@askexenow/exe-os 0.9.279 → 0.9.281

package/dist/chunk-4J5TKW7C.js

@@ -0,0 +1,1352 @@
+import {
+  buildFtsMatch,
+  tokenizeForFts
+} from "./chunk-AB4PAQYK.js";
+import {
+  attachDocumentMetadata,
+  buildRawVisibilityFilter,
+  buildWikiScopeFilter,
+  searchMemories
+} from "./chunk-JDSJ3NU7.js";
+import {
+  blobToVector
+} from "./chunk-OTVEIJUQ.js";
+import {
+  getClient
+} from "./chunk-ZJP3ZONM.js";
+
+// src/lib/hybrid-search.ts
+var RRF_K = 60;
+var DAEMON_SAFE_FTS_TERM_THRESHOLD = 3;
+var DAEMON_SAFE_FTS_MAX_TERMS = 5;
+var _daemonBroadFtsSkipLogged = false;
+var _daemonGraphFtsSkipLogged = false;
+var _hybridDegradeWarned = false;
+function isDaemonProcess() {
+  return process.env.EXE_IS_DAEMON === "1";
+}
+function daemonSafeFtsTerms(terms) {
+  return isDaemonProcess() ? terms.slice(0, DAEMON_SAFE_FTS_MAX_TERMS) : terms;
+}
+function shouldUseFtsPrefix(terms) {
+  return !(isDaemonProcess() && terms.length >= DAEMON_SAFE_FTS_TERM_THRESHOLD);
+}
+function logDaemonBroadFtsSkipOnce(terms) {
+  if (_daemonBroadFtsSkipLogged || process.env.VITEST) return;
+  _daemonBroadFtsSkipLogged = true;
+  process.stderr.write(
+    `[hybrid-search] Daemon-safe FTS: skipped broad OR fallback for ${terms.length} terms to keep MCP responsive.
+`
+  );
+}
+function logDaemonGraphFtsSkipOnce(terms) {
+  if (_daemonGraphFtsSkipLogged || process.env.VITEST) return;
+  _daemonGraphFtsSkipLogged = true;
+  process.stderr.write(
+    `[hybrid-search] Daemon-safe FTS: skipped graph/entity FTS for ${terms.length} terms to keep MCP responsive.
+`
+  );
+}
+var _cardinalityCache = /* @__PURE__ */ new Map();
+var CARDINALITY_TTL_MS = 6e4;
+setInterval(() => {
+  const now = Date.now();
+  for (const [key, entry] of _cardinalityCache) {
+    if (now > entry.expires) _cardinalityCache.delete(key);
+  }
+}, 5 * 60 * 1e3).unref();
+async function getCachedCardinality(agentId) {
+  if (process.env.VITEST === "true" || process.env.NODE_ENV === "test") {
+    const { getMemoryCardinality: getMemoryCardinality2 } = await import("./lib/store.js");
+    return getMemoryCardinality2(agentId);
+  }
+  const cached = _cardinalityCache.get(agentId);
+  if (cached && Date.now() < cached.expires) return cached.count;
+  const { getMemoryCardinality } = await import("./lib/store.js");
+  const count = await getMemoryCardinality(agentId);
+  _cardinalityCache.set(agentId, { count, expires: Date.now() + CARDINALITY_TTL_MS });
+  return count;
+}
+var ABSTENTION_THRESHOLD = parseFloat(
+  process.env.EXE_ABSTENTION_THRESHOLD ?? "0.25"
+);
+var CONTRADICTION_TEMPORAL_BOOST = 1.5;
+var AFFINITY_BOOST = 0.3;
+function buildTemporalFilter(options, columnPrefix) {
+  const asOf = options?.asOf;
+  if (asOf) {
+    return {
+      clause: ` AND (${columnPrefix}valid_from IS NULL OR ${columnPrefix}valid_from <= ?) AND (${columnPrefix}invalid_at IS NULL OR ${columnPrefix}invalid_at > ?)`,
+      args: [asOf, asOf]
+    };
+  }
+  return {
+    clause: ` AND ${columnPrefix}invalid_at IS NULL`,
+    args: []
+  };
+}
+function appendMemoryTypeFilter(sql, args, column, options) {
+  if (options?.memoryTypes && options.memoryTypes.length > 0) {
+    const uniqueTypes = [...new Set(options.memoryTypes)];
+    sql += ` AND ${column} IN (${uniqueTypes.map(() => "?").join(",")})`;
+    args.push(...uniqueTypes);
+  } else if (options?.memoryType) {
+    sql += ` AND ${column} = ?`;
+    args.push(options.memoryType);
+  }
+  return sql;
+}
+async function graphSearch(query, agentId, _options, limit) {
+  const client = getClient();
+  const queryWords = tokenizeForFts(query, { maxTerms: 16 });
+  if (queryWords.length === 0) return [];
+  if (isDaemonProcess() && queryWords.length >= DAEMON_SAFE_FTS_TERM_THRESHOLD) {
+    logDaemonGraphFtsSkipOnce(queryWords);
+    return [];
+  }
+  let entityIds = [];
+  try {
+    const safeWords = daemonSafeFtsTerms(queryWords);
+    const usePrefix = shouldUseFtsPrefix(safeWords);
+    const matchExpr = buildFtsMatch(safeWords, { prefix: usePrefix, join: "OR" });
+    const ftsResult = await client.execute({
+      sql: `SELECT e.id FROM entities e
+            JOIN entities_fts fts ON e.rowid = fts.rowid
+            WHERE entities_fts MATCH ?
+            ORDER BY rank LIMIT 10`,
+      args: [matchExpr]
+    });
+    entityIds = ftsResult.rows.map((r) => String(r.id));
+  } catch {
+    try {
+      const conditions = queryWords.map(() => `LOWER(name) LIKE ? ESCAPE '\\'`);
+      const args = queryWords.map((w) => `%${escapeLikePattern(w)}%`);
+      const likeResult = await client.execute({
+        sql: `SELECT id FROM entities WHERE ${conditions.join(" OR ")} LIMIT 10`,
+        args: [...args]
+      });
+      entityIds = likeResult.rows.map((r) => String(r.id));
+    } catch {
+      return [];
+    }
+  }
+  if (entityIds.length === 0) return [];
+  const allEntityIds = new Set(entityIds);
+  try {
+    const placeholders2 = entityIds.map(() => "?").join(",");
+    const neighborResult = await client.execute({
+      sql: `SELECT DISTINCT target_entity_id FROM relationships
+            WHERE source_entity_id IN (${placeholders2})
+            UNION
+            SELECT DISTINCT source_entity_id FROM relationships
+            WHERE target_entity_id IN (${placeholders2})
+            LIMIT 30`,
+      args: [...entityIds, ...entityIds]
+    });
+    for (const row of neighborResult.rows) {
+      allEntityIds.add(String(row.target_entity_id ?? row.source_entity_id));
+    }
+  } catch {
+  }
+  const entityIdArr = Array.from(allEntityIds);
+  const placeholders = entityIdArr.map(() => "?").join(",");
+  try {
+    const memResult = await client.execute({
+      sql: `SELECT DISTINCT m.id, m.agent_id, m.agent_role, m.session_id, m.timestamp,
+                   m.tool_name, m.project_name, m.has_error, m.raw_text, m.vector,
+                   m.task_id, m.importance, m.status, m.confidence, m.last_accessed,
+                   m.workspace_id, m.document_id, m.user_id, m.char_offset,
+                   m.page_number, m.source_path, m.source_type, m.memory_type, m.strength
+            FROM memories m
+            JOIN entity_memories em ON m.id = em.memory_id
+            WHERE em.entity_id IN (${placeholders})
+              AND (m.agent_id = ? OR m.agent_id = 'wiki')
+              AND COALESCE(m.status, 'active') = 'active'
+              AND COALESCE(m.confidence, 0.7) >= 0.3
+            ORDER BY m.importance DESC, m.timestamp DESC
+            LIMIT ?`,
+      args: [...entityIdArr, agentId, limit]
+    });
+    return memResult.rows.map((row) => rowToMemoryRecord(row));
+  } catch {
+    return [];
+  }
+}
+function escapeLikePattern(value) {
+  return value.replace(/[\\%_]/g, (ch) => `\\${ch}`);
+}
+function extractEntitySubqueries(query) {
+  const subqueries = [];
+  const quoted = query.match(/"([^"]+)"/g);
+  if (quoted) {
+    for (const q of quoted) {
+      subqueries.push(q.replace(/"/g, ""));
+    }
+  }
+  const words = query.split(/\s+/);
+  const properNouns = [];
+  for (let i = 1; i < words.length; i++) {
+    const word = words[i].replace(/[^a-zA-Z]/g, "");
+    if (word.length >= 2 && /^[A-Z]/.test(word) && !/^(What|When|Where|Who|How|Why|Which|Does|Did|Is|Are|Was|Were|Has|Have|Had|Can|Could|Would|Should|Do|The|And|But|For|Not|You|Your|His|Her|Its|Our|Their|This|That|These|Those)$/.test(word)) {
+      properNouns.push(word);
+    }
+  }
+  if (properNouns.length > 0) {
+    subqueries.push(properNouns.join(" "));
+  }
+  const prepPatterns = /(?:about|regarding|concerning|towards?|with|for|against)\s+(.+?)(?:\?|$|,|\band\b)/gi;
+  let match;
+  while ((match = prepPatterns.exec(query)) !== null) {
+    const phrase = match[1].trim();
+    if (phrase.length >= 3 && phrase.split(/\s+/).length <= 5) {
+      subqueries.push(phrase);
+    }
+  }
+  return [...new Set(subqueries)].slice(0, 3);
+}
+function resolveContradictions(results) {
+  if (results.length < 2) return results;
+  const entityGroups = /* @__PURE__ */ new Map();
+  for (const r of results) {
+    const words = (r.raw_text ?? "").toLowerCase().replace(/[^a-z0-9\s]/g, "").split(/\s+/).filter((w) => w.length >= 4).slice(0, 3);
+    if (words.length < 2) continue;
+    const key = words.join("|");
+    let grouped = false;
+    for (const [existingKey, group] of entityGroups) {
+      const existingWords = new Set(existingKey.split("|"));
+      const overlapCount = words.filter((w) => existingWords.has(w)).length;
+      if (overlapCount >= 2) {
+        group.push(r);
+        entityGroups.set(existingKey, group);
+        grouped = true;
+        break;
+      }
+    }
+    if (grouped) continue;
+    const existing = entityGroups.get(key) ?? [];
+    existing.push(r);
+    entityGroups.set(key, existing);
+  }
+  const temporalBoosts = /* @__PURE__ */ new Map();
+  for (const [, group] of entityGroups) {
+    if (group.length < 2) continue;
+    const sorted = [...group].sort(
+      (a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime()
+    );
+    for (let i = 0; i < sorted.length; i++) {
+      const id = sorted[i].id;
+      const boost = i === 0 ? CONTRADICTION_TEMPORAL_BOOST : 1 / (1 + i * 0.3);
+      temporalBoosts.set(id, Math.max(temporalBoosts.get(id) ?? 0, boost));
+    }
+  }
+  if (temporalBoosts.size === 0) return results;
+  const scored = results.map((r, i) => {
+    const baseScore = 1 / (1 + i * 0.1);
+    const contradiction = temporalBoosts.get(r.id) ?? 1;
+    return { record: r, score: baseScore * contradiction };
+  });
+  scored.sort((a, b) => b.score - a.score);
+  return scored.map((s) => s.record);
+}
+function applyAffinityBoost(results) {
+  if (results.length < 2) return results;
+  const scored = results.map((r, i) => ({
+    record: r,
+    baseScore: 1 / (1 + i * 0.1),
+    boostedScore: 0
+  }));
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of scored) {
+    const proj = entry.record.project_name?.trim();
+    if (!proj) {
+      entry.boostedScore = entry.baseScore;
+      continue;
+    }
+    const docId = entry.record.document_id ?? "";
+    const key = `${proj}\0${docId}`;
+    const group = groups.get(key) ?? [];
+    group.push(entry);
+    groups.set(key, group);
+  }
+  for (const [, group] of groups) {
+    if (group.length < 2) {
+      for (const e of group) e.boostedScore = e.baseScore;
+      continue;
+    }
+    let leaderScore = 0;
+    for (const e of group) {
+      if (e.baseScore > leaderScore) leaderScore = e.baseScore;
+    }
+    for (const e of group) {
+      if (e.baseScore <= 0) {
+        e.boostedScore = e.baseScore;
+      } else if (e.baseScore === leaderScore) {
+        e.boostedScore = e.baseScore;
+      } else {
+        e.boostedScore = e.baseScore + AFFINITY_BOOST * leaderScore;
+      }
+    }
+  }
+  for (const e of scored) {
+    if (e.boostedScore === 0 && e.baseScore > 0) {
+      e.boostedScore = e.baseScore;
+    }
+  }
+  scored.sort((a, b) => b.boostedScore - a.boostedScore);
+  return scored.map((e) => e.record);
+}
+async function hybridSearch(queryText, agentId, options) {
+  const { loadConfig } = await import("./lib/config.js");
+  const config = await loadConfig();
+  const searchStartMs = Date.now();
+  if (config.searchMode === "fts") {
+    return lightweightSearch(queryText, agentId, options);
+  }
+  const limit = options?.limit ?? 10;
+  const trajectoryResults = await trajectoryBypass(queryText, agentId, options, limit);
+  if (trajectoryResults !== null) return trajectoryResults;
+  let effectiveQuery = queryText;
+  const effectiveOptions = { ...options };
+  let _isBroadQuery = false;
+  let inferredTerms = [];
+  if (config.selfQueryRouter) {
+    try {
+      const { routeQuery } = await import("./self-query-router-PYVVFXJT.js");
+      const routed = await routeQuery(queryText, config.selfQueryModel, agentId);
+      effectiveQuery = routed.semanticQuery;
+      _isBroadQuery = routed.isBroadQuery;
+      inferredTerms = routed.inferredTerms ?? [];
+      if (routed.projectFilter && !effectiveOptions.projectName) {
+        effectiveOptions.projectName = routed.projectFilter;
+      }
+      if (routed.timeFilter && !effectiveOptions.since) {
+        effectiveOptions.since = routed.timeFilter;
+      }
+      if (routed.roleFilter) {
+        inferredTerms.push(routed.roleFilter.toLowerCase());
+      }
+    } catch (err) {
+      if (!process.env.VITEST) {
+        process.stderr.write(`[hybrid-search] Self-query router failed: ${err instanceof Error ? err.message : String(err)}
+`);
+      }
+    }
+  }
+  const cardinality = await getCachedCardinality(agentId);
+  const { rerankerAutoTrigger } = config.scalingRoadmap ?? {};
+  const minCardForBroad = rerankerAutoTrigger?.broadQueryMinCardinality ?? 5e4;
+  const useNarrowPath = cardinality < 1e4;
+  const useBroadPath = cardinality > minCardForBroad || _isBroadQuery && cardinality >= 1e4;
+  const effectiveIsBroad = useBroadPath && !useNarrowPath;
+  if (effectiveIsBroad !== _isBroadQuery) {
+    process.stderr.write(
+      `[hybrid-search] Adaptive routing override: cardinality=${cardinality}, router=${_isBroadQuery ? "broad" : "narrow"} \u2192 ${effectiveIsBroad ? "broad" : "narrow"}
+`
+    );
+  }
+  let rerankerAvailable = false;
+  if (process.env.EXE_IS_DAEMON === "1") {
+    try {
+      const { isRerankerAvailable } = await import("./reranker-USWG7L7N.js");
+      rerankerAvailable = isRerankerAvailable();
+    } catch {
+    }
+  }
+  const broadFetchTopK = config.scalingRoadmap?.rerankerAutoTrigger?.fetchTopK ?? 150;
+  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 {
+    const { embed } = await import("./lib/embedder.js");
+    queryVector = await embed(effectiveQuery);
+  } catch {
+    if (!process.env.VITEST) {
+      if (!_hybridDegradeWarned) {
+        _hybridDegradeWarned = true;
+        process.stderr.write(
+          '[hybrid-search] searchMode=hybrid but embed daemon unavailable \u2014 degrading to FTS+Graph only. Set EXE_EMBEDDINGS=1 or change searchMode to "fts" in ~/.exe-os/config.json to silence this warning.\n'
+        );
+      }
+    }
+  }
+  let grepPromise = Promise.resolve([]);
+  if (config.fileGrepEnabled === true && !process.env.VITEST) {
+    try {
+      if (process.env.EXE_IS_DAEMON !== "1") {
+        const { getProjectName } = await import("./project-name-EWG5KAZP.js");
+        const projectRoot = process.cwd();
+        const projectName = getProjectName(projectRoot);
+        if (projectName && projectName !== "tmp") {
+          const { grepProjectFiles } = await import("./lib/file-grep.js");
+          grepPromise = grepProjectFiles(effectiveQuery, projectRoot, {
+            maxResults: 10
+          }).catch(() => []);
+        }
+      }
+    } catch {
+    }
+  }
+  const entitySubqueries = extractEntitySubqueries(effectiveQuery);
+  if (inferredTerms.length > 0) {
+    entitySubqueries.push(...inferredTerms.filter(
+      (t) => !entitySubqueries.some((sq) => sq.toLowerCase() === t.toLowerCase())
+    ));
+  }
+  const subqueryPromises = entitySubqueries.map(
+    (sq) => lightweightSearch(sq, agentId, { ...fetchOptions, limit: Math.min(fetchLimit, 20) }).catch(() => [])
+  );
+  const includeStructuredCards = effectiveIsBroad || effectiveOptions.includeStructuredCards === true;
+  const [ftsResults, vectorResults, graphResults, cardResults, reflectionResults, grepResults, ...subqueryResults] = await Promise.all([
+    lightweightSearch(effectiveQuery, agentId, fetchOptions),
+    queryVector ? searchMemories(queryVector, agentId, fetchOptions).catch((err) => {
+      if (!process.env.VITEST) {
+        process.stderr.write(`[hybrid-search] Vector search failed; continuing with non-vector signals: ${err instanceof Error ? err.message : String(err)}
+`);
+      }
+      return [];
+    }) : Promise.resolve([]),
+    // Graph search: first-class parallel signal via entity → memory linkage.
+    // Non-blocking with 2s timeout — graph is a bonus, not a requirement.
+    Promise.race([
+      graphSearch(effectiveQuery, agentId, fetchOptions, Math.min(fetchLimit, 20)),
+      new Promise((resolve) => setTimeout(() => resolve([]), 2e3))
+    ]).catch(() => []),
+    includeStructuredCards ? (async () => {
+      try {
+        const { searchMemoryCards } = await import("./memory-cards-AKXTAQZG.js");
+        return await searchMemoryCards(effectiveQuery, agentId, fetchOptions);
+      } catch {
+        return [];
+      }
+    })() : Promise.resolve([]),
+    // Reflection insights: patterns, contradictions, summaries across sessions
+    includeStructuredCards ? (async () => {
+      try {
+        const { searchReflections } = await import("./memory-reflection-RAWMCOLK.js");
+        const insights = await searchReflections(effectiveQuery, agentId, 5);
+        return insights.map((ins) => ({
+          id: ins.id,
+          agent_id: ins.agent_id,
+          raw_text: `[${ins.insight_type}] ${ins.content}`,
+          timestamp: ins.created_at,
+          session_id: "reflection",
+          importance: Math.round(ins.confidence * 10),
+          confidence: ins.confidence
+        }));
+      } catch {
+        return [];
+      }
+    })() : Promise.resolve([]),
+    grepPromise,
+    ...subqueryPromises
+  ]);
+  for (const r of ftsResults) {
+    r._source = "fts";
+  }
+  for (const r of vectorResults) {
+    r._source = "embed";
+  }
+  for (const r of graphResults) {
+    r._source = "graph";
+  }
+  for (const r of cardResults) {
+    r._source = "card";
+  }
+  for (const r of reflectionResults) {
+    r._source = "reflection";
+  }
+  for (const r of grepResults) {
+    r._source = "grep";
+  }
+  const isDebug = options?.debug === true;
+  const debugScoreMap = /* @__PURE__ */ new Map();
+  if (isDebug) {
+    const initEntry = (id) => {
+      if (!debugScoreMap.has(id)) {
+        debugScoreMap.set(id, { fts_rank: null, graph_rank: null, vector_rank: null, vector_distance: null });
+      }
+      return debugScoreMap.get(id);
+    };
+    for (let i = 0; i < ftsResults.length; i++) {
+      initEntry(ftsResults[i].id).fts_rank = i + 1;
+    }
+    for (let i = 0; i < vectorResults.length; i++) {
+      const rec = vectorResults[i];
+      const entry = initEntry(rec.id);
+      entry.vector_rank = i + 1;
+      const scored = rec;
+      entry.vector_distance = scored.distance ?? null;
+    }
+    for (let i = 0; i < graphResults.length; i++) {
+      initEntry(graphResults[i].id).graph_rank = i + 1;
+    }
+  }
+  const lists = [];
+  const weights = [];
+  if (ftsResults.length > 0) {
+    lists.push(ftsResults);
+    weights.push(1);
+  }
+  if (vectorResults.length > 0) {
+    lists.push(vectorResults);
+    weights.push(1);
+  }
+  if (graphResults.length > 0) {
+    lists.push(graphResults);
+    weights.push(0.9);
+  }
+  if (reflectionResults.length > 0) {
+    lists.push(reflectionResults);
+    weights.push(0.65);
+  }
+  if (cardResults.length > 0) {
+    lists.push(cardResults);
+    weights.push(0.85);
+  }
+  if (grepResults.length > 0) {
+    lists.push(grepResults);
+    weights.push(0.5);
+  }
+  for (const sqResult of subqueryResults) {
+    if (sqResult.length > 0) {
+      lists.push(sqResult);
+      weights.push(0.7);
+    }
+  }
+  if (lists.length === 0) return [];
+  if (lists.length === 1 && !effectiveIsBroad) return lists[0].slice(0, limit);
+  const rrfLimit = effectiveIsBroad ? Math.max(limit * 5, broadFetchTopK) : limit;
+  let merged = lists.length === 1 ? lists[0].slice(0, rrfLimit) : rrfMergeMulti(lists, rrfLimit, RRF_K, weights);
+  let graphContextMap = /* @__PURE__ */ new Map();
+  let entityBoostRan = false;
+  if (merged.length > 0) {
+    try {
+      const { applyEntityBoost } = await import("./entity-boost-DVQU26WN.js");
+      const boosted = await applyEntityBoost(merged, effectiveQuery, getClient());
+      merged = boosted.results;
+      graphContextMap = boosted.graphContext;
+      entityBoostRan = true;
+    } catch {
+    }
+  }
+  if (merged.length >= 2) {
+    merged = resolveContradictions(merged);
+  }
+  const auto = config.scalingRoadmap?.rerankerAutoTrigger ?? {
+    enabled: config.rerankerEnabled ?? true,
+    broadQueryMinCardinality: 5e4,
+    fetchTopK: 150,
+    returnTopK: 5
+  };
+  let rerankedAndBlended = null;
+  const rerankReturnLimit = Math.max(limit, auto.returnTopK ?? 5);
+  const shouldRerank = auto.enabled && rerankerAvailable && merged.length >= limit * 2 && (effectiveIsBroad || lists.length >= 2);
+  if (shouldRerank) {
+    try {
+      let rerankedRecords;
+      if (graphContextMap.size > 0) {
+        const { rerankWithContext } = await import("./reranker-USWG7L7N.js");
+        const candidates = merged.map((m) => ({
+          text: m.raw_text,
+          context: graphContextMap.get(m.id)
+        }));
+        const scored = await rerankWithContext(effectiveQuery, candidates, rerankReturnLimit);
+        rerankedRecords = scored.map((s) => merged[s.index]);
+      } else {
+        const { rerank } = await import("./reranker-USWG7L7N.js");
+        rerankedRecords = await rerank(effectiveQuery, merged, rerankReturnLimit);
+      }
+      if (rerankedRecords.length > 0) {
+        rerankedAndBlended = rrfMergeMulti(
+          [rerankedRecords],
+          rerankReturnLimit,
+          RRF_K
+        );
+      }
+    } catch {
+    }
+  }
+  let preSlice = rerankedAndBlended ?? merged;
+  if (options?.affinityBoost && preSlice.length >= 2) {
+    preSlice = applyAffinityBoost(preSlice);
+  }
+  let finalResults = preSlice.slice(0, limit);
+  if (isDebug && finalResults.length > 0) {
+    const expansionTerms = entitySubqueries.length > 0 ? entitySubqueries : null;
+    for (let i = 0; i < finalResults.length; i++) {
+      const r = finalResults[i];
+      const scores = debugScoreMap.get(r.id);
+      r._debug = {
+        fts_score: scores?.fts_rank ?? null,
+        graph_boost: scores?.graph_rank ?? null,
+        vector_score: scores?.vector_distance ?? scores?.vector_rank ?? null,
+        rrf_rank: i + 1,
+        match_source: r._source ?? "unknown",
+        query_expansion: expansionTerms
+      };
+    }
+  }
+  if (finalResults.length > 0) {
+    const topResult = finalResults[0];
+    const signalCount = lists.length;
+    const resultRatio = Math.min(1, finalResults.length / limit);
+    const retrievalConfidence = resultRatio * (signalCount >= 2 ? 1 : 0.7);
+    topResult._retrievalConfidence = retrievalConfidence;
+    if (retrievalConfidence < ABSTENTION_THRESHOLD) {
+      for (const r of finalResults) {
+        r._lowConfidence = true;
+      }
+    }
+  }
+  if (options?.includeSource && finalResults.length > 0) {
+    finalResults = await expandNeighborChunks(finalResults, limit);
+    await attachDocumentMetadata(finalResults);
+  }
+  if (process.env.EXE_SEARCH_LOG !== "0") {
+    const logEntry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      query: queryText,
+      agentId,
+      signals: {
+        fts: ftsResults.length,
+        vector: vectorResults.length,
+        graph: graphResults.length,
+        cards: cardResults.length,
+        reflections: reflectionResults.length,
+        grep: grepResults.length,
+        entitySubqueries: subqueryResults.filter((r) => r.length > 0).length,
+        entityBoost: entityBoostRan,
+        contradictionResolution: merged.length >= 2,
+        reranker: rerankedAndBlended !== null,
+        selfQueryRouter: effectiveQuery !== queryText,
+        inferredTerms: inferredTerms.length > 0 ? inferredTerms : void 0,
+        lowConfidence: finalResults[0]?._lowConfidence ?? false,
+        neighborExpansion: options?.includeSource ? finalResults.filter((r) => r._isNeighbor).length : 0
+      },
+      topResults: finalResults.slice(0, 10).map((r, i) => {
+        const scored = r;
+        return {
+          rank: i + 1,
+          id: r.id.slice(0, 8),
+          tool: r.tool_name,
+          score: scored.distance ?? null,
+          age_hours: Math.round((Date.now() - new Date(r.timestamp).getTime()) / 36e5),
+          neighbor: r._isNeighbor ?? false
+        };
+      }),
+      latencyMs: Date.now() - searchStartMs
+    };
+    try {
+      const fs = await import("fs");
+      const path = await import("path");
+      const os = await import("os");
+      const logPath = path.join(os.homedir(), ".exe-os", "search-quality.jsonl");
+      fs.mkdirSync(path.dirname(logPath), { recursive: true });
+      const MAX_LOG_BYTES = 5 * 1024 * 1024;
+      try {
+        const stat = fs.statSync(logPath);
+        if (stat.size > MAX_LOG_BYTES) {
+          fs.renameSync(logPath, logPath + ".1");
+        }
+      } catch {
+      }
+      try {
+        const backupPath = logPath + ".1";
+        const bstat = fs.statSync(backupPath);
+        if (Date.now() - bstat.mtimeMs > 30 * 24 * 60 * 60 * 1e3) {
+          fs.unlinkSync(backupPath);
+        }
+      } catch {
+      }
+      fs.appendFileSync(logPath, JSON.stringify(logEntry) + "\n");
+    } catch {
+    }
+  }
+  if (finalResults.length > 0) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const ids = finalResults.filter((r) => !r._isNeighbor).map((r) => r.id);
+    if (ids.length === 0) return finalResults;
+    const placeholders = ids.map(() => "?").join(",");
+    try {
+      const client = getClient();
+      void client.execute({
+        sql: `UPDATE memories SET last_accessed = ?, retrieval_count = COALESCE(retrieval_count, 0) + 1, strength = MIN(1.0, COALESCE(strength, 1.0) + 0.1) WHERE id IN (${placeholders})`,
+        args: [now, ...ids]
+      }).catch(() => {
+      });
+    } catch {
+    }
+  }
+  return finalResults;
+}
+async function estimateCardinality(agentId, options) {
+  const client = getClient();
+  let sql = `SELECT COUNT(*) as cnt FROM memories
+             WHERE (agent_id = ? OR agent_id = 'wiki')
+               AND COALESCE(status, 'active') = 'active'
+               AND COALESCE(confidence, 0.7) >= 0.3`;
+  const args = [agentId];
+  const temporal = buildTemporalFilter(options, "");
+  sql += temporal.clause;
+  args.push(...temporal.args);
+  const rawVisibility = buildRawVisibilityFilter(options, "");
+  sql += rawVisibility.clause;
+  args.push(...rawVisibility.args);
+  if (options?.projectName) {
+    sql += ` AND project_name = ?`;
+    args.push(options.projectName);
+  }
+  if (options?.sessionScope) {
+    sql += ` AND (session_scope = ? OR session_scope IS NULL)`;
+    args.push(options.sessionScope);
+  }
+  if (options?.toolName) {
+    sql += ` AND tool_name = ?`;
+    args.push(options.toolName);
+  }
+  if (options?.hasError !== void 0) {
+    sql += ` AND has_error = ?`;
+    args.push(options.hasError ? 1 : 0);
+  }
+  if (options?.since) {
+    sql += ` AND timestamp >= ?`;
+    args.push(options.since);
+  }
+  sql = appendMemoryTypeFilter(sql, args, "memory_type", options);
+  try {
+    const result = await client.execute({ sql, args });
+    return Number(result.rows[0]?.cnt) || 0;
+  } catch {
+    return 0;
+  }
+}
+function rrfMerge(listA, listB, limit, k = RRF_K) {
+  return rrfMergeMulti([listA, listB], limit, k);
+}
+function recencyScore(timestamp) {
+  const daysSince = (Date.now() - new Date(timestamp).getTime()) / (1e3 * 60 * 60 * 24);
+  return 1 / (1 + daysSince * 0.01);
+}
+function normalizedImportance(importance) {
+  return ((importance ?? 5) - 1) / 9;
+}
+function frecencyBoost(lastAccessed, timestamp) {
+  const accessTime = lastAccessed ? new Date(lastAccessed).getTime() : new Date(timestamp).getTime();
+  const hoursSince = Math.max(0, (Date.now() - accessTime) / (1e3 * 60 * 60));
+  return Math.exp(-0.01 * hoursSince);
+}
+function sourceConfidence(record) {
+  const tool = record.tool_name?.toLowerCase() ?? "";
+  if (tool === "manual" || tool === "store_memory") return 0.95;
+  if (tool === "auto-summary" || tool === "consolidation") return 0.9;
+  if (tool === "userprompt" || tool === "assistantresponse") return 0.75;
+  if (tool === "bash" || tool === "write" || tool === "edit") return 0.6;
+  if (tool === "file_grep" || tool === "file_read") return 0.5;
+  return record.confidence ?? 0.5;
+}
+function rrfMergeMulti(lists, limit, k = RRF_K, weights) {
+  const scores = /* @__PURE__ */ new Map();
+  for (let listIdx = 0; listIdx < lists.length; listIdx++) {
+    const list = lists[listIdx];
+    const weight = weights?.[listIdx] ?? 1;
+    for (let i = 0; i < list.length; i++) {
+      const rec = list[i];
+      const entry = scores.get(rec.id) ?? { rrfScore: 0, record: rec, sources: /* @__PURE__ */ new Set() };
+      entry.rrfScore += weight * (1 / (k + i + 1));
+      if (rec._source) entry.sources.add(rec._source);
+      scores.set(rec.id, entry);
+    }
+  }
+  for (const entry of scores.values()) {
+    if (entry.sources.size > 0) {
+      entry.record._source = Array.from(entry.sources).sort().join("+");
+    }
+  }
+  const maxRrf = Math.max(...Array.from(scores.values()).map((e) => e.rrfScore), 0);
+  const entries = Array.from(scores.values()).map((e) => {
+    const recency = recencyScore(e.record.timestamp);
+    const importance = normalizedImportance(e.record.importance);
+    const confidence = sourceConfidence(e.record);
+    const strength = e.record.strength ?? 1;
+    const frecency = frecencyBoost(e.record.last_accessed, e.record.timestamp);
+    const normalizedRrf = maxRrf > 0 ? e.rrfScore / maxRrf : 0;
+    const baseScore = normalizedRrf * 0.4 + recency * 0.24 + importance * 0.2 + confidence * 0.1 + strength * 0.06;
+    const procedureBoost = e.record.memory_type === "procedure" ? 0.1 : 0;
+    const finalScore = (baseScore + procedureBoost) * (1 + 0.3 * frecency);
+    return { score: finalScore, record: e.record };
+  });
+  return entries.sort((a, b) => b.score - a.score).slice(0, limit).map((e) => e.record);
+}
+async function lightweightSearch(queryText, agentId, options) {
+  const client = getClient();
+  const limit = options?.limit ?? 5;
+  const FTS_STOP_WORDS = /* @__PURE__ */ new Set([
+    "the",
+    "and",
+    "but",
+    "for",
+    "not",
+    "you",
+    "your",
+    "his",
+    "her",
+    "its",
+    "our",
+    "their",
+    "this",
+    "that",
+    "these",
+    "those",
+    "what",
+    "when",
+    "where",
+    "who",
+    "how",
+    "why",
+    "which",
+    "does",
+    "did",
+    "was",
+    "were",
+    "has",
+    "have",
+    "had",
+    "can",
+    "could",
+    "would",
+    "should",
+    "are",
+    "with",
+    "from",
+    "about",
+    "into",
+    "through",
+    "during",
+    "before",
+    "after",
+    "above",
+    "below",
+    "between",
+    "same",
+    "each",
+    "every",
+    "both",
+    "more",
+    "most",
+    "other",
+    "some",
+    "such",
+    "than",
+    "too",
+    "very",
+    "just",
+    "also",
+    "any",
+    "all",
+    "own",
+    "being",
+    "been",
+    "they",
+    "them",
+    "will",
+    "may",
+    "might",
+    "shall",
+    "must",
+    "need",
+    "like",
+    "only",
+    "then",
+    "here",
+    "there",
+    "once",
+    "over",
+    "much",
+    "many"
+  ]);
+  const nameTermsSet = /* @__PURE__ */ new Set();
+  const rawWords = queryText.split(/\s+/);
+  for (let i = 0; i < rawWords.length; i++) {
+    const word = rawWords[i].replace(/[^a-zA-Z]/g, "");
+    if (word.length >= 2 && /^[A-Z][a-z]/.test(word) && !/^(What|When|Where|Who|How|Why|Which|Does|Did|Is|Are|Was|Were|Has|Have|Had|Can|Could|Would|Should|Do|The|And|But|For|Not|You|Your|His|Her|Its|Our|Their|This|That|These|Those|Also|Just|Very|Some|Any|All|Each|Every|Both|More|Most|Other)$/.test(word)) {
+      nameTermsSet.add(word.toLowerCase());
+    }
+  }
+  const allTerms = tokenizeForFts(queryText, { maxTerms: 16 }).filter((t) => !FTS_STOP_WORDS.has(t));
+  const contentTerms = allTerms.filter((t) => !nameTermsSet.has(t));
+  const terms = daemonSafeFtsTerms(contentTerms.length > 0 ? contentTerms : allTerms);
+  if (terms.length === 0) {
+    return (await recentRecords(agentId, options, limit)).map((record) => ({
+      ...record,
+      _source: record._source ? `${record._source}+recent-fallback` : "recent-fallback"
+    }));
+  }
+  const usePrefixTerms = shouldUseFtsPrefix(terms);
+  const useAnd = terms.length >= 3;
+  const matchExpr = buildFtsMatch(terms, {
+    prefix: usePrefixTerms,
+    join: useAnd ? "AND" : "OR",
+    columns: ["raw_text", "keywords"]
+  });
+  const results = await ftsQuery(client, matchExpr, agentId, options, limit);
+  const broadOrFallbackIsSafe = !isDaemonProcess() || terms.length < DAEMON_SAFE_FTS_TERM_THRESHOLD;
+  if (useAnd && results.length < limit && broadOrFallbackIsSafe) {
+    const orExpr = buildFtsMatch(terms, {
+      prefix: usePrefixTerms,
+      join: "OR",
+      columns: ["raw_text", "keywords"]
+    });
+    const orResults = await ftsQuery(client, orExpr, agentId, options, limit);
+    const seen = new Set(results.map((r) => r.id));
+    for (const r of orResults) {
+      if (!seen.has(r.id) && results.length < limit) {
+        results.push(r);
+        seen.add(r.id);
+      }
+    }
+  } else if (useAnd && results.length < limit && !broadOrFallbackIsSafe) {
+    logDaemonBroadFtsSkipOnce(terms);
+  }
+  if (options?.includeSource && results.length > 0) {
+    const expanded = await expandNeighborChunks(results, limit);
+    await attachDocumentMetadata(expanded);
+    results.length = 0;
+    results.push(...expanded);
+  }
+  if (results.length >= 2) {
+    try {
+      const { recordCoActivations } = await import("./co-activation-PLLVFEDK.js");
+      const ids = results.slice(0, 10).map((r) => r.id);
+      void recordCoActivations(ids);
+    } catch {
+    }
+  }
+  if (options?.includeStructuredCards !== true) return results;
+  try {
+    const { searchMemoryCards } = await import("./memory-cards-AKXTAQZG.js");
+    const cardResults = await searchMemoryCards(queryText, agentId, options);
+    if (cardResults.length > 0) {
+      return rrfMergeMulti([results, cardResults], limit, RRF_K, [1, 0.85]);
+    }
+  } catch {
+  }
+  return results;
+}
+async function ftsQuery(client, matchExpr, agentId, options, limit) {
+  const statusFilter = options?.includeArchived ? "" : `
+               AND COALESCE(m.status, 'active') = 'active'`;
+  const draftFilter = options?.includeDrafts ? "" : `
+               AND (m.draft = 0 OR m.draft IS NULL)`;
+  let sql = `SELECT m.id, m.agent_id, m.agent_role, m.session_id, m.timestamp,
+                    m.tool_name, m.project_name,
+                    m.has_error, m.raw_text, m.vector, m.task_id,
+                    m.importance, m.status, m.confidence, m.last_accessed,
+                    m.workspace_id, m.document_id, m.user_id,
+                    m.char_offset, m.page_number,
+                    m.source_path, m.source_type, m.memory_type, m.strength
+             FROM memories m
+             JOIN memories_fts fts ON m.rowid = fts.rowid
+             WHERE memories_fts MATCH ?
+               AND (m.agent_id = ? OR m.agent_id = 'wiki')${statusFilter}${draftFilter}
+               AND COALESCE(m.confidence, 0.7) >= 0.3`;
+  const args = [matchExpr, agentId];
+  const temporal = buildTemporalFilter(options, "m.");
+  sql += temporal.clause;
+  args.push(...temporal.args);
+  const scope = buildWikiScopeFilter(options, "m.");
+  sql += scope.clause;
+  args.push(...scope.args);
+  const rawVisibility = buildRawVisibilityFilter(options, "m.");
+  sql += rawVisibility.clause;
+  args.push(...rawVisibility.args);
+  if (options?.projectName) {
+    sql += ` AND m.project_name = ?`;
+    args.push(options.projectName);
+  }
+  if (options?.sessionScope) {
+    sql += ` AND (m.session_scope = ? OR m.session_scope IS NULL)`;
+    args.push(options.sessionScope);
+  }
+  if (options?.toolName) {
+    sql += ` AND m.tool_name = ?`;
+    args.push(options.toolName);
+  }
+  if (options?.hasError !== void 0) {
+    sql += ` AND m.has_error = ?`;
+    args.push(options.hasError ? 1 : 0);
+  }
+  if (options?.since) {
+    sql += ` AND m.timestamp >= ?`;
+    args.push(options.since);
+  }
+  sql = appendMemoryTypeFilter(sql, args, "m.memory_type", options);
+  sql += ` ORDER BY bm25(memories_fts, 1.0, 3.0) LIMIT ?`;
+  args.push(limit);
+  let result;
+  try {
+    result = await client.execute({ sql, args });
+  } catch (ftsErr) {
+    const msg = ftsErr instanceof Error ? ftsErr.message : String(ftsErr);
+    if (msg.includes("fts5") || msg.includes("FTS") || msg.includes("database disk image is malformed")) {
+      process.stderr.write(
+        `[hybrid-search] FTS5 corruption detected during query: ${msg}
+[hybrid-search] Attempting auto-rebuild of memories_fts index...
+`
+      );
+      try {
+        await client.execute("INSERT INTO memories_fts(memories_fts) VALUES('rebuild')");
+        process.stderr.write("[hybrid-search] FTS5 index rebuilt successfully \u2014 retrying query.\n");
+        result = await client.execute({ sql, args });
+      } catch (rebuildErr) {
+        process.stderr.write(
+          `[hybrid-search] FTS5 rebuild failed: ${rebuildErr instanceof Error ? rebuildErr.message : String(rebuildErr)}
+`
+        );
+        return [];
+      }
+    } else {
+      throw ftsErr;
+    }
+  }
+  return result.rows.map((row) => ({
+    id: row.id,
+    agent_id: row.agent_id,
+    agent_role: row.agent_role,
+    session_id: row.session_id,
+    timestamp: row.timestamp,
+    tool_name: row.tool_name,
+    project_name: row.project_name,
+    has_error: row.has_error === 1,
+    raw_text: row.raw_text,
+    vector: row.vector == null ? [] : Array.isArray(row.vector) ? row.vector : blobToVector(row.vector),
+    task_id: row.task_id ?? null,
+    importance: row.importance ?? 5,
+    status: row.status ?? "active",
+    confidence: row.confidence ?? 0.7,
+    last_accessed: row.last_accessed ?? row.timestamp,
+    workspace_id: row.workspace_id ?? null,
+    document_id: row.document_id ?? null,
+    user_id: row.user_id ?? null,
+    char_offset: row.char_offset ?? null,
+    page_number: row.page_number ?? null,
+    source_path: row.source_path ?? null,
+    source_type: row.source_type ?? null,
+    memory_type: row.memory_type ?? void 0
+  }));
+}
+async function recentRecords(agentId, options, limit, textFilter) {
+  const client = getClient();
+  const sessionBoundaryMemories = [];
+  try {
+    const kills = await client.execute({
+      sql: `SELECT killed_at FROM session_kills
+            WHERE agent_id = ?
+            ORDER BY killed_at DESC LIMIT 2`,
+      args: [agentId]
+    });
+    if (kills.rows.length > 0) {
+      const boundarySlots = Math.min(5, Math.floor(limit / 2));
+      for (const kill of kills.rows) {
+        const killedAt = kill.killed_at;
+        const windowStart = new Date(new Date(killedAt).getTime() - 10 * 60 * 1e3).toISOString();
+        const boundaryResult = await client.execute({
+          sql: `SELECT id, agent_id, agent_role, session_id, timestamp,
+                       tool_name, project_name,
+                       has_error, raw_text, vector, task_id,
+                       importance, status, confidence, last_accessed,
+                       workspace_id, document_id, user_id,
+                       char_offset, page_number,
+                       source_path, source_type, memory_type, strength
+                FROM memories
+                WHERE (agent_id = ? OR agent_id = 'wiki')
+                  AND timestamp >= ? AND timestamp <= ?
+                  AND COALESCE(status, 'active') = 'active'
+                  AND ${options?.includeRaw === false ? "COALESCE(memory_type, 'raw') != 'raw'" : "1 = 1"}
+                  ${options?.memoryTypes?.length ? `AND memory_type IN (${options.memoryTypes.map(() => "?").join(",")})` : options?.memoryType ? "AND memory_type = ?" : ""}
+                  AND COALESCE(confidence, 0.7) >= 0.3
+                ORDER BY timestamp DESC LIMIT ?`,
+          args: [
+            agentId,
+            windowStart,
+            killedAt,
+            ...options?.memoryTypes?.length ? [...new Set(options.memoryTypes)] : options?.memoryType ? [options.memoryType] : [],
+            boundarySlots
+          ]
+        });
+        for (const row of boundaryResult.rows) {
+          sessionBoundaryMemories.push(rowToMemoryRecord(row));
+        }
+      }
+    }
+  } catch {
+  }
+  const statusFilter = options?.includeArchived ? "" : `
+               AND COALESCE(status, 'active') = 'active'`;
+  const draftFilter = options?.includeDrafts ? "" : `
+               AND (draft = 0 OR draft IS NULL)`;
+  let sql = `SELECT id, agent_id, agent_role, session_id, timestamp,
+                    tool_name, project_name,
+                    has_error, raw_text, vector, task_id,
+                    importance, status, confidence, last_accessed,
+                    workspace_id, document_id, user_id,
+                    char_offset, page_number,
+                    source_path, source_type, memory_type, strength
+             FROM memories
+             WHERE (agent_id = ? OR agent_id = 'wiki')${statusFilter}${draftFilter}
+               AND COALESCE(confidence, 0.7) >= 0.3`;
+  const args = [agentId];
+  const temporal = buildTemporalFilter(options, "");
+  sql += temporal.clause;
+  args.push(...temporal.args);
+  const scope = buildWikiScopeFilter(options, "");
+  sql += scope.clause;
+  args.push(...scope.args);
+  const rawVisibility = buildRawVisibilityFilter(options, "");
+  sql += rawVisibility.clause;
+  args.push(...rawVisibility.args);
+  if (options?.projectName) {
+    sql += ` AND project_name = ?`;
+    args.push(options.projectName);
+  }
+  if (options?.sessionScope) {
+    sql += ` AND (session_scope = ? OR session_scope IS NULL)`;
+    args.push(options.sessionScope);
+  }
+  if (options?.toolName) {
+    sql += ` AND tool_name = ?`;
+    args.push(options.toolName);
+  }
+  if (options?.hasError !== void 0) {
+    sql += ` AND has_error = ?`;
+    args.push(options.hasError ? 1 : 0);
+  }
+  if (options?.since) {
+    sql += ` AND timestamp >= ?`;
+    args.push(options.since);
+  }
+  sql = appendMemoryTypeFilter(sql, args, "memory_type", options);
+  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 });
+  const recentResults = result.rows.map((row) => rowToMemoryRecord(row));
+  if (sessionBoundaryMemories.length > 0) {
+    const seenIds = new Set(recentResults.map((r) => r.id));
+    for (const bm of sessionBoundaryMemories) {
+      if (!seenIds.has(bm.id)) {
+        recentResults.push(bm);
+        seenIds.add(bm.id);
+      }
+    }
+    recentResults.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+    return recentResults.slice(0, limit);
+  }
+  return recentResults;
+}
+function rowToMemoryRecord(row) {
+  return {
+    id: row.id,
+    agent_id: row.agent_id,
+    agent_role: row.agent_role,
+    session_id: row.session_id,
+    timestamp: row.timestamp,
+    tool_name: row.tool_name,
+    project_name: row.project_name,
+    has_error: row.has_error === 1,
+    raw_text: row.raw_text,
+    vector: row.vector == null ? [] : Array.isArray(row.vector) ? row.vector : blobToVector(row.vector),
+    task_id: row.task_id ?? null,
+    importance: row.importance ?? 5,
+    status: row.status ?? "active",
+    confidence: row.confidence ?? 0.7,
+    last_accessed: row.last_accessed ?? row.timestamp,
+    workspace_id: row.workspace_id ?? null,
+    document_id: row.document_id ?? null,
+    user_id: row.user_id ?? null,
+    char_offset: row.char_offset ?? null,
+    page_number: row.page_number ?? null,
+    source_path: row.source_path ?? null,
+    source_type: row.source_type ?? null,
+    memory_type: row.memory_type ?? void 0,
+    strength: row.strength ?? 1
+  };
+}
+async function expandNeighborChunks(results, limit) {
+  const docChunks = [];
+  for (const r of results) {
+    if (r.document_id) {
+      docChunks.push({ documentId: r.document_id, memoryId: r.id });
+    }
+  }
+  if (docChunks.length === 0) return results;
+  const client = getClient();
+  const existingIds = new Set(results.map((r) => r.id));
+  const neighborRecords = [];
+  const byDoc = /* @__PURE__ */ new Map();
+  for (const { documentId, memoryId } of docChunks) {
+    const ids = byDoc.get(documentId) ?? [];
+    ids.push(memoryId);
+    byDoc.set(documentId, ids);
+  }
+  let remainingSlots = Math.max(0, limit - results.length);
+  for (const [documentId, memoryIds] of byDoc) {
+    if (remainingSlots <= 0) break;
+    for (const memoryId of memoryIds) {
+      if (remainingSlots <= 0) break;
+      try {
+        const pivotResult = await client.execute({
+          sql: `SELECT rowid FROM memories WHERE id = ?`,
+          args: [memoryId]
+        });
+        if (pivotResult.rows.length === 0) continue;
+        const pivotRowid = pivotResult.rows[0].rowid;
+        const neighborsResult = await client.execute({
+          sql: `SELECT id, agent_id, agent_role, session_id, timestamp,
+                       tool_name, project_name, has_error, raw_text, vector,
+                       task_id, importance, status, confidence, last_accessed,
+                       workspace_id, document_id, user_id, char_offset,
+                       page_number, source_path, source_type, memory_type, strength
+                FROM memories
+                WHERE document_id = ?
+                  AND id != ?
+                  AND rowid BETWEEN ? AND ?
+                ORDER BY rowid`,
+          args: [documentId, memoryId, pivotRowid - 2, pivotRowid + 2]
+        });
+        for (const row of neighborsResult.rows) {
+          const neighborId = row.id;
+          if (existingIds.has(neighborId)) continue;
+          if (remainingSlots <= 0) break;
+          const record = rowToMemoryRecord(row);
+          record._isNeighbor = true;
+          record._source = "neighbor";
+          neighborRecords.push(record);
+          existingIds.add(neighborId);
+          remainingSlots--;
+        }
+      } catch {
+      }
+    }
+  }
+  if (neighborRecords.length === 0) return results;
+  const expanded = [];
+  const usedNeighborIds = /* @__PURE__ */ new Set();
+  for (const r of results) {
+    expanded.push(r);
+    if (r.document_id) {
+      const related = neighborRecords.filter(
+        (n) => n.document_id === r.document_id && !usedNeighborIds.has(n.id)
+      );
+      for (const n of related) {
+        if (expanded.length >= limit) break;
+        expanded.push(n);
+        usedNeighborIds.add(n.id);
+      }
+    }
+    if (expanded.length >= limit) break;
+  }
+  return expanded.slice(0, limit);
+}
+var KNOWN_TOOLS = /* @__PURE__ */ new Set([
+  "Bash",
+  "Read",
+  "Write",
+  "Edit",
+  "Grep",
+  "Glob",
+  "Agent",
+  "Skill",
+  "WebSearch",
+  "WebFetch"
+]);
+function detectToolQuery(query) {
+  const lower = query.toLowerCase().trim();
+  for (const tool of KNOWN_TOOLS) {
+    if (lower === `tool:${tool.toLowerCase()}`) return tool;
+  }
+  return null;
+}
+async function trajectoryBypass(queryText, agentId, options, limit) {
+  const toolName = detectToolQuery(queryText);
+  if (!toolName) return null;
+  try {
+    const client = getClient();
+    const statusFilter = options?.includeArchived ? "" : `
+               AND COALESCE(status, 'active') = 'active'`;
+    const draftFilter = options?.includeDrafts ? "" : `
+               AND (draft = 0 OR draft IS NULL)`;
+    let sql = `SELECT id, agent_id, agent_role, session_id, timestamp,
+                      tool_name, project_name,
+                      has_error, raw_text, vector, task_id,
+                      importance, status, confidence, last_accessed,
+                      workspace_id, document_id, user_id,
+                      char_offset, page_number,
+                      source_path, source_type, memory_type
+               FROM memories
+               WHERE trajectory IS NOT NULL
+                 AND json_extract(trajectory, '$.tool') = ?
+                 AND (agent_id = ? OR agent_id = 'wiki')${statusFilter}${draftFilter}`;
+    const args = [toolName, agentId];
+    const temporal = buildTemporalFilter(options, "");
+    sql += temporal.clause;
+    args.push(...temporal.args);
+    const rawVisibility = buildRawVisibilityFilter(options, "");
+    sql += rawVisibility.clause;
+    args.push(...rawVisibility.args);
+    if (options?.projectName) {
+      sql += ` AND project_name = ?`;
+      args.push(options.projectName);
+    }
+    if (options?.sessionScope) {
+      sql += ` AND (session_scope = ? OR session_scope IS NULL)`;
+      args.push(options.sessionScope);
+    }
+    if (options?.since) {
+      sql += ` AND timestamp >= ?`;
+      args.push(options.since);
+    }
+    sql += ` ORDER BY timestamp DESC LIMIT ?`;
+    args.push(limit);
+    const result = await client.execute({ sql, args });
+    if (result.rows.length < 3) return null;
+    return result.rows.map((row) => ({
+      id: row.id,
+      agent_id: row.agent_id,
+      agent_role: row.agent_role,
+      session_id: row.session_id,
+      timestamp: row.timestamp,
+      tool_name: row.tool_name,
+      project_name: row.project_name,
+      has_error: row.has_error === 1,
+      raw_text: row.raw_text,
+      vector: row.vector == null ? [] : Array.isArray(row.vector) ? row.vector : blobToVector(row.vector),
+      task_id: row.task_id ?? null,
+      importance: row.importance ?? 5,
+      status: row.status ?? "active",
+      confidence: row.confidence ?? 0.7,
+      last_accessed: row.last_accessed ?? row.timestamp,
+      workspace_id: row.workspace_id ?? null,
+      document_id: row.document_id ?? null,
+      user_id: row.user_id ?? null,
+      char_offset: row.char_offset ?? null,
+      page_number: row.page_number ?? null,
+      source_path: row.source_path ?? null,
+      source_type: row.source_type ?? null,
+      memory_type: row.memory_type ?? void 0
+    }));
+  } catch {
+    return null;
+  }
+}
+
+export {
+  hybridSearch,
+  estimateCardinality,
+  rrfMerge,
+  rrfMergeMulti,
+  lightweightSearch,
+  recentRecords
+};