@askexenow/exe-os 0.8.83 → 0.8.86

package/dist/hooks/prompt-submit.js

@@ -408,6 +408,12 @@ function getClient() {
   if (!_resilientClient) {
     throw new Error("Database client not initialized. Call initDatabase() first.");
   }
+  if (process.env.EXE_IS_DAEMON === "1") {
+    return _resilientClient;
+  }
+  if (_daemonClient && _daemonClient._isDaemonActive()) {
+    return _daemonClient;
+  }
   return _resilientClient;
 }
 function getRawClient() {
@@ -896,6 +902,12 @@ async function ensureSchema() {
     } catch {
     }
   }
+  try {
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_content_hash ON memories(content_hash, agent_id)`
+    );
+  } catch {
+  }
   await client.executeMultiple(`
     CREATE TABLE IF NOT EXISTS entities (
       id TEXT PRIMARY KEY,
@@ -948,7 +960,30 @@ async function ensureSchema() {
       entity_id TEXT NOT NULL,
       PRIMARY KEY (hyperedge_id, entity_id)
     );
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS entities_fts USING fts5(
+      name,
+      content=entities,
+      content_rowid=rowid
+    );
+
+    CREATE TRIGGER IF NOT EXISTS entities_fts_ai AFTER INSERT ON entities BEGIN
+      INSERT INTO entities_fts(rowid, name) VALUES (new.rowid, new.name);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS entities_fts_ad AFTER DELETE ON entities BEGIN
+      INSERT INTO entities_fts(entities_fts, rowid, name) VALUES('delete', old.rowid, old.name);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS entities_fts_au AFTER UPDATE ON entities BEGIN
+      INSERT INTO entities_fts(entities_fts, rowid, name) VALUES('delete', old.rowid, old.name);
+      INSERT INTO entities_fts(rowid, name) VALUES (new.rowid, new.name);
+    END;
   `);
+  try {
+    await client.execute("INSERT INTO entities_fts(entities_fts) VALUES('rebuild')");
+  } catch {
+  }
   await client.executeMultiple(`
     CREATE TABLE IF NOT EXISTS entity_aliases (
       alias TEXT NOT NULL PRIMARY KEY,
@@ -1129,6 +1164,33 @@ async function ensureSchema() {
     CREATE INDEX IF NOT EXISTS idx_conversations_channel
       ON conversations(channel_id);
   `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS session_agent_map (
+      session_uuid TEXT PRIMARY KEY,
+      agent_id TEXT NOT NULL,
+      session_name TEXT,
+      task_id TEXT,
+      project_name TEXT,
+      started_at TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_session_agent_map_agent
+      ON session_agent_map(agent_id);
+  `);
+  try {
+    const mapCount = await client.execute({ sql: `SELECT COUNT(*) as cnt FROM session_agent_map`, args: [] });
+    if (Number(mapCount.rows[0]?.cnt ?? 0) === 0) {
+      await client.execute({
+        sql: `INSERT OR IGNORE INTO session_agent_map (session_uuid, agent_id, session_name, started_at)
+              SELECT session_id, agent_id, '', MIN(timestamp)
+              FROM memories
+              WHERE session_id IS NOT NULL AND session_id != '' AND agent_id IS NOT NULL AND agent_id != ''
+              GROUP BY session_id, agent_id`,
+        args: []
+      });
+    }
+  } catch {
+  }
   try {
     await client.execute({
       sql: `ALTER TABLE tasks ADD COLUMN budget_tokens INTEGER`,
@@ -1262,15 +1324,41 @@ async function ensureSchema() {
     });
   } catch {
   }
+  for (const col of [
+    "ALTER TABLE memories ADD COLUMN intent TEXT",
+    "ALTER TABLE memories ADD COLUMN outcome TEXT",
+    "ALTER TABLE memories ADD COLUMN domain TEXT",
+    "ALTER TABLE memories ADD COLUMN referenced_entities TEXT",
+    "ALTER TABLE memories ADD COLUMN retrieval_count INTEGER DEFAULT 0",
+    "ALTER TABLE memories ADD COLUMN chain_position TEXT",
+    "ALTER TABLE memories ADD COLUMN review_status TEXT",
+    "ALTER TABLE memories ADD COLUMN context_window_pct INTEGER",
+    "ALTER TABLE memories ADD COLUMN file_paths TEXT",
+    "ALTER TABLE memories ADD COLUMN commit_hash TEXT",
+    "ALTER TABLE memories ADD COLUMN duration_ms INTEGER",
+    "ALTER TABLE memories ADD COLUMN token_cost REAL",
+    "ALTER TABLE memories ADD COLUMN audience TEXT",
+    "ALTER TABLE memories ADD COLUMN language_type TEXT",
+    "ALTER TABLE memories ADD COLUMN parent_memory_id TEXT"
+  ]) {
+    try {
+      await client.execute(col);
+    } catch {
+    }
+  }
 }
 async function disposeDatabase() {
+  if (_daemonClient) {
+    _daemonClient.close();
+    _daemonClient = null;
+  }
   if (_client) {
     _client.close();
     _client = null;
     _resilientClient = null;
   }
 }
-var _client, _resilientClient, initTurso, disposeTurso;
+var _client, _resilientClient, _daemonClient, initTurso, disposeTurso;
 var init_database = __esm({
   "src/lib/database.ts"() {
     "use strict";
@@ -1278,6 +1366,7 @@ var init_database = __esm({
     init_employees();
     _client = null;
     _resilientClient = null;
+    _daemonClient = null;
     initTurso = initDatabase;
     disposeTurso = disposeDatabase;
   }
@@ -1314,12 +1403,20 @@ async function getMasterKey() {
   }
   const keyPath = getKeyPath();
   if (!existsSync3(keyPath)) {
+    process.stderr.write(
+      `[keychain] Key not found at ${keyPath} (HOME=${os3.homedir()}, EXE_OS_DIR=${process.env.EXE_OS_DIR ?? "unset"})
+`
+    );
     return null;
   }
   try {
     const content = await readFile3(keyPath, "utf-8");
     return Buffer.from(content.trim(), "base64");
-  } catch {
+  } catch (err) {
+    process.stderr.write(
+      `[keychain] Key read failed at ${keyPath}: ${err instanceof Error ? err.message : String(err)}
+`
+    );
     return null;
   }
 }
@@ -1830,6 +1927,7 @@ __export(store_exports, {
   vectorToBlob: () => vectorToBlob,
   writeMemory: () => writeMemory
 });
+import { createHash } from "crypto";
 function isBusyError2(err) {
   if (err instanceof Error) {
     const msg = err.message.toLowerCase();
@@ -1903,12 +2001,52 @@ function classifyTier(record) {
   if (["store_memory", "manual"].includes(record.tool_name ?? "") && (record.importance ?? 0) >= 5) return 2;
   return 3;
 }
+function inferFilePaths(record) {
+  if (!["Read", "Write", "Edit"].includes(record.tool_name)) return null;
+  const firstLine = record.raw_text.split("\n")[0] ?? "";
+  const match = firstLine.match(/(\/[\w./-]+\.\w+)/);
+  return match ? JSON.stringify([match[1]]) : null;
+}
+function inferCommitHash(record) {
+  if (record.tool_name !== "Bash") return null;
+  const match = record.raw_text.match(/\b([a-f0-9]{7,40})\b/);
+  return match ? match[1] : null;
+}
+function inferLanguageType(record) {
+  const text = record.raw_text;
+  if (!text || text.length < 10) return null;
+  const trimmed = text.trimStart();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) return "json";
+  if (/\b(SELECT|INSERT|UPDATE|DELETE|CREATE TABLE|ALTER TABLE)\b/i.test(text)) return "sql";
+  if (/\b(function |const |import |export |class |def |async |=>)\b/.test(text)) return "code";
+  if (trimmed.startsWith("#") || trimmed.startsWith("*")) return "prose";
+  return "mixed";
+}
+function inferDomain(record) {
+  const proj = (record.project_name ?? "").toLowerCase();
+  if (proj.includes("marketing") || proj.includes("content")) return "marketing";
+  if (proj.includes("crm") || proj.includes("customer")) return "customer";
+  return null;
+}
 async function writeMemory(record) {
   if (record.vector !== null && record.vector.length !== EMBEDDING_DIM) {
     throw new Error(
       `Expected ${EMBEDDING_DIM}-dim vector, got ${record.vector.length}`
     );
   }
+  const contentHash = createHash("md5").update(record.raw_text).digest("hex");
+  if (_pendingRecords.some((r) => r.content_hash === contentHash && r.agent_id === record.agent_id)) {
+    return;
+  }
+  try {
+    const client = getClient();
+    const existing = await client.execute({
+      sql: "SELECT id FROM memories WHERE content_hash = ? AND agent_id = ? LIMIT 1",
+      args: [contentHash, record.agent_id]
+    });
+    if (existing.rows.length > 0) return;
+  } catch {
+  }
   const dbRow = {
     id: record.id,
     agent_id: record.agent_id,
@@ -1938,7 +2076,23 @@ async function writeMemory(record) {
     supersedes_id: record.supersedes_id ?? null,
     draft: record.draft ? 1 : 0,
     memory_type: record.memory_type ?? "raw",
-    trajectory: record.trajectory ? JSON.stringify(record.trajectory) : null
+    trajectory: record.trajectory ? JSON.stringify(record.trajectory) : null,
+    content_hash: contentHash,
+    intent: record.intent ?? null,
+    outcome: record.outcome ?? null,
+    domain: record.domain ?? inferDomain(record),
+    referenced_entities: record.referenced_entities ?? null,
+    retrieval_count: record.retrieval_count ?? 0,
+    chain_position: record.chain_position ?? null,
+    review_status: record.review_status ?? null,
+    context_window_pct: record.context_window_pct ?? null,
+    file_paths: record.file_paths ?? inferFilePaths(record),
+    commit_hash: record.commit_hash ?? inferCommitHash(record),
+    duration_ms: record.duration_ms ?? null,
+    token_cost: record.token_cost ?? null,
+    audience: record.audience ?? null,
+    language_type: record.language_type ?? inferLanguageType(record),
+    parent_memory_id: record.parent_memory_id ?? null
   };
   _pendingRecords.push(dbRow);
   orgBus.emit({
@@ -1996,80 +2150,85 @@ async function flushBatch() {
       const draft = row.draft ? 1 : 0;
       const memoryType = row.memory_type ?? "raw";
       const trajectory = row.trajectory ?? null;
-      return {
-        sql: hasVector ? `INSERT OR IGNORE INTO memories
-              (id, agent_id, agent_role, session_id, timestamp,
+      const contentHash = row.content_hash ?? null;
+      const intent = row.intent ?? null;
+      const outcome = row.outcome ?? null;
+      const domain = row.domain ?? null;
+      const referencedEntities = row.referenced_entities ?? null;
+      const retrievalCount = row.retrieval_count ?? 0;
+      const chainPosition = row.chain_position ?? null;
+      const reviewStatus = row.review_status ?? null;
+      const contextWindowPct = row.context_window_pct ?? null;
+      const filePaths = row.file_paths ?? null;
+      const commitHash = row.commit_hash ?? null;
+      const durationMs = row.duration_ms ?? null;
+      const tokenCost = row.token_cost ?? null;
+      const audience = row.audience ?? null;
+      const languageType = row.language_type ?? null;
+      const parentMemoryId = row.parent_memory_id ?? null;
+      const cols = `id, agent_id, agent_role, session_id, timestamp,
                tool_name, project_name,
                has_error, raw_text, vector, version, task_id, importance, status,
                confidence, last_accessed,
                workspace_id, document_id, user_id, char_offset, page_number,
-               source_path, source_type, tier, supersedes_id, draft, memory_type, trajectory)
-              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, vector32(?), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)` : `INSERT OR IGNORE INTO memories
-              (id, agent_id, agent_role, session_id, timestamp,
-               tool_name, project_name,
-               has_error, raw_text, vector, version, task_id, importance, status,
-               confidence, last_accessed,
-               workspace_id, document_id, user_id, char_offset, page_number,
-               source_path, source_type, tier, supersedes_id, draft, memory_type, trajectory)
-              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-        args: hasVector ? [
-          row.id,
-          row.agent_id,
-          row.agent_role,
-          row.session_id,
-          row.timestamp,
-          row.tool_name,
-          row.project_name,
-          row.has_error,
-          row.raw_text,
-          vectorToBlob(row.vector),
-          row.version,
-          taskId,
-          importance,
-          status,
-          confidence,
-          lastAccessed,
-          workspaceId,
-          documentId,
-          userId,
-          charOffset,
-          pageNumber,
-          sourcePath,
-          sourceType,
-          tier,
-          supersedesId,
-          draft,
-          memoryType,
-          trajectory
-        ] : [
-          row.id,
-          row.agent_id,
-          row.agent_role,
-          row.session_id,
-          row.timestamp,
-          row.tool_name,
-          row.project_name,
-          row.has_error,
-          row.raw_text,
-          row.version,
-          taskId,
-          importance,
-          status,
-          confidence,
-          lastAccessed,
-          workspaceId,
-          documentId,
-          userId,
-          charOffset,
-          pageNumber,
-          sourcePath,
-          sourceType,
-          tier,
-          supersedesId,
-          draft,
-          memoryType,
-          trajectory
-        ]
+               source_path, source_type, tier, supersedes_id, draft, memory_type, trajectory, content_hash,
+               intent, outcome, domain, referenced_entities, retrieval_count,
+               chain_position, review_status, context_window_pct, file_paths, commit_hash,
+               duration_ms, token_cost, audience, language_type, parent_memory_id`;
+      const metaArgs = [
+        intent,
+        outcome,
+        domain,
+        referencedEntities,
+        retrievalCount,
+        chainPosition,
+        reviewStatus,
+        contextWindowPct,
+        filePaths,
+        commitHash,
+        durationMs,
+        tokenCost,
+        audience,
+        languageType,
+        parentMemoryId
+      ];
+      const baseArgs = [
+        row.id,
+        row.agent_id,
+        row.agent_role,
+        row.session_id,
+        row.timestamp,
+        row.tool_name,
+        row.project_name,
+        row.has_error,
+        row.raw_text
+      ];
+      const sharedArgs = [
+        row.version,
+        taskId,
+        importance,
+        status,
+        confidence,
+        lastAccessed,
+        workspaceId,
+        documentId,
+        userId,
+        charOffset,
+        pageNumber,
+        sourcePath,
+        sourceType,
+        tier,
+        supersedesId,
+        draft,
+        memoryType,
+        trajectory,
+        contentHash
+      ];
+      return {
+        sql: hasVector ? `INSERT OR IGNORE INTO memories (${cols})
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, vector32(?), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)` : `INSERT OR IGNORE INTO memories (${cols})
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        args: hasVector ? [...baseArgs, vectorToBlob(row.vector), ...sharedArgs, ...metaArgs] : [...baseArgs, ...sharedArgs, ...metaArgs]
       };
     };
     const globalClient = getClient();
@@ -2408,12 +2567,141 @@ var init_self_query_router = __esm({
   }
 });
 
+// src/lib/reranker.ts
+var reranker_exports = {};
+__export(reranker_exports, {
+  disposeReranker: () => disposeReranker,
+  getRerankerModelPath: () => getRerankerModelPath,
+  isRerankerAvailable: () => isRerankerAvailable,
+  rerank: () => rerank,
+  rerankWithContext: () => rerankWithContext,
+  rerankWithScores: () => rerankWithScores
+});
+import path5 from "path";
+import { existsSync as existsSync5 } from "fs";
+function resetIdleTimer() {
+  if (_idleTimer) clearTimeout(_idleTimer);
+  _idleTimer = setTimeout(() => {
+    void disposeReranker();
+  }, IDLE_TIMEOUT_MS);
+  if (_idleTimer && typeof _idleTimer === "object" && "unref" in _idleTimer) {
+    _idleTimer.unref();
+  }
+}
+function isRerankerAvailable() {
+  return existsSync5(path5.join(MODELS_DIR, RERANKER_MODEL_FILE));
+}
+function getRerankerModelPath() {
+  return path5.join(MODELS_DIR, RERANKER_MODEL_FILE);
+}
+async function ensureLoaded() {
+  if (_rerankerContext) {
+    resetIdleTimer();
+    return;
+  }
+  const modelPath = path5.join(MODELS_DIR, RERANKER_MODEL_FILE);
+  if (!existsSync5(modelPath)) {
+    throw new Error(
+      `Reranker model not found at ${modelPath}. Run /exe-setup to download it.`
+    );
+  }
+  process.stderr.write("[reranker] Loading Jina Reranker v3...\n");
+  const { getLlama } = await import("node-llama-cpp");
+  const llama = await getLlama();
+  _rerankerModel = await llama.loadModel({ modelPath });
+  _rerankerContext = await _rerankerModel.createEmbeddingContext();
+  process.stderr.write("[reranker] Jina Reranker v3 loaded.\n");
+  resetIdleTimer();
+}
+async function disposeReranker() {
+  if (_idleTimer) {
+    clearTimeout(_idleTimer);
+    _idleTimer = null;
+  }
+  if (_rerankerContext) {
+    try {
+      await _rerankerContext.dispose();
+    } catch {
+    }
+    _rerankerContext = null;
+  }
+  if (_rerankerModel) {
+    try {
+      await _rerankerModel.dispose();
+    } catch {
+    }
+    _rerankerModel = null;
+  }
+  process.stderr.write("[reranker] Unloaded (idle timeout).\n");
+}
+async function rerankWithScores(query, texts, topK) {
+  if (texts.length === 0) return [];
+  await ensureLoaded();
+  const ctx = _rerankerContext;
+  const scored = [];
+  for (let i = 0; i < texts.length; i++) {
+    const text = texts[i] ?? "";
+    try {
+      const input2 = `query: ${query} document: ${text.slice(0, 512)}`;
+      const embedding = await ctx.getEmbeddingFor(input2);
+      const score = embedding.vector[0] ?? 0;
+      scored.push({ text, score, index: i });
+    } catch {
+      scored.push({ text, score: -1, index: i });
+    }
+  }
+  scored.sort((a, b) => b.score - a.score);
+  return typeof topK === "number" ? scored.slice(0, topK) : scored;
+}
+async function rerank(query, candidates, topK = 5) {
+  if (candidates.length === 0) return [];
+  if (candidates.length <= topK) return candidates;
+  const scored = await rerankWithScores(
+    query,
+    candidates.map((c) => c.raw_text),
+    topK
+  );
+  return scored.map((s) => candidates[s.index]);
+}
+async function rerankWithContext(query, candidates, topK) {
+  if (candidates.length === 0) return [];
+  await ensureLoaded();
+  const ctx = _rerankerContext;
+  const scored = [];
+  for (let i = 0; i < candidates.length; i++) {
+    const candidate = candidates[i];
+    try {
+      const docText = candidate.context ? `[${candidate.context}] ${candidate.text.slice(0, 460)}` : candidate.text.slice(0, 512);
+      const input2 = `query: ${query} document: ${docText}`;
+      const embedding = await ctx.getEmbeddingFor(input2);
+      const score = embedding.vector[0] ?? 0;
+      scored.push({ text: candidate.text, score, index: i });
+    } catch {
+      scored.push({ text: candidate.text, score: -1, index: i });
+    }
+  }
+  scored.sort((a, b) => b.score - a.score);
+  return typeof topK === "number" ? scored.slice(0, topK) : scored;
+}
+var RERANKER_MODEL_FILE, IDLE_TIMEOUT_MS, _rerankerContext, _rerankerModel, _idleTimer;
+var init_reranker = __esm({
+  "src/lib/reranker.ts"() {
+    "use strict";
+    init_config();
+    RERANKER_MODEL_FILE = "jina-reranker-v3-q4_k_m.gguf";
+    IDLE_TIMEOUT_MS = 6e4;
+    _rerankerContext = null;
+    _rerankerModel = null;
+    _idleTimer = null;
+  }
+});
+
 // src/lib/exe-daemon-client.ts
 import net from "net";
 import { spawn } from "child_process";
 import { randomUUID as randomUUID2 } from "crypto";
-import { existsSync as existsSync5, unlinkSync as unlinkSync2, readFileSync as readFileSync3, openSync, closeSync, statSync } from "fs";
-import path5 from "path";
+import { existsSync as existsSync6, unlinkSync as unlinkSync2, readFileSync as readFileSync3, openSync, closeSync, statSync } from "fs";
+import path6 from "path";
 import { fileURLToPath } from "url";
 function handleData(chunk) {
   _buffer += chunk.toString();
@@ -2428,10 +2716,12 @@ function handleData(chunk) {
     if (!line) continue;
     try {
       const response = JSON.parse(line);
-      const entry = _pending.get(response.id);
+      const id = response.id;
+      if (!id) continue;
+      const entry = _pending.get(id);
       if (entry) {
         clearTimeout(entry.timer);
-        _pending.delete(response.id);
+        _pending.delete(id);
         entry.resolve(response);
       }
     } catch {
@@ -2439,7 +2729,7 @@ function handleData(chunk) {
   }
 }
 function cleanupStaleFiles() {
-  if (existsSync5(PID_PATH)) {
+  if (existsSync6(PID_PATH)) {
     try {
       const pid = parseInt(readFileSync3(PID_PATH, "utf8").trim(), 10);
       if (pid > 0) {
@@ -2462,11 +2752,11 @@ function cleanupStaleFiles() {
   }
 }
 function findPackageRoot() {
-  let dir = path5.dirname(fileURLToPath(import.meta.url));
-  const { root } = path5.parse(dir);
+  let dir = path6.dirname(fileURLToPath(import.meta.url));
+  const { root } = path6.parse(dir);
   while (dir !== root) {
-    if (existsSync5(path5.join(dir, "package.json"))) return dir;
-    dir = path5.dirname(dir);
+    if (existsSync6(path6.join(dir, "package.json"))) return dir;
+    dir = path6.dirname(dir);
   }
   return null;
 }
@@ -2476,8 +2766,8 @@ function spawnDaemon() {
     process.stderr.write("[exed-client] WARN: cannot find package root\n");
     return;
   }
-  const daemonPath = path5.join(pkgRoot, "dist", "lib", "exe-daemon.js");
-  if (!existsSync5(daemonPath)) {
+  const daemonPath = path6.join(pkgRoot, "dist", "lib", "exe-daemon.js");
+  if (!existsSync6(daemonPath)) {
     process.stderr.write(`[exed-client] WARN: daemon script not found at ${daemonPath}
 `);
     return;
@@ -2485,7 +2775,7 @@ function spawnDaemon() {
   const resolvedPath = daemonPath;
   process.stderr.write(`[exed-client] Spawning daemon: ${resolvedPath}
 `);
-  const logPath = path5.join(path5.dirname(SOCKET_PATH), "exed.log");
+  const logPath = path6.join(path6.dirname(SOCKET_PATH), "exed.log");
   let stderrFd = "ignore";
   try {
     stderrFd = openSync(logPath, "a");
@@ -2602,6 +2892,9 @@ async function connectEmbedDaemon() {
   return false;
 }
 function sendRequest(texts, priority) {
+  return sendDaemonRequest({ texts, priority });
+}
+function sendDaemonRequest(payload, timeoutMs = REQUEST_TIMEOUT_MS) {
   return new Promise((resolve) => {
     if (!_socket || !_connected) {
       resolve({ error: "Not connected" });
@@ -2611,10 +2904,10 @@ function sendRequest(texts, priority) {
     const timer = setTimeout(() => {
       _pending.delete(id);
       resolve({ error: "Request timeout" });
-    }, REQUEST_TIMEOUT_MS);
+    }, timeoutMs);
     _pending.set(id, { resolve, timer });
     try {
-      _socket.write(JSON.stringify({ id, texts, priority }) + "\n");
+      _socket.write(JSON.stringify({ id, ...payload }) + "\n");
     } catch {
       clearTimeout(timer);
       _pending.delete(id);
@@ -2624,34 +2917,15 @@ function sendRequest(texts, priority) {
 }
 async function pingDaemon() {
   if (!_socket || !_connected) return null;
-  return new Promise((resolve) => {
-    const id = randomUUID2();
-    const timer = setTimeout(() => {
-      _pending.delete(id);
-      resolve(null);
-    }, 5e3);
-    _pending.set(id, {
-      resolve: (data) => {
-        if (data.health) {
-          resolve(data.health);
-        } else {
-          resolve(null);
-        }
-      },
-      timer
-    });
-    try {
-      _socket.write(JSON.stringify({ id, type: "health" }) + "\n");
-    } catch {
-      clearTimeout(timer);
-      _pending.delete(id);
-      resolve(null);
-    }
-  });
+  const response = await sendDaemonRequest({ type: "health" }, 5e3);
+  if (response.health) {
+    return response.health;
+  }
+  return null;
 }
 function killAndRespawnDaemon() {
   process.stderr.write("[exed-client] Killing daemon for restart...\n");
-  if (existsSync5(PID_PATH)) {
+  if (existsSync6(PID_PATH)) {
     try {
       const pid = parseInt(readFileSync3(PID_PATH, "utf8").trim(), 10);
       if (pid > 0) {
@@ -2737,9 +3011,9 @@ var init_exe_daemon_client = __esm({
   "src/lib/exe-daemon-client.ts"() {
     "use strict";
     init_config();
-    SOCKET_PATH = process.env.EXE_DAEMON_SOCK ?? process.env.EXE_EMBED_SOCK ?? path5.join(EXE_AI_DIR, "exed.sock");
-    PID_PATH = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path5.join(EXE_AI_DIR, "exed.pid");
-    SPAWN_LOCK_PATH = path5.join(EXE_AI_DIR, "exed-spawn.lock");
+    SOCKET_PATH = process.env.EXE_DAEMON_SOCK ?? process.env.EXE_EMBED_SOCK ?? path6.join(EXE_AI_DIR, "exed.sock");
+    PID_PATH = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path6.join(EXE_AI_DIR, "exed.pid");
+    SPAWN_LOCK_PATH = path6.join(EXE_AI_DIR, "exed-spawn.lock");
     SPAWN_LOCK_STALE_MS = 3e4;
     CONNECT_TIMEOUT_MS = 15e3;
     REQUEST_TIMEOUT_MS = 3e4;
@@ -2790,10 +3064,10 @@ async function disposeEmbedder() {
 async function embedDirect(text) {
   const llamaCpp = await import("node-llama-cpp");
   const { MODELS_DIR: MODELS_DIR2 } = await Promise.resolve().then(() => (init_config(), config_exports));
-  const { existsSync: existsSync15 } = await import("fs");
-  const path18 = await import("path");
-  const modelPath = path18.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
-  if (!existsSync15(modelPath)) {
+  const { existsSync: existsSync16 } = await import("fs");
+  const path19 = await import("path");
+  const modelPath = path19.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
+  if (!existsSync16(modelPath)) {
     throw new Error(`Embedding model not found at ${modelPath}. Run '/exe-setup' to download it.`);
   }
   const llama = await llamaCpp.getLlama();
@@ -2828,7 +3102,7 @@ __export(project_name_exports, {
   getProjectName: () => getProjectName
 });
 import { execSync as execSync2 } from "child_process";
-import path6 from "path";
+import path7 from "path";
 function getProjectName(cwd) {
   const dir = cwd ?? process.cwd();
   if (_cached && _cachedCwd === dir) return _cached;
@@ -2841,7 +3115,7 @@ function getProjectName(cwd) {
         timeout: 2e3,
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
-      repoRoot = path6.dirname(gitCommonDir);
+      repoRoot = path7.dirname(gitCommonDir);
     } catch {
       repoRoot = execSync2("git rev-parse --show-toplevel", {
         cwd: dir,
@@ -2850,11 +3124,11 @@ function getProjectName(cwd) {
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
     }
-    _cached = path6.basename(repoRoot);
+    _cached = path7.basename(repoRoot);
     _cachedCwd = dir;
     return _cached;
   } catch {
-    _cached = path6.basename(dir);
+    _cached = path7.basename(dir);
     _cachedCwd = dir;
     return _cached;
   }
@@ -2878,8 +3152,8 @@ __export(file_grep_exports, {
   grepProjectFiles: () => grepProjectFiles
 });
 import { execSync as execSync3 } from "child_process";
-import { readFileSync as readFileSync4, readdirSync as readdirSync2, statSync as statSync2, existsSync as existsSync6 } from "fs";
-import path7 from "path";
+import { readFileSync as readFileSync4, readdirSync as readdirSync2, statSync as statSync2, existsSync as existsSync7 } from "fs";
+import path8 from "path";
 import crypto from "crypto";
 function hasRipgrep() {
   if (_hasRg === null) {
@@ -2919,7 +3193,7 @@ async function grepProjectFiles(query, projectRoot, options) {
       session_id: "file-grep",
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       tool_name: "file_grep",
-      project_name: path7.basename(projectRoot),
+      project_name: path8.basename(projectRoot),
       has_error: false,
       raw_text: `${prefix} ${buildSnippet(hit, projectRoot)}`,
       vector: null,
@@ -2993,7 +3267,7 @@ function grepWithNodeFs(pattern, projectRoot, patterns) {
   const files = collectFiles(projectRoot, patterns ?? DEFAULT_PATTERNS);
   const hits = [];
   for (const filePath of files.slice(0, MAX_FILES)) {
-    const absPath = path7.join(projectRoot, filePath);
+    const absPath = path8.join(projectRoot, filePath);
     try {
       const stat = statSync2(absPath);
       if (stat.size > MAX_FILE_SIZE) continue;
@@ -3020,15 +3294,15 @@ function collectFiles(root, patterns) {
   const files = [];
   function walk(dir, relative) {
     if (files.length >= MAX_FILES) return;
-    const basename = path7.basename(dir);
+    const basename = path8.basename(dir);
     if (EXCLUDE_DIRS.includes(basename)) return;
     try {
       const entries = readdirSync2(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (files.length >= MAX_FILES) return;
-        const rel = path7.join(relative, entry.name);
+        const rel = path8.join(relative, entry.name);
         if (entry.isDirectory()) {
-          walk(path7.join(dir, entry.name), rel);
+          walk(path8.join(dir, entry.name), rel);
         } else if (entry.isFile()) {
           for (const pat of patterns) {
             if (matchGlob(rel, pat)) {
@@ -3060,7 +3334,7 @@ function matchGlob(filePath, pattern) {
   if (slashIdx !== -1) {
     const dir = pattern.slice(0, slashIdx);
     const ext2 = pattern.slice(slashIdx + 1).replace("*", "");
-    const fileDir = path7.dirname(filePath);
+    const fileDir = path8.dirname(filePath);
     return fileDir === dir && filePath.endsWith(ext2);
   }
   const ext = pattern.replace("*", "");
@@ -3068,8 +3342,8 @@ function matchGlob(filePath, pattern) {
 }
 function buildSnippet(hit, projectRoot) {
   try {
-    const absPath = path7.join(projectRoot, hit.filePath);
-    if (!existsSync6(absPath)) return hit.matchLine;
+    const absPath = path8.join(projectRoot, hit.filePath);
+    if (!existsSync7(absPath)) return hit.matchLine;
     const lines = readFileSync4(absPath, "utf8").split("\n");
     const start = Math.max(0, hit.lineNumber - 3);
     const end = Math.min(lines.length, hit.lineNumber + 2);
@@ -3095,111 +3369,574 @@ var init_file_grep = __esm({
   }
 });
 
-// src/lib/reranker.ts
-var reranker_exports = {};
-__export(reranker_exports, {
-  disposeReranker: () => disposeReranker,
-  getRerankerModelPath: () => getRerankerModelPath,
-  isRerankerAvailable: () => isRerankerAvailable,
-  rerank: () => rerank,
-  rerankWithScores: () => rerankWithScores
+// src/lib/graph-query.ts
+var graph_query_exports = {};
+__export(graph_query_exports, {
+  getConversationPartners: () => getConversationPartners,
+  getEntityByName: () => getEntityByName,
+  getEntityNeighbors: () => getEntityNeighbors,
+  getEntityTimeline: () => getEntityTimeline,
+  getGraphStats: () => getGraphStats,
+  getHotEntities: () => getHotEntities,
+  getRelationshipFrequency: () => getRelationshipFrequency,
+  getRelationships: () => getRelationships,
+  searchEntities: () => searchEntities,
+  traverseChain: () => traverseChain
 });
-import path8 from "path";
-import { existsSync as existsSync7 } from "fs";
-function resetIdleTimer() {
-  if (_idleTimer) clearTimeout(_idleTimer);
-  _idleTimer = setTimeout(() => {
-    void disposeReranker();
-  }, IDLE_TIMEOUT_MS);
-  if (_idleTimer && typeof _idleTimer === "object" && "unref" in _idleTimer) {
-    _idleTimer.unref();
+async function getEntityByName(client, name, type) {
+  const sql = type ? `SELECT * FROM entities WHERE LOWER(name) = LOWER(?) AND type = ? LIMIT 1` : `SELECT * FROM entities WHERE LOWER(name) = LOWER(?) LIMIT 1`;
+  const args = type ? [name, type] : [name];
+  const result = await client.execute({ sql, args });
+  if (result.rows.length === 0) return null;
+  const row = result.rows[0];
+  return {
+    id: String(row.id),
+    name: String(row.name),
+    type: String(row.type),
+    firstSeen: String(row.first_seen),
+    lastSeen: String(row.last_seen),
+    properties: JSON.parse(String(row.properties ?? "{}"))
+  };
+}
+async function searchEntities(client, query, limit = 10) {
+  const result = await client.execute({
+    sql: `SELECT * FROM entities WHERE LOWER(name) LIKE ? ORDER BY last_seen DESC LIMIT ?`,
+    args: [`%${query.toLowerCase()}%`, limit]
+  });
+  return result.rows.map((row) => ({
+    id: String(row.id),
+    name: String(row.name),
+    type: String(row.type),
+    firstSeen: String(row.first_seen),
+    lastSeen: String(row.last_seen),
+    properties: JSON.parse(String(row.properties ?? "{}"))
+  }));
+}
+async function getRelationships(client, entityId, options) {
+  const direction = options?.direction ?? "both";
+  let sql;
+  const args = [];
+  if (direction === "outgoing") {
+    sql = `SELECT r.*, s.name as source_name, t.name as target_name
+           FROM relationships r
+           JOIN entities s ON r.source_entity_id = s.id
+           JOIN entities t ON r.target_entity_id = t.id
+           WHERE r.source_entity_id = ?`;
+    args.push(entityId);
+  } else if (direction === "incoming") {
+    sql = `SELECT r.*, s.name as source_name, t.name as target_name
+           FROM relationships r
+           JOIN entities s ON r.source_entity_id = s.id
+           JOIN entities t ON r.target_entity_id = t.id
+           WHERE r.target_entity_id = ?`;
+    args.push(entityId);
+  } else {
+    sql = `SELECT r.*, s.name as source_name, t.name as target_name
+           FROM relationships r
+           JOIN entities s ON r.source_entity_id = s.id
+           JOIN entities t ON r.target_entity_id = t.id
+           WHERE r.source_entity_id = ? OR r.target_entity_id = ?`;
+    args.push(entityId, entityId);
+  }
+  if (options?.type) {
+    sql += ` AND r.type = ?`;
+    args.push(options.type);
+  }
+  sql += ` ORDER BY r.weight DESC, r.timestamp DESC`;
+  const result = await client.execute({ sql, args });
+  return result.rows.map((row) => ({
+    id: String(row.id),
+    sourceEntityId: String(row.source_entity_id),
+    targetEntityId: String(row.target_entity_id),
+    type: String(row.type),
+    weight: Number(row.weight),
+    timestamp: String(row.timestamp),
+    properties: JSON.parse(String(row.properties ?? "{}")),
+    confidence: Number(row.confidence ?? 1),
+    confidenceLabel: String(row.confidence_label ?? "extracted"),
+    sourceName: String(row.source_name),
+    targetName: String(row.target_name)
+  }));
+}
+async function traverseChain(client, startEntityId, relationshipType, maxDepth = 3) {
+  const result = await client.execute({
+    sql: `WITH RECURSIVE chain(entity_id, depth, rel_type) AS (
+            SELECT ?, 0, ''
+            UNION ALL
+            SELECT r.target_entity_id, c.depth + 1, r.type
+            FROM chain c
+            JOIN relationships r ON r.source_entity_id = c.entity_id
+            WHERE r.type = ? AND c.depth < ?
+          )
+          SELECT DISTINCT e.*, chain.depth, chain.rel_type
+          FROM chain
+          JOIN entities e ON e.id = chain.entity_id
+          ORDER BY chain.depth ASC`,
+    args: [startEntityId, relationshipType, maxDepth]
+  });
+  return result.rows.map((row) => ({
+    entity: {
+      id: String(row.id),
+      name: String(row.name),
+      type: String(row.type),
+      firstSeen: String(row.first_seen),
+      lastSeen: String(row.last_seen),
+      properties: JSON.parse(String(row.properties ?? "{}"))
+    },
+    depth: Number(row.depth),
+    relationship: String(row.rel_type)
+  }));
+}
+async function getEntityNeighbors(client, entityId, maxHops = 2) {
+  const result = await client.execute({
+    sql: `WITH RECURSIVE neighborhood(entity_id, depth, rel_type, rel_confidence) AS (
+            SELECT ?, 0, '', 1.0
+            UNION ALL
+            SELECT CASE
+              WHEN r.source_entity_id = n.entity_id THEN r.target_entity_id
+              ELSE r.source_entity_id
+            END, n.depth + 1, r.type, COALESCE(r.confidence, 1.0)
+            FROM neighborhood n
+            JOIN relationships r ON r.source_entity_id = n.entity_id
+                                 OR r.target_entity_id = n.entity_id
+            WHERE n.depth < ?
+          )
+          SELECT DISTINCT e.*, MIN(neighborhood.depth) as depth,
+                 neighborhood.rel_type, neighborhood.rel_confidence
+          FROM neighborhood
+          JOIN entities e ON e.id = neighborhood.entity_id
+          GROUP BY e.id
+          ORDER BY depth ASC, e.last_seen DESC
+          LIMIT 50`,
+    args: [entityId, maxHops]
+  });
+  return result.rows.map((row) => ({
+    entity: {
+      id: String(row.id),
+      name: String(row.name),
+      type: String(row.type),
+      firstSeen: String(row.first_seen),
+      lastSeen: String(row.last_seen),
+      properties: JSON.parse(String(row.properties ?? "{}"))
+    },
+    depth: Number(row.depth),
+    relType: String(row.rel_type ?? ""),
+    relConfidence: Number(row.rel_confidence ?? 1)
+  }));
+}
+async function getGraphStats(client) {
+  const entityCount = await client.execute("SELECT COUNT(*) as cnt FROM entities");
+  const relCount = await client.execute("SELECT COUNT(*) as cnt FROM relationships");
+  const typeResult = await client.execute(
+    "SELECT type, COUNT(*) as cnt FROM entities GROUP BY type ORDER BY cnt DESC"
+  );
+  const types = {};
+  for (const row of typeResult.rows) {
+    types[String(row.type)] = Number(row.cnt);
   }
+  return {
+    entities: Number(entityCount.rows[0]?.cnt ?? 0),
+    relationships: Number(relCount.rows[0]?.cnt ?? 0),
+    types
+  };
 }
-function isRerankerAvailable() {
-  return existsSync7(path8.join(MODELS_DIR, RERANKER_MODEL_FILE));
+async function getEntityTimeline(client, entityId, since) {
+  const args = [entityId, entityId];
+  let sinceClause = "";
+  if (since) {
+    sinceClause = " AND r.timestamp >= ?";
+    args.push(since.toISOString());
+  }
+  const result = await client.execute({
+    sql: `SELECT r.*, s.name as source_name, t.name as target_name
+          FROM relationships r
+          JOIN entities s ON r.source_entity_id = s.id
+          JOIN entities t ON r.target_entity_id = t.id
+          WHERE (r.source_entity_id = ? OR r.target_entity_id = ?)${sinceClause}
+          ORDER BY r.timestamp DESC`,
+    args
+  });
+  return result.rows.map((row) => ({
+    relationship: {
+      id: String(row.id),
+      sourceEntityId: String(row.source_entity_id),
+      targetEntityId: String(row.target_entity_id),
+      type: String(row.type),
+      weight: Number(row.weight),
+      timestamp: String(row.timestamp),
+      properties: JSON.parse(String(row.properties ?? "{}")),
+      sourceName: String(row.source_name),
+      targetName: String(row.target_name)
+    },
+    timestamp: String(row.timestamp)
+  }));
 }
-function getRerankerModelPath() {
-  return path8.join(MODELS_DIR, RERANKER_MODEL_FILE);
+async function getRelationshipFrequency(client, entityId, options) {
+  const granularity = options?.granularity ?? "day";
+  const args = [entityId, entityId];
+  let typeClause = "";
+  if (options?.type) {
+    typeClause = " AND r.type = ?";
+    args.push(options.type);
+  }
+  let bucketExpr;
+  switch (granularity) {
+    case "week":
+      bucketExpr = `strftime('%Y', r.timestamp) || '-W' || strftime('%W', r.timestamp)`;
+      break;
+    case "month":
+      bucketExpr = `strftime('%Y-%m', r.timestamp)`;
+      break;
+    default:
+      bucketExpr = `strftime('%Y-%m-%d', r.timestamp)`;
+  }
+  const result = await client.execute({
+    sql: `SELECT ${bucketExpr} as bucket, COUNT(*) as cnt, r.type as rel_type
+          FROM relationships r
+          WHERE (r.source_entity_id = ? OR r.target_entity_id = ?)${typeClause}
+          GROUP BY bucket${options?.type ? "" : ", r.type"}
+          ORDER BY bucket DESC`,
+    args
+  });
+  return result.rows.map((row) => ({
+    bucket: String(row.bucket),
+    count: Number(row.cnt),
+    relationshipType: options?.type ? options.type : String(row.rel_type)
+  }));
 }
-async function ensureLoaded() {
-  if (_rerankerContext) {
-    resetIdleTimer();
-    return;
+async function getConversationPartners(client, contactEntityId, since) {
+  const args = [contactEntityId, contactEntityId];
+  let sinceClause = "";
+  if (since) {
+    sinceClause = " AND r.timestamp >= ?";
+    args.push(since.toISOString());
   }
-  const modelPath = path8.join(MODELS_DIR, RERANKER_MODEL_FILE);
-  if (!existsSync7(modelPath)) {
-    throw new Error(
-      `Reranker model not found at ${modelPath}. Run /exe-setup to download it.`
-    );
+  const result = await client.execute({
+    sql: `SELECT
+            CASE
+              WHEN r.source_entity_id = ? THEN r.target_entity_id
+              ELSE r.source_entity_id
+            END as partner_id,
+            COUNT(*) as interaction_count,
+            MAX(r.timestamp) as last_interaction
+          FROM relationships r
+          WHERE (r.source_entity_id = ? OR r.target_entity_id = ?)${sinceClause}
+          GROUP BY partner_id
+          ORDER BY interaction_count DESC`,
+    args: [contactEntityId, ...args]
+  });
+  const partners = [];
+  for (const row of result.rows) {
+    const partnerId = String(row.partner_id);
+    const entityResult = await client.execute({
+      sql: "SELECT * FROM entities WHERE id = ?",
+      args: [partnerId]
+    });
+    if (entityResult.rows.length === 0) continue;
+    const e = entityResult.rows[0];
+    partners.push({
+      agentEntity: {
+        id: String(e.id),
+        name: String(e.name),
+        type: String(e.type),
+        firstSeen: String(e.first_seen),
+        lastSeen: String(e.last_seen),
+        properties: JSON.parse(String(e.properties ?? "{}"))
+      },
+      interactionCount: Number(row.interaction_count),
+      lastInteraction: String(row.last_interaction)
+    });
   }
-  process.stderr.write("[reranker] Loading Jina Reranker v3...\n");
-  const { getLlama } = await import("node-llama-cpp");
-  const llama = await getLlama();
-  _rerankerModel = await llama.loadModel({ modelPath });
-  _rerankerContext = await _rerankerModel.createEmbeddingContext();
-  process.stderr.write("[reranker] Jina Reranker v3 loaded.\n");
-  resetIdleTimer();
+  return partners;
 }
-async function disposeReranker() {
-  if (_idleTimer) {
-    clearTimeout(_idleTimer);
-    _idleTimer = null;
+async function getHotEntities(client, since, limit = 10) {
+  const sinceISO = since.toISOString();
+  const result = await client.execute({
+    sql: `SELECT entity_id, COUNT(*) as rel_count
+          FROM (
+            SELECT source_entity_id as entity_id FROM relationships WHERE timestamp >= ?
+            UNION ALL
+            SELECT target_entity_id as entity_id FROM relationships WHERE timestamp >= ?
+          )
+          GROUP BY entity_id
+          ORDER BY rel_count DESC
+          LIMIT ?`,
+    args: [sinceISO, sinceISO, limit]
+  });
+  const hotEntities = [];
+  for (const row of result.rows) {
+    const eid = String(row.entity_id);
+    const entityResult = await client.execute({
+      sql: "SELECT * FROM entities WHERE id = ?",
+      args: [eid]
+    });
+    if (entityResult.rows.length === 0) continue;
+    const e = entityResult.rows[0];
+    hotEntities.push({
+      entity: {
+        id: String(e.id),
+        name: String(e.name),
+        type: String(e.type),
+        firstSeen: String(e.first_seen),
+        lastSeen: String(e.last_seen),
+        properties: JSON.parse(String(e.properties ?? "{}"))
+      },
+      newRelationships: Number(row.rel_count)
+    });
   }
-  if (_rerankerContext) {
-    try {
-      await _rerankerContext.dispose();
-    } catch {
+  return hotEntities;
+}
+var init_graph_query = __esm({
+  "src/lib/graph-query.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/entity-boost.ts
+var entity_boost_exports = {};
+__export(entity_boost_exports, {
+  applyEntityBoost: () => applyEntityBoost
+});
+function getRelTypeWeights() {
+  const override = process.env.RELATIONSHIP_TYPE_WEIGHTS;
+  if (!override) return DEFAULT_RELATIONSHIP_WEIGHTS;
+  try {
+    return { ...DEFAULT_RELATIONSHIP_WEIGHTS, ...JSON.parse(override) };
+  } catch {
+    return DEFAULT_RELATIONSHIP_WEIGHTS;
+  }
+}
+async function matchEntities(query, client) {
+  const words = query.toLowerCase().split(/\s+/).filter((w) => w.length >= MIN_WORD_LENGTH).map((w) => w.replace(/[^a-z0-9_-]/g, "")).filter((w) => w.length >= MIN_WORD_LENGTH);
+  if (words.length === 0) return [];
+  try {
+    const matchExpr = words.map((w) => `${w}*`).join(" OR ");
+    const result = await client.execute({
+      sql: `SELECT e.id, e.name FROM entities e
+            JOIN entities_fts fts ON e.rowid = fts.rowid
+            WHERE entities_fts MATCH ?
+            ORDER BY rank
+            LIMIT ?`,
+      args: [matchExpr, MAX_ENTITY_MATCHES]
+    });
+    if (result.rows.length > 0) {
+      return result.rows.map((row) => ({
+        entityId: String(row.id),
+        name: String(row.name)
+      }));
     }
-    _rerankerContext = null;
+  } catch {
   }
-  if (_rerankerModel) {
-    try {
-      await _rerankerModel.dispose();
-    } catch {
+  const conditions = words.map(() => `LOWER(name) LIKE ?`);
+  const args = words.map((w) => `%${w}%`);
+  try {
+    const result = await client.execute({
+      sql: `SELECT id, name FROM entities
+            WHERE ${conditions.join(" OR ")}
+            LIMIT ?`,
+      args: [...args, MAX_ENTITY_MATCHES]
+    });
+    return result.rows.map((row) => ({
+      entityId: String(row.id),
+      name: String(row.name)
+    }));
+  } catch {
+    return [];
+  }
+}
+async function getLinkedMemories(entityIds, client) {
+  const linked = /* @__PURE__ */ new Map();
+  if (entityIds.length === 0) return linked;
+  const placeholders = entityIds.map(() => "?").join(",");
+  try {
+    const result = await client.execute({
+      sql: `SELECT entity_id, memory_id FROM entity_memories
+            WHERE entity_id IN (${placeholders})`,
+      args: entityIds
+    });
+    for (const row of result.rows) {
+      const entityId = String(row.entity_id);
+      const memoryId = String(row.memory_id);
+      const entry = linked.get(entityId) ?? {
+        entityId,
+        memoryIds: /* @__PURE__ */ new Set(),
+        count: 0
+      };
+      entry.memoryIds.add(memoryId);
+      entry.count = entry.memoryIds.size;
+      linked.set(entityId, entry);
     }
-    _rerankerModel = null;
+  } catch {
   }
-  process.stderr.write("[reranker] Unloaded (idle timeout).\n");
+  return linked;
 }
-async function rerankWithScores(query, texts, topK) {
-  if (texts.length === 0) return [];
-  await ensureLoaded();
-  const ctx = _rerankerContext;
-  const scored = [];
-  for (let i = 0; i < texts.length; i++) {
-    const text = texts[i] ?? "";
+function spreadAttenuation(numLinked) {
+  return 1 / (1 + 1e-3 * (numLinked - 1) ** 2);
+}
+async function traverseAndScore(entities, client, boostMap, resultIds, graphContextMap) {
+  const topEntities = entities.slice(0, TOP_ENTITIES_TO_TRAVERSE);
+  if (topEntities.length === 0) return;
+  const { getEntityNeighbors: getEntityNeighbors2 } = await Promise.resolve().then(() => (init_graph_query(), graph_query_exports));
+  const relWeights = getRelTypeWeights();
+  const neighborEntityIds = [];
+  const neighborMeta = /* @__PURE__ */ new Map();
+  for (const entity of topEntities) {
     try {
-      const input2 = `query: ${query} document: ${text.slice(0, 512)}`;
-      const embedding = await ctx.getEmbeddingFor(input2);
-      const score = embedding.vector[0] ?? 0;
-      scored.push({ text, score, index: i });
+      const neighbors = await getEntityNeighbors2(
+        client,
+        entity.entityId,
+        GRAPH_TRAVERSAL_MAX_HOPS
+      );
+      for (const n of neighbors) {
+        if (n.depth === 0) continue;
+        if (neighborMeta.has(n.entity.id)) continue;
+        neighborEntityIds.push(n.entity.id);
+        neighborMeta.set(n.entity.id, {
+          depth: n.depth,
+          relType: n.relType,
+          relConfidence: n.relConfidence,
+          sourceName: entity.name
+        });
+      }
     } catch {
-      scored.push({ text, score: -1, index: i });
     }
   }
-  scored.sort((a, b) => b.score - a.score);
-  return typeof topK === "number" ? scored.slice(0, topK) : scored;
+  if (neighborEntityIds.length === 0) return;
+  const neighborLinked = await getLinkedMemories(neighborEntityIds, client);
+  for (const [entityId, entry] of neighborLinked) {
+    const meta = neighborMeta.get(entityId);
+    if (!meta) continue;
+    const relWeight = relWeights[meta.relType] ?? DEFAULT_REL_WEIGHT;
+    const depthDecay = 1 / (1 + meta.depth);
+    const neighborBoost = ENTITY_BOOST_WEIGHT * meta.relConfidence * depthDecay * relWeight;
+    const attenuation = spreadAttenuation(entry.count);
+    const finalBoost = neighborBoost * attenuation;
+    for (const memoryId of entry.memoryIds) {
+      if (resultIds.has(memoryId)) {
+        boostMap.set(memoryId, (boostMap.get(memoryId) ?? 0) + finalBoost);
+        const contextPath = `${meta.sourceName} ${meta.relType} ${entityId}`;
+        if (!graphContextMap.has(memoryId)) {
+          graphContextMap.set(memoryId, contextPath);
+        }
+      }
+    }
+  }
 }
-async function rerank(query, candidates, topK = 5) {
-  if (candidates.length === 0) return [];
-  if (candidates.length <= topK) return candidates;
-  const scored = await rerankWithScores(
-    query,
-    candidates.map((c) => c.raw_text),
-    topK
+async function applyHyperedgeBoost(entities, client, boostMap, resultIds) {
+  if (entities.length < 2) return;
+  const entityIds = entities.map((e) => e.entityId);
+  const placeholders = entityIds.map(() => "?").join(",");
+  try {
+    const result = await client.execute({
+      sql: `SELECT hyperedge_id, entity_id FROM hyperedge_nodes
+            WHERE entity_id IN (${placeholders})`,
+      args: entityIds
+    });
+    const hyperedgeEntities = /* @__PURE__ */ new Map();
+    for (const row of result.rows) {
+      const hid = String(row.hyperedge_id);
+      const eid = String(row.entity_id);
+      const set = hyperedgeEntities.get(hid) ?? /* @__PURE__ */ new Set();
+      set.add(eid);
+      hyperedgeEntities.set(hid, set);
+    }
+    const sharedHyperedgeIds = [];
+    for (const [hid, eids] of hyperedgeEntities) {
+      if (eids.size >= 2) {
+        sharedHyperedgeIds.push(hid);
+      }
+    }
+    if (sharedHyperedgeIds.length === 0) return;
+    const hPlaceholders = sharedHyperedgeIds.map(() => "?").join(",");
+    const allNodesResult = await client.execute({
+      sql: `SELECT DISTINCT entity_id FROM hyperedge_nodes
+            WHERE hyperedge_id IN (${hPlaceholders})`,
+      args: sharedHyperedgeIds
+    });
+    const allEntityIds = allNodesResult.rows.map((r) => String(r.entity_id));
+    if (allEntityIds.length === 0) return;
+    const linked = await getLinkedMemories(allEntityIds, client);
+    for (const [, entry] of linked) {
+      const attenuation = spreadAttenuation(entry.count);
+      const boost = ENTITY_BOOST_WEIGHT * attenuation;
+      for (const memoryId of entry.memoryIds) {
+        if (resultIds.has(memoryId)) {
+          boostMap.set(memoryId, (boostMap.get(memoryId) ?? 0) + boost);
+        }
+      }
+    }
+  } catch {
+  }
+}
+async function applyEntityBoost(results, query, client) {
+  const emptyResult = { results, graphContext: /* @__PURE__ */ new Map() };
+  if (ENTITY_BOOST_WEIGHT === 0 || results.length === 0) {
+    return emptyResult;
+  }
+  console.time("entity-boost");
+  const entities = await matchEntities(query, client);
+  if (entities.length === 0) {
+    console.timeEnd("entity-boost");
+    return emptyResult;
+  }
+  const boostMap = /* @__PURE__ */ new Map();
+  const resultIds = new Set(results.map((r) => r.id));
+  const graphContextMap = /* @__PURE__ */ new Map();
+  const directLinked = await getLinkedMemories(
+    entities.map((e) => e.entityId),
+    client
   );
-  return scored.map((s) => candidates[s.index]);
+  for (const [, entry] of directLinked) {
+    const attenuation = spreadAttenuation(entry.count);
+    const boost = ENTITY_BOOST_WEIGHT * attenuation;
+    for (const memoryId of entry.memoryIds) {
+      if (resultIds.has(memoryId)) {
+        boostMap.set(memoryId, (boostMap.get(memoryId) ?? 0) + boost);
+      }
+    }
+  }
+  await traverseAndScore(entities, client, boostMap, resultIds, graphContextMap);
+  await applyHyperedgeBoost(entities, client, boostMap, resultIds);
+  if (boostMap.size === 0) {
+    console.timeEnd("entity-boost");
+    return emptyResult;
+  }
+  const scored = results.map((r, i) => ({
+    record: r,
+    baseScore: 1 / (1 + i * 0.1),
+    entityBoost: boostMap.get(r.id) ?? 0
+  }));
+  scored.sort(
+    (a, b) => b.baseScore + b.entityBoost - (a.baseScore + a.entityBoost)
+  );
+  console.timeEnd("entity-boost");
+  return {
+    results: scored.map((s) => s.record),
+    graphContext: graphContextMap
+  };
 }
-var RERANKER_MODEL_FILE, IDLE_TIMEOUT_MS, _rerankerContext, _rerankerModel, _idleTimer;
-var init_reranker = __esm({
-  "src/lib/reranker.ts"() {
+var ENTITY_BOOST_WEIGHT, MIN_WORD_LENGTH, MAX_ENTITY_MATCHES, GRAPH_TRAVERSAL_MAX_HOPS, TOP_ENTITIES_TO_TRAVERSE, DEFAULT_RELATIONSHIP_WEIGHTS, DEFAULT_REL_WEIGHT;
+var init_entity_boost = __esm({
+  "src/lib/entity-boost.ts"() {
     "use strict";
-    init_config();
-    RERANKER_MODEL_FILE = "jina-reranker-v3-q4_k_m.gguf";
-    IDLE_TIMEOUT_MS = 6e4;
-    _rerankerContext = null;
-    _rerankerModel = null;
-    _idleTimer = null;
+    ENTITY_BOOST_WEIGHT = parseFloat(
+      process.env.ENTITY_BOOST_WEIGHT ?? "0.5"
+    );
+    MIN_WORD_LENGTH = 3;
+    MAX_ENTITY_MATCHES = 20;
+    GRAPH_TRAVERSAL_MAX_HOPS = Math.min(
+      parseInt(process.env.GRAPH_TRAVERSAL_MAX_HOPS ?? "2", 10),
+      3
+    );
+    TOP_ENTITIES_TO_TRAVERSE = 5;
+    DEFAULT_RELATIONSHIP_WEIGHTS = {
+      decided: 1,
+      depends_on: 0.8,
+      part_of: 0.7,
+      related_to: 0.5,
+      mentioned_in: 0.3
+    };
+    DEFAULT_REL_WEIGHT = 0.4;
   }
 });
 
@@ -3393,6 +4130,42 @@ var init_provider_table = __esm({
   }
 });
 
+// src/lib/runtime-table.ts
+var RUNTIME_TABLE;
+var init_runtime_table = __esm({
+  "src/lib/runtime-table.ts"() {
+    "use strict";
+    RUNTIME_TABLE = {
+      codex: {
+        binary: "codex",
+        launchMode: "exec",
+        autoApproveFlag: "--full-auto",
+        inlineFlag: "--no-alt-screen",
+        apiKeyEnv: "OPENAI_API_KEY",
+        defaultModel: "gpt-5.4"
+      }
+    };
+  }
+});
+
+// src/lib/agent-config.ts
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync3, existsSync as existsSync8, mkdirSync as mkdirSync3 } from "fs";
+import path11 from "path";
+var AGENT_CONFIG_PATH, DEFAULT_MODELS;
+var init_agent_config = __esm({
+  "src/lib/agent-config.ts"() {
+    "use strict";
+    init_config();
+    init_runtime_table();
+    AGENT_CONFIG_PATH = path11.join(EXE_AI_DIR, "agent-config.json");
+    DEFAULT_MODELS = {
+      claude: "claude-opus-4",
+      codex: RUNTIME_TABLE.codex?.defaultModel ?? "gpt-5.4",
+      opencode: "minimax-m2.7"
+    };
+  }
+});
+
 // src/lib/intercom-queue.ts
 var intercom_queue_exports = {};
 __export(intercom_queue_exports, {
@@ -3401,17 +4174,17 @@ __export(intercom_queue_exports, {
   queueIntercom: () => queueIntercom,
   readQueue: () => readQueue
 });
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync3, renameSync as renameSync3, existsSync as existsSync8, mkdirSync as mkdirSync3 } from "fs";
-import path11 from "path";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync4, renameSync as renameSync3, existsSync as existsSync9, mkdirSync as mkdirSync4 } from "fs";
+import path12 from "path";
 import os5 from "os";
 function ensureDir() {
-  const dir = path11.dirname(QUEUE_PATH);
-  if (!existsSync8(dir)) mkdirSync3(dir, { recursive: true });
+  const dir = path12.dirname(QUEUE_PATH);
+  if (!existsSync9(dir)) mkdirSync4(dir, { recursive: true });
 }
 function readQueue() {
   try {
-    if (!existsSync8(QUEUE_PATH)) return [];
-    return JSON.parse(readFileSync6(QUEUE_PATH, "utf8"));
+    if (!existsSync9(QUEUE_PATH)) return [];
+    return JSON.parse(readFileSync7(QUEUE_PATH, "utf8"));
   } catch {
     return [];
   }
@@ -3419,7 +4192,7 @@ function readQueue() {
 function writeQueue(queue) {
   ensureDir();
   const tmp = `${QUEUE_PATH}.tmp`;
-  writeFileSync3(tmp, JSON.stringify(queue, null, 2));
+  writeFileSync4(tmp, JSON.stringify(queue, null, 2));
   renameSync3(tmp, QUEUE_PATH);
 }
 function queueIntercom(targetSession, reason) {
@@ -3502,32 +4275,32 @@ var QUEUE_PATH, MAX_RETRIES2, TTL_MS, INTERCOM_LOG;
 var init_intercom_queue = __esm({
   "src/lib/intercom-queue.ts"() {
     "use strict";
-    QUEUE_PATH = path11.join(os5.homedir(), ".exe-os", "intercom-queue.json");
+    QUEUE_PATH = path12.join(os5.homedir(), ".exe-os", "intercom-queue.json");
     MAX_RETRIES2 = 5;
     TTL_MS = 60 * 60 * 1e3;
-    INTERCOM_LOG = path11.join(os5.homedir(), ".exe-os", "intercom.log");
+    INTERCOM_LOG = path12.join(os5.homedir(), ".exe-os", "intercom.log");
   }
 });
 
 // src/lib/license.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync4, existsSync as existsSync9, mkdirSync as mkdirSync4 } from "fs";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync5, existsSync as existsSync10, mkdirSync as mkdirSync5 } from "fs";
 import { randomUUID as randomUUID3 } from "crypto";
-import path12 from "path";
+import path13 from "path";
 import { jwtVerify, importSPKI } from "jose";
 var LICENSE_PATH, CACHE_PATH, DEVICE_ID_PATH;
 var init_license = __esm({
   "src/lib/license.ts"() {
     "use strict";
     init_config();
-    LICENSE_PATH = path12.join(EXE_AI_DIR, "license.key");
-    CACHE_PATH = path12.join(EXE_AI_DIR, "license-cache.json");
-    DEVICE_ID_PATH = path12.join(EXE_AI_DIR, "device-id");
+    LICENSE_PATH = path13.join(EXE_AI_DIR, "license.key");
+    CACHE_PATH = path13.join(EXE_AI_DIR, "license-cache.json");
+    DEVICE_ID_PATH = path13.join(EXE_AI_DIR, "device-id");
   }
 });
 
 // src/lib/plan-limits.ts
-import { readFileSync as readFileSync8, existsSync as existsSync10 } from "fs";
-import path13 from "path";
+import { readFileSync as readFileSync9, existsSync as existsSync11 } from "fs";
+import path14 from "path";
 var CACHE_PATH2;
 var init_plan_limits = __esm({
   "src/lib/plan-limits.ts"() {
@@ -3536,13 +4309,13 @@ var init_plan_limits = __esm({
     init_employees();
     init_license();
     init_config();
-    CACHE_PATH2 = path13.join(EXE_AI_DIR, "license-cache.json");
+    CACHE_PATH2 = path14.join(EXE_AI_DIR, "license-cache.json");
   }
 });
 
 // src/lib/tmux-routing.ts
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, existsSync as existsSync11, appendFileSync } from "fs";
-import path14 from "path";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync6, mkdirSync as mkdirSync6, existsSync as existsSync12, appendFileSync } from "fs";
+import path15 from "path";
 import os6 from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function getMySession() {
@@ -3583,7 +4356,7 @@ function extractRootExe(name) {
 }
 function getParentExe(sessionKey) {
   try {
-    const data = JSON.parse(readFileSync9(path14.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
+    const data = JSON.parse(readFileSync10(path15.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
     return data.parentExe || null;
   } catch {
     return null;
@@ -3607,32 +4380,50 @@ function isEmployeeAlive(sessionName) {
 }
 function readDebounceState() {
   try {
-    if (!existsSync11(DEBOUNCE_FILE)) return {};
-    return JSON.parse(readFileSync9(DEBOUNCE_FILE, "utf8"));
+    if (!existsSync12(DEBOUNCE_FILE)) return {};
+    const raw = JSON.parse(readFileSync10(DEBOUNCE_FILE, "utf8"));
+    const state = {};
+    for (const [key, val] of Object.entries(raw)) {
+      if (typeof val === "number") {
+        state[key] = { lastSent: val, pending: 0 };
+      } else if (val && typeof val === "object" && "lastSent" in val) {
+        state[key] = val;
+      }
+    }
+    return state;
   } catch {
     return {};
   }
 }
 function writeDebounceState(state) {
   try {
-    if (!existsSync11(SESSION_CACHE)) mkdirSync5(SESSION_CACHE, { recursive: true });
-    writeFileSync5(DEBOUNCE_FILE, JSON.stringify(state));
+    if (!existsSync12(SESSION_CACHE)) mkdirSync6(SESSION_CACHE, { recursive: true });
+    writeFileSync6(DEBOUNCE_FILE, JSON.stringify(state));
   } catch {
   }
 }
 function isDebounced(targetSession) {
   const state = readDebounceState();
-  const lastSent = state[targetSession] ?? 0;
-  return Date.now() - lastSent < INTERCOM_DEBOUNCE_MS;
+  const entry = state[targetSession];
+  const lastSent = entry?.lastSent ?? 0;
+  if (Date.now() - lastSent < INTERCOM_DEBOUNCE_MS) {
+    if (!state[targetSession]) state[targetSession] = { lastSent, pending: 0 };
+    state[targetSession].pending++;
+    writeDebounceState(state);
+    return true;
+  }
+  return false;
 }
 function recordDebounce(targetSession) {
   const state = readDebounceState();
-  state[targetSession] = Date.now();
+  const batched = state[targetSession]?.pending ?? 0;
+  state[targetSession] = { lastSent: Date.now(), pending: 0 };
   const cutoff = Date.now() - DEBOUNCE_CLEANUP_AGE_MS;
   for (const key of Object.keys(state)) {
-    if ((state[key] ?? 0) < cutoff) delete state[key];
+    if ((state[key]?.lastSent ?? 0) < cutoff) delete state[key];
   }
   writeDebounceState(state);
+  return batched;
 }
 function logIntercom(msg) {
   const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}
@@ -3673,7 +4464,7 @@ function sendIntercom(targetSession) {
     return "skipped_exe";
   }
   if (isDebounced(targetSession)) {
-    logIntercom(`DEBOUNCE \u2192 ${targetSession} (cross-process file debounce)`);
+    logIntercom(`DEBOUNCE \u2192 ${targetSession} (nudge batched, task safe in DB)`);
     return "debounced";
   }
   try {
@@ -3685,14 +4476,14 @@ function sendIntercom(targetSession) {
     const sessionState = getSessionState(targetSession);
     if (sessionState === "no_claude") {
       queueIntercom(targetSession, "claude not running in session");
-      recordDebounce(targetSession);
-      logIntercom(`QUEUED \u2192 ${targetSession} (no claude process \u2014 raw shell detected)`);
+      const batched2 = recordDebounce(targetSession);
+      logIntercom(`QUEUED \u2192 ${targetSession} (no claude process)${batched2 > 0 ? ` [${batched2} batched]` : ""}`);
       return "queued";
     }
     if (sessionState === "thinking" || sessionState === "tool") {
       queueIntercom(targetSession, "session busy at send time");
-      recordDebounce(targetSession);
-      logIntercom(`QUEUED \u2192 ${targetSession} (session busy, will retry from queue)`);
+      const batched2 = recordDebounce(targetSession);
+      logIntercom(`QUEUED \u2192 ${targetSession} (session busy)${batched2 > 0 ? ` [${batched2} batched]` : ""}`);
       return "queued";
     }
     if (transport.isPaneInCopyMode(targetSession)) {
@@ -3700,8 +4491,8 @@ function sendIntercom(targetSession) {
       transport.sendKeys(targetSession, "q");
     }
     transport.sendKeys(targetSession, "/exe-intercom");
-    recordDebounce(targetSession);
-    logIntercom(`DELIVERED \u2192 ${targetSession} (fire-and-forget)`);
+    const batched = recordDebounce(targetSession);
+    logIntercom(`DELIVERED \u2192 ${targetSession}${batched > 0 ? ` [${batched} nudges batched during debounce]` : ""} (fire-and-forget)`);
     return "delivered";
   } catch {
     logIntercom(`FAIL \u2192 ${targetSession}`);
@@ -3718,15 +4509,17 @@ var init_tmux_routing = __esm({
     init_cc_agent_support();
     init_mcp_prefix();
     init_provider_table();
+    init_agent_config();
+    init_runtime_table();
     init_intercom_queue();
     init_plan_limits();
     init_employees();
-    SPAWN_LOCK_DIR = path14.join(os6.homedir(), ".exe-os", "spawn-locks");
-    SESSION_CACHE = path14.join(os6.homedir(), ".exe-os", "session-cache");
+    SPAWN_LOCK_DIR = path15.join(os6.homedir(), ".exe-os", "spawn-locks");
+    SESSION_CACHE = path15.join(os6.homedir(), ".exe-os", "session-cache");
     VALID_SESSION_NAME = /^[a-z]+\d*-[a-zA-Z0-9_]+$/;
     INTERCOM_DEBOUNCE_MS = 3e4;
-    INTERCOM_LOG2 = path14.join(os6.homedir(), ".exe-os", "intercom.log");
-    DEBOUNCE_FILE = path14.join(SESSION_CACHE, "intercom-debounce.json");
+    INTERCOM_LOG2 = path15.join(os6.homedir(), ".exe-os", "intercom.log");
+    DEBOUNCE_FILE = path15.join(SESSION_CACHE, "intercom-debounce.json");
     DEBOUNCE_CLEANUP_AGE_MS = 5 * 60 * 1e3;
     BUSY_PATTERN = /[✻✽✶✳·].*…|Running…/;
   }
@@ -3985,13 +4778,13 @@ var init_messaging = __esm({
 
 // src/lib/notifications.ts
 import crypto3 from "crypto";
-import path15 from "path";
+import path16 from "path";
 import os7 from "os";
 import {
-  readFileSync as readFileSync10,
+  readFileSync as readFileSync11,
   readdirSync as readdirSync4,
   unlinkSync as unlinkSync4,
-  existsSync as existsSync12,
+  existsSync as existsSync13,
   rmdirSync
 } from "fs";
 async function writeNotification(notification) {
@@ -4036,8 +4829,8 @@ __export(tasks_review_exports, {
   getReviewChecklist: () => getReviewChecklist,
   listPendingReviews: () => listPendingReviews
 });
-import path16 from "path";
-import { existsSync as existsSync13, readdirSync as readdirSync5, unlinkSync as unlinkSync5 } from "fs";
+import path17 from "path";
+import { existsSync as existsSync14, readdirSync as readdirSync5, unlinkSync as unlinkSync5 } from "fs";
 async function countPendingReviews(sessionScope) {
   const client = getClient();
   if (sessionScope) {
@@ -4059,7 +4852,7 @@ async function countNewPendingReviewsSince(sinceIso, sessionScope) {
     const result2 = await client.execute({
       sql: `SELECT COUNT(*) as cnt FROM tasks
             WHERE status = 'needs_review' AND updated_at > ?
-              AND (session_scope = ? OR session_scope IS NULL)`,
+              AND session_scope = ?`,
       args: [sinceIso, sessionScope]
     });
     return Number(result2.rows[0]?.cnt) || 0;
@@ -4077,7 +4870,7 @@ async function listPendingReviews(limit, sessionScope) {
     const result2 = await client.execute({
       sql: `SELECT title, assigned_to, project_name FROM tasks
             WHERE status = 'needs_review'
-              AND (session_scope = ? OR session_scope IS NULL)
+              AND session_scope = ?
             ORDER BY priority ASC, created_at DESC LIMIT ?`,
       args: [sessionScope, limit]
     });
@@ -4178,7 +4971,7 @@ async function createReviewForCompletedTask(row, result, _baseDir, now) {
   const taskFile = String(row.task_file);
   const employees = await loadEmployees();
   const coordinatorName = getCoordinatorName(employees);
-  if (String(row.assigned_to) === "exe" || isCoordinatorName(String(row.assigned_to), employees)) return;
+  if (isCoordinatorName(String(row.assigned_to), employees)) return;
   if (String(row.title).startsWith("Review:")) return;
   const fileName = taskFile.split("/").pop() ?? "";
   if (fileName.startsWith("review-") && String(row.assigned_by) === "system") return;
@@ -4287,14 +5080,14 @@ async function cleanupReviewFile(row, taskFile, _baseDir) {
       if (parts.length >= 3 && parts[0] === "review") {
         const agent = parts[1];
         const slug = parts.slice(2).join("-");
-        const originalTaskFile = `exe/${agent}/${slug}.md`;
+        const legacyTaskFile = `exe/${agent}/${slug}.md`;
         const result = await client.execute({
-          sql: "UPDATE tasks SET status = 'done', updated_at = ? WHERE task_file = ? AND status = 'needs_review'",
-          args: [now, originalTaskFile]
+          sql: "UPDATE tasks SET status = 'done', updated_at = ? WHERE (task_file = ? OR task_file LIKE ?) AND status = 'needs_review'",
+          args: [now, legacyTaskFile, `tasks/%/${agent}/${slug}.md`]
         });
         if (result.rowsAffected > 0) {
           process.stderr.write(
-            `[review-cleanup] Cascaded original task to done (legacy path): ${originalTaskFile}
+            `[review-cleanup] Cascaded original task to done: ${agent}/${slug}.md
 `
           );
         }
@@ -4307,11 +5100,11 @@ async function cleanupReviewFile(row, taskFile, _baseDir) {
     );
   }
   try {
-    const cacheDir = path16.join(EXE_AI_DIR, "session-cache");
-    if (existsSync13(cacheDir)) {
+    const cacheDir = path17.join(EXE_AI_DIR, "session-cache");
+    if (existsSync14(cacheDir)) {
       for (const f of readdirSync5(cacheDir)) {
         if (f.startsWith("review-notified-")) {
-          unlinkSync5(path16.join(cacheDir, f));
+          unlinkSync5(path17.join(cacheDir, f));
         }
       }
     }
@@ -4336,8 +5129,8 @@ init_config();
 init_config();
 init_store();
 import { spawn as spawn2 } from "child_process";
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync6, mkdirSync as mkdirSync6, existsSync as existsSync14, openSync as openSync2, closeSync as closeSync2 } from "fs";
-import path17 from "path";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7, existsSync as existsSync15, openSync as openSync2, closeSync as closeSync2 } from "fs";
+import path18 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/lib/hybrid-search.ts
@@ -4384,8 +5177,14 @@ async function hybridSearch(queryText, agentId, options) {
 `
     );
   }
+  let rerankerAvailable = false;
+  try {
+    const { isRerankerAvailable: isRerankerAvailable2 } = await Promise.resolve().then(() => (init_reranker(), reranker_exports));
+    rerankerAvailable = isRerankerAvailable2();
+  } catch {
+  }
   const broadFetchTopK = config.scalingRoadmap?.rerankerAutoTrigger?.fetchTopK ?? 150;
-  const fetchLimit = effectiveIsBroad ? Math.max(limit * 5, broadFetchTopK) : Math.max(limit * 3, 30);
+  const fetchLimit = effectiveIsBroad ? Math.max(limit * 5, broadFetchTopK) : rerankerAvailable ? Math.max(limit * 4, 60) : Math.max(limit * 3, 30);
   const fetchOptions = { ...effectiveOptions, limit: fetchLimit, includeSource: false };
   let queryVector = null;
   try {
@@ -4395,7 +5194,7 @@ async function hybridSearch(queryText, agentId, options) {
     process.stderr.write("[hybrid-search] Embed daemon unavailable \u2014 FTS-only mode\n");
   }
   let grepPromise = Promise.resolve([]);
-  if (config.fileGrepEnabled !== false) {
+  if (config.fileGrepEnabled === true) {
     try {
       const { getProjectName: getProjectName2 } = await Promise.resolve().then(() => (init_project_name(), project_name_exports));
       const projectRoot = process.cwd();
@@ -4431,7 +5230,17 @@ async function hybridSearch(queryText, agentId, options) {
   if (lists.length === 0) return [];
   if (lists.length === 1 && !effectiveIsBroad) return lists[0].slice(0, limit);
   const rrfLimit = effectiveIsBroad ? Math.max(limit * 5, 150) : limit;
-  const merged = lists.length === 1 ? lists[0].slice(0, rrfLimit) : rrfMergeMulti(lists, rrfLimit, RRF_K, weights);
+  let merged = lists.length === 1 ? lists[0].slice(0, rrfLimit) : rrfMergeMulti(lists, rrfLimit, RRF_K, weights);
+  let graphContextMap = /* @__PURE__ */ new Map();
+  if (merged.length > 0) {
+    try {
+      const { applyEntityBoost: applyEntityBoost2 } = await Promise.resolve().then(() => (init_entity_boost(), entity_boost_exports));
+      const boosted = await applyEntityBoost2(merged, effectiveQuery, getClient());
+      merged = boosted.results;
+      graphContextMap = boosted.graphContext;
+    } catch {
+    }
+  }
   const auto = config.scalingRoadmap?.rerankerAutoTrigger ?? {
     enabled: config.rerankerEnabled ?? true,
     broadQueryMinCardinality: 5e4,
@@ -4439,20 +5248,29 @@ async function hybridSearch(queryText, agentId, options) {
     returnTopK: 5
   };
   let rerankedAndBlended = null;
-  if (effectiveIsBroad && auto.enabled) {
+  if (effectiveIsBroad && auto.enabled && rerankerAvailable) {
     const cardinality2 = await estimateCardinality(agentId, effectiveOptions);
     if (cardinality2 > auto.broadQueryMinCardinality) {
       try {
-        const { isRerankerAvailable: isRerankerAvailable2, rerank: rerank2 } = await Promise.resolve().then(() => (init_reranker(), reranker_exports));
-        if (isRerankerAvailable2()) {
-          const reranked = await rerank2(effectiveQuery, merged, auto.returnTopK);
-          if (reranked.length > 0) {
-            rerankedAndBlended = rrfMergeMulti(
-              [reranked],
-              auto.returnTopK,
-              RRF_K
-            );
-          }
+        let rerankedRecords;
+        if (graphContextMap.size > 0) {
+          const { rerankWithContext: rerankWithContext2 } = await Promise.resolve().then(() => (init_reranker(), reranker_exports));
+          const candidates = merged.map((m) => ({
+            text: m.raw_text,
+            context: graphContextMap.get(m.id)
+          }));
+          const scored = await rerankWithContext2(effectiveQuery, candidates, auto.returnTopK);
+          rerankedRecords = scored.map((s) => merged[s.index]);
+        } else {
+          const { rerank: rerank2 } = await Promise.resolve().then(() => (init_reranker(), reranker_exports));
+          rerankedRecords = await rerank2(effectiveQuery, merged, auto.returnTopK);
+        }
+        if (rerankedRecords.length > 0) {
+          rerankedAndBlended = rrfMergeMulti(
+            [rerankedRecords],
+            auto.returnTopK,
+            RRF_K
+          );
         }
       } catch {
       }
@@ -4472,7 +5290,7 @@ async function hybridSearch(queryText, agentId, options) {
     try {
       const client = getClient();
       void client.execute({
-        sql: `UPDATE memories SET last_accessed = ? WHERE id IN (${placeholders})`,
+        sql: `UPDATE memories SET last_accessed = ?, retrieval_count = COALESCE(retrieval_count, 0) + 1 WHERE id IN (${placeholders})`,
         args: [now, ...ids]
       }).catch(() => {
       });
@@ -4642,7 +5460,7 @@ async function ftsQuery(client, matchExpr, agentId, options, limit) {
     source_type: row.source_type ?? null
   }));
 }
-async function recentRecords(agentId, options, limit) {
+async function recentRecords(agentId, options, limit, textFilter) {
   const client = getClient();
   const statusFilter = options?.includeArchived ? "" : `
                AND COALESCE(status, 'active') = 'active'`;
@@ -4682,6 +5500,10 @@ async function recentRecords(agentId, options, limit) {
     sql += ` AND memory_type = ?`;
     args.push(options.memoryType);
   }
+  if (textFilter) {
+    sql += ` AND raw_text LIKE '%' || ? || '%'`;
+    args.push(textFilter);
+  }
   sql += ` ORDER BY timestamp DESC LIMIT ?`;
   args.push(limit);
   const result = await client.execute({ sql, args });
@@ -4904,7 +5726,7 @@ if (!process.env.AGENT_ID) {
 if (!loadConfigSync().autoRetrieval) {
   process.exit(0);
 }
-var WORKER_LOG_PATH = path17.join(EXE_AI_DIR, "workers.log");
+var WORKER_LOG_PATH = path18.join(EXE_AI_DIR, "workers.log");
 function openWorkerLog() {
   try {
     return openSync2(WORKER_LOG_PATH, "a");
@@ -4912,10 +5734,10 @@ function openWorkerLog() {
     return "ignore";
   }
 }
-var CACHE_DIR2 = path17.join(EXE_AI_DIR, "session-cache");
+var CACHE_DIR2 = path18.join(EXE_AI_DIR, "session-cache");
 function loadInjectedIds(sessionId) {
   try {
-    const raw = readFileSync11(path17.join(CACHE_DIR2, `${sessionId}.json`), "utf8");
+    const raw = readFileSync12(path18.join(CACHE_DIR2, `${sessionId}.json`), "utf8");
     return new Set(JSON.parse(raw));
   } catch {
     return /* @__PURE__ */ new Set();
@@ -4923,9 +5745,9 @@ function loadInjectedIds(sessionId) {
 }
 function saveInjectedIds(sessionId, ids) {
   try {
-    mkdirSync6(CACHE_DIR2, { recursive: true });
-    writeFileSync6(
-      path17.join(CACHE_DIR2, `${sessionId}.json`),
+    mkdirSync7(CACHE_DIR2, { recursive: true });
+    writeFileSync7(
+      path18.join(CACHE_DIR2, `${sessionId}.json`),
       JSON.stringify([...ids])
     );
   } catch {
@@ -5008,7 +5830,7 @@ ${fresh.map(
       try {
         const { countPendingReviews: countPendingReviews2, countNewPendingReviewsSince: countNewPendingReviewsSince2 } = await Promise.resolve().then(() => (init_tasks_review(), tasks_review_exports));
         const sessionKey = getSessionKey();
-        const lastCheckPath = path17.join(CACHE_DIR2, `review-lastcheck-${sessionKey}.json`);
+        const lastCheckPath = path18.join(CACHE_DIR2, `review-lastcheck-${sessionKey}.json`);
         let sessionScope;
         try {
           const { execSync: execSync7 } = await import("child_process");
@@ -5018,7 +5840,7 @@ ${fresh.map(
         }
         let lastCheckedAt = "";
         try {
-          lastCheckedAt = readFileSync11(lastCheckPath, "utf8").trim();
+          lastCheckedAt = readFileSync12(lastCheckPath, "utf8").trim();
         } catch {
         }
         const totalCount = await countPendingReviews2(sessionScope);
@@ -5076,11 +5898,11 @@ IMPORTANT: After completing your current task, you MUST address the pending revi
 function spawnPromptWorker(prompt, sessionId, agent) {
   if (!loadConfigSync().autoIngestion) return;
   try {
-    const workerPath = path17.resolve(
-      path17.dirname(fileURLToPath3(import.meta.url)),
+    const workerPath = path18.resolve(
+      path18.dirname(fileURLToPath3(import.meta.url)),
       "prompt-ingest-worker.js"
     );
-    if (!existsSync14(workerPath)) {
+    if (!existsSync15(workerPath)) {
       process.stderr.write(`[prompt-submit] WARN: prompt-ingest-worker not found at ${workerPath}
 `);
       return;