sweet-search 2.5.2 → 2.5.4

package/core/cli.js

@@ -20,6 +20,9 @@ if (args[0] === 'init') {
 } else if (args[0] === 'prewarm-vocab') {
   const { handlePrewarmVocabCli } = await import('./vocabulary/index.js');
   await handlePrewarmVocabCli(args.slice(1));
+} else if (args[0] === 'reconcile' || args[0] === 'rebuild') {
+  const { handleIncrementalCli } = await import('./incremental-indexing/application/operator-cli.mjs');
+  await handleIncrementalCli(args[0], args.slice(1));
 } else if (args[0] === 'read') {
   // Filesystem-grounded reader; runs in JS (no native equivalent yet).
   const { handleReadCli } = await import('./search/search-read.js');
@@ -28,6 +31,10 @@ if (args[0] === 'init') {
   // Hybrid span-selection reader; runs in JS (depends on LI index + ranking).
   const { handleReadSemanticCli } = await import('./search/search-read-semantic.js');
   await handleReadSemanticCli(args.slice(1));
+} else if (args[0] === 'trace') {
+  // Unified structural code context: callers, callees, and impact.
+  const { handleTraceCli } = await import('./search/search-trace.js');
+  await handleTraceCli(args.slice(1));
 } else if (args[0] === 'index') {
   // Indexing pipeline. Forwarded to index-codebase-v21.js::main(), which
   // reads its own flags via process.argv. Setting argv here is required
@@ -39,9 +46,15 @@ if (args[0] === 'init') {
   // `index` so existing flag combos (--full / --graph-only / --vectors-only /
   // --files-from-stdin / --late-interaction-model=… / etc.) all work.
   const indexerArgs = args.slice(1);
-  process.argv = [process.argv[0], 'index-codebase-v21.js', ...indexerArgs];
-  const { main: runIndexer } = await import('./indexing/index-codebase-v21.js');
-  await runIndexer();
+  const hasAddHint = indexerArgs.includes('--add') || indexerArgs.some((arg) => arg.startsWith('--add='));
+  if (hasAddHint) {
+    const { handleIndexAddCli } = await import('./incremental-indexing/application/operator-cli.mjs');
+    await handleIndexAddCli(indexerArgs);
+  } else {
+    process.argv = [process.argv[0], 'index-codebase-v21.js', ...indexerArgs];
+    const { main: runIndexer } = await import('./indexing/index-codebase-v21.js');
+    await runIndexer();
+  }
 } else if (args[0] === '--serve' || args[0] === '--stop') {
   // Warm search server lifecycle is implemented in JS.
   const { runCli } = await import('./search/index.js');
@@ -51,9 +64,16 @@ if (args[0] === 'init') {
 
 Usage:
   sweet-search <query>                  Search the indexed codebase
+  sweet-search trace <symbol>           Structural context: callers, callees, impact
   sweet-search read <file...>           Filesystem-grounded read (1-20 files)
   sweet-search read-semantic <f> <q>    Return only file spans relevant to a query
   sweet-search index [options]          Build / update the codebase index
+  sweet-search index --add <path>       Hint a file as dirty
+  sweet-search reconcile status         Show incremental epoch and dirty status
+  sweet-search reconcile inspect <path> Explain why a file is dirty or clean
+  sweet-search reconcile pause|resume   Pause or resume automatic reconcile work
+  sweet-search rebuild status           Show incremental maintenance queue
+  sweet-search rebuild force <tier>     Queue maintenance for a tier
   sweet-search init [options]           Set up runtime assets and models
   sweet-search uninstall [opts]         Remove local state created by init
   sweet-search prewarm-vocab [file]     Pre-warm vocabulary cache with terms
@@ -70,6 +90,7 @@ Indexing flags (sweet-search index ...):
   --graph-only      Build code graph only
   --vectors-only    Build vectors + HNSW only (skips code graph)
   --files-from-stdin  Read newline-delimited paths from stdin
+  --add <path>        Queue a dirty-file hint without running the indexer
   --late-interaction-model=ID  Override the LI variant for this run
   --no-late-interaction        Skip LI index build
   --quiet | --verbose          Logging verbosity

package/core/graph/graph-expansion.js

@@ -12,6 +12,97 @@
 // Default edge types to follow during expansion
 const DEFAULT_EDGE_TYPES = new Set(['imports', 'extends', 'implements', 'uses', 'calls']);
 
+// SQLite-variable-limit guard. Mirrors SAFE_IN_CLAUSE_BATCH in
+// core/infrastructure/db-utils.js; inlined here so this module stays
+// import-free (callers inject all dependencies). 2-hop expansion can in
+// principle balloon to thousands of IDs when a seed entity has many
+// outgoing edges; without this guard, an `IN(?,?,...)` over a >32k array
+// crashes with "too many SQL variables". Fail fast at 999 with a clear
+// message instead.
+const _SAFE_IN_CLAUSE_BATCH = 999;
+function _assertInClauseSize(n, label) {
+  if (n > _SAFE_IN_CLAUSE_BATCH) {
+    throw new RangeError(
+      `${label}: IN(?,?,...) clause would bind ${n} parameters, exceeding ` +
+      `SAFE_IN_CLAUSE_BATCH=${_SAFE_IN_CLAUSE_BATCH}. Chunk via ` +
+      `chunkedIn() in core/infrastructure/db-utils.js or upstream-cap the input.`
+    );
+  }
+}
+
+const _VISIBILITY_CACHE = new WeakMap();
+
+function _sqlAliasPrefix(alias = '') {
+  if (!alias) return '';
+  const normalized = String(alias).endsWith('.') ? String(alias).slice(0, -1) : String(alias);
+  return normalized ? `${normalized}.` : '';
+}
+
+function _visibilityInfo(db) {
+  let cached = _VISIBILITY_CACHE.get(db);
+  if (cached) return cached;
+  const hasColumns = (table, columns) => {
+    try {
+      const names = new Set(db.prepare(`PRAGMA table_info(${table})`).all().map((c) => c.name));
+      return columns.every((c) => names.has(c));
+    } catch {
+      return false;
+    }
+  };
+  cached = {
+    entities: hasColumns('entities', ['epoch_written', 'epoch_retired']),
+    relationships: hasColumns('relationships', ['epoch_written', 'epoch_retired']),
+  };
+  _VISIBILITY_CACHE.set(db, cached);
+  return cached;
+}
+
+function _entityVisibility(db, manifestEpoch, alias = '', options = {}) {
+  const prefix = _sqlAliasPrefix(alias);
+  let sql;
+  if (!_visibilityInfo(db).entities) {
+    sql = `${prefix}stale_since IS NULL`;
+  } else if (Number.isInteger(manifestEpoch)) {
+    sql = `(${prefix}epoch_written IS NULL OR ${prefix}epoch_written <= ?)
+      AND (${prefix}epoch_retired IS NULL OR ${prefix}epoch_retired > ?)
+      AND (${prefix}stale_since IS NULL OR (${prefix}epoch_retired IS NOT NULL AND ${prefix}epoch_retired > ?))`;
+  } else {
+    sql = `${prefix}stale_since IS NULL AND ${prefix}epoch_retired IS NULL`;
+  }
+  return {
+    sql: options.allowNullJoined ? `(${sql} OR ${prefix}id IS NULL)` : sql,
+    params: _visibilityInfo(db).entities && Number.isInteger(manifestEpoch)
+      ? [manifestEpoch, manifestEpoch, manifestEpoch]
+      : [],
+  };
+}
+
+function _relationshipVisibility(db, manifestEpoch, alias = '') {
+  const prefix = _sqlAliasPrefix(alias);
+  if (!_visibilityInfo(db).relationships) return { sql: '1=1', params: [] };
+  if (Number.isInteger(manifestEpoch)) {
+    return {
+      sql: `(${prefix}epoch_written IS NULL OR ${prefix}epoch_written <= ?)
+        AND (${prefix}epoch_retired IS NULL OR ${prefix}epoch_retired > ?)`,
+      params: [manifestEpoch, manifestEpoch],
+    };
+  }
+  return { sql: `${prefix}epoch_retired IS NULL`, params: [] };
+}
+
+// Per-stage profiling hooks. No-op unless `globalThis.__stageTimings` is set
+// by scripts/profile-search-stages.mjs (same convention as search-hybrid.js
+// and search-postprocess.js).
+function __ptStart() {
+  return globalThis.__stageTimings ? performance.now() : null;
+}
+function __ptEnd(stage, t0) {
+  if (t0 == null || !globalThis.__stageTimings) return;
+  const ms = performance.now() - t0;
+  const buf = globalThis.__stageTimings;
+  (buf[stage] = buf[stage] || []).push(ms);
+}
+
 // --- Token Estimation Helpers ---
 
 // Language-specific tokens-per-line averages (from CodeSearchNet analysis)
@@ -66,6 +157,7 @@ export function loadChunkTexts(codebaseDbOrRepo, ids) {
   }
   // Legacy raw-DB path (backward compat)
   try {
+    _assertInClauseSize(ids.length, 'graph-expansion.getChunkTexts');
     const ph = ids.map(() => '?').join(',');
     const rows = codebaseDbOrRepo.prepare(
       `SELECT id, text FROM vectors WHERE id IN (${ph})`
@@ -201,20 +293,52 @@ export function expandResults(db, results, options = {}) {
     cosineSimilarity = null,
     codebaseDb = null,
     readFileLines = null,
+    format = null,
+    manifestEpoch = null,
   } = options;
+  // F1 envelope cap (2026-05-07): drop graph-expanded entities whose line span
+  // exceeds maxEnvelopeLines. The taxonomy diagnosed mega-class envelopes
+  // (Flask App 951L, Scaffold 646L, uv do_lock 555L) as the #1 failure mode —
+  // these are pulled from the entity DB by graph expansion, not the chunker.
+  // Capped here so the seed chunks (30-60 lines each) keep the top spot.
+  //
+  // Format-gated to agent: GCSN NL queries don't carry format='agent' so are
+  // unaffected. Cap default 500 was selected by dev sweep over {Inf, 500, 300,
+  // 200, 150, 100}: cap=500 was the only value with zero regressions on
+  // FreshStack uv (lower caps regressed PASS counts). Yields +1 probe PASS
+  // (S5-Q9 Flask Scaffold class) and +1 FreshStack PARTIAL (UV-NL-2 do_lock).
+  // Held-out probes flat — no overfit signature, but also no held-out transfer
+  // since the failure mode (mega-class envelope) isn't present in held-out.
+  const maxEnvelopeLines = (() => {
+    const raw = process.env.SWEET_SEARCH_MAX_ENVELOPE_LINES;
+    if (raw != null && raw !== '') {
+      const n = Number.parseInt(raw, 10);
+      if (Number.isFinite(n) && n > 0) return n;
+    }
+    return options.maxEnvelopeLines ?? 500;
+  })();
+  const isAgentFormat = format === 'agent' || format === 'agent_full'
+    || format === 'agent_full_xl' || format === 'agent_preview'
+    || process.env.SWEET_SEARCH_FORCE_BM25F_BOOSTS === '1';
+  const envelopeCapEnabled = isAgentFormat && Number.isFinite(maxEnvelopeLines);
   const clampedSemanticWeight = clampSemanticWeight(semanticWeight);
 
   if (expandMode === 'none' || results.length === 0) return results;
 
   // Collect entity IDs from results
-  const seedIds = collectSeedIds(db, results);
+  const __t_seeds = __ptStart();
+  const seedIds = collectSeedIds(db, results, { manifestEpoch });
+  __ptEnd('expand:collectSeedIds', __t_seeds);
   if (seedIds.size === 0) return results;
 
   // 1-hop expansion: find neighbors via forward + reverse edges
-  const expanded = expandOneHop(db, seedIds, edgeTypes);
+  const __t_hop1 = __ptStart();
+  const expanded = expandOneHop(db, seedIds, edgeTypes, { manifestEpoch });
+  __ptEnd('expand:expandOneHop', __t_hop1);
 
   // 2-hop expansion (if requested)
   if (expandMode === '2hop' && expanded.size > 0) {
+    const __t_hop2 = __ptStart();
     if (adaptiveHop2) {
       expandSecondHopAdaptive(db, seedIds, expanded, edgeTypes, {
         maxHop2: maxExpanded,
@@ -223,6 +347,7 @@ export function expandResults(db, results, options = {}) {
         hnswIndex,
         semanticWeight: clampedSemanticWeight,
         cosineSimilarity,
+        manifestEpoch,
       });
     } else {
       expandSecondHop(db, seedIds, expanded, edgeTypes, {
@@ -230,15 +355,31 @@ export function expandResults(db, results, options = {}) {
         hnswIndex,
         semanticWeight: clampedSemanticWeight,
         cosineSimilarity,
+        manifestEpoch,
       });
     }
+    __ptEnd(adaptiveHop2 ? 'expand:expandSecondHopAdaptive' : 'expand:expandSecondHop', __t_hop2);
   }
 
   if (expanded.size === 0) return results;
 
   // Look up entity details for expanded IDs, respecting maxExpanded
   const expandedIds = [...expanded.keys()].slice(0, maxExpanded);
-  const expandedResults = lookupEntities(db, expandedIds, expanded);
+  const __t_lookup = __ptStart();
+  let expandedResults = lookupEntities(db, expandedIds, expanded, { manifestEpoch });
+  __ptEnd('expand:lookupEntities', __t_lookup);
+
+  // F1 envelope cap: drop expanded entities exceeding line cap (agent format only).
+  if (envelopeCapEnabled && expandedResults.length > 0) {
+    const beforeLen = expandedResults.length;
+    expandedResults = expandedResults.filter(er => {
+      const lines = (er.endLine - er.startLine) + 1;
+      return Number.isFinite(lines) && lines <= maxEnvelopeLines;
+    });
+    if (process.env.SWEET_SEARCH_DEBUG_ENVELOPE_CAP === '1' && expandedResults.length < beforeLen) {
+      console.warn(`[envelope-cap] dropped ${beforeLen - expandedResults.length}/${beforeLen} expanded entities (cap=${maxEnvelopeLines})`);
+    }
+  }
 
   // Score expanded results relative to original results
   const maxOriginalScore = Math.max(...results.map(r => r.score || 0), 1);
@@ -249,18 +390,22 @@ export function expandResults(db, results, options = {}) {
   }
 
   // Rerank expanded results using composite scoring (file proximity + entity type + semantic)
+  const __t_rerank = __ptStart();
   rerankExpanded(expandedResults, results, {
     queryInt8,
     hnswIndex,
     semanticWeight: clampedSemanticWeight,
     cosineSimilarity,
   });
+  __ptEnd('expand:rerankExpanded', __t_rerank);
 
   // Apply token budget
+  const __t_budget = __ptStart();
   const { results: budgeted, stats: budgetStats } = applyTokenBudget(
     [...results, ...expandedResults], tokenBudget,
     { expandedBudget, codebaseDb, readFileLines }
   );
+  __ptEnd('expand:applyTokenBudget', __t_budget);
 
   budgeted._budgetStats = budgetStats;
   return budgeted;
@@ -274,7 +419,7 @@ export function expandResults(db, results, options = {}) {
  * @param {Array} results
  * @returns {Set<string>}
  */
-function collectSeedIds(db, results) {
+function collectSeedIds(db, results, options = {}) {
   const seedIds = new Set();
   const needsLineMatch = [];
 
@@ -295,13 +440,28 @@ function collectSeedIds(db, results) {
 
   if (needsLineMatch.length === 0) return seedIds;
 
-  // Line-range fallback for chunk-id keyed results.
-  let entityLookup;
+  // Per-result indexed point query. Hybrid output is keyed on chunk-ids
+  // (path:start-end:n), so this fallback is the COMMON path for graph
+  // expansion, not a rare one. The original implementation did a full
+  // SELECT * FROM entities and then an O(N×M) JS-side scan to find the
+  // smallest overlapping entity per result — costing ~11ms p50 on
+  // production-sized indexes (10 results × 100k+ entities = 1M JS-side
+  // comparisons + materialization GC). Replaced with a single prepared
+  // statement that uses the (file_path, start_line, end_line) index for
+  // O(log N) lookup. Reuses the same prepared statement across all
+  // needsLineMatch results in one collectSeedIds call.
+  let findStmt;
   try {
-    entityLookup = db.prepare(`
-      SELECT id, file_path, start_line, end_line
-      FROM entities WHERE stale_since IS NULL
-    `).all();
+    const entityVis = _entityVisibility(db, options.manifestEpoch);
+    findStmt = db.prepare(`
+      SELECT id FROM entities
+      WHERE file_path = ?
+        AND start_line <= ?
+        AND end_line >= ?
+        AND ${entityVis.sql}
+      ORDER BY (end_line - start_line) ASC
+      LIMIT 1
+    `);
   } catch {
     return seedIds;
   }
@@ -331,23 +491,19 @@ function collectSeedIds(db, results) {
       }
     }
     if (!filePath || lineStart == null) continue;
-    // If we still don't have an end line, treat the chunk as a single line.
     if (lineEnd == null) lineEnd = lineStart;
 
-    // Find the SMALLEST entity that overlaps the chunk's [start, end] —
-    // smaller entities (functions/methods) are more meaningful seeds than
-    // file-level container entities. Cap to one seed per result to avoid
-    // unbounded seed-set blow-up that can break the relationships SQL.
-    let bestId = null;
-    let bestSize = Infinity;
-    for (const e of entityLookup) {
-      if (e.file_path !== filePath) continue;
-      if (e.start_line == null || e.end_line == null) continue;
-      if (e.start_line > lineEnd || e.end_line < lineStart) continue;
-      const size = (e.end_line - e.start_line) + 1;
-      if (size < bestSize) { bestSize = size; bestId = e.id; }
+    // Smallest enclosing/overlapping entity wins (functions/methods over
+    // file-level containers). The SQL ORDER BY (end_line - start_line) ASC
+    // matches the JS `bestSize` selection in the prior implementation
+    // exactly: same overlap predicate, same tie-breaker.
+    try {
+      const row = findStmt.get(filePath, lineEnd, lineStart, ..._entityVisibility(db, options.manifestEpoch).params);
+      if (row?.id) seedIds.add(row.id);
+    } catch {
+      // Skip this result; preserves prior behavior of silently dropping
+      // entries the lookup couldn't match.
     }
-    if (bestId) seedIds.add(bestId);
   }
 
   return seedIds;
@@ -361,18 +517,21 @@ function collectSeedIds(db, results) {
  * @param {Set<string>} edgeTypes
  * @returns {Map<string, {via: string, direction: string, score: number, hops?: number}>}
  */
-export function expandOneHop(db, seedIds, edgeTypes) {
+export function expandOneHop(db, seedIds, edgeTypes, options = {}) {
   const expanded = new Map();
   const seedArray = [...seedIds];
+  _assertInClauseSize(seedArray.length, 'graph-expansion.expandOneHop.seeds');
   const placeholders = seedArray.map(() => '?').join(',');
 
   // Forward edges: seed -> neighbor
   let forwardRels;
   try {
+    const relVis = _relationshipVisibility(db, options.manifestEpoch);
     forwardRels = db.prepare(`
       SELECT DISTINCT target_id, type FROM relationships
       WHERE source_id IN (${placeholders}) AND target_id IS NOT NULL
-    `).all(...seedArray);
+        AND ${relVis.sql}
+    `).all(...seedArray, ...relVis.params);
   } catch {
     forwardRels = [];
   }
@@ -380,10 +539,12 @@ export function expandOneHop(db, seedIds, edgeTypes) {
   // Reverse edges: neighbor -> seed
   let reverseRels;
   try {
+    const relVis = _relationshipVisibility(db, options.manifestEpoch);
     reverseRels = db.prepare(`
       SELECT DISTINCT source_id, type FROM relationships
       WHERE target_id IN (${placeholders}) AND source_id IS NOT NULL
-    `).all(...seedArray);
+        AND ${relVis.sql}
+    `).all(...seedArray, ...relVis.params);
   } catch {
     reverseRels = [];
   }
@@ -427,15 +588,18 @@ export function expandSecondHop(db, seedIds, expanded, edgeTypes, options = {})
 
   const hop1Ids = [...expanded.keys()];
   if (hop1Ids.length === 0) return;
+  _assertInClauseSize(hop1Ids.length, 'graph-expansion.expand2Hop.forward');
 
   const ph = hop1Ids.map(() => '?').join(',');
 
   let hop2Forward;
   try {
+    const relVis = _relationshipVisibility(db, options.manifestEpoch);
     hop2Forward = db.prepare(`
       SELECT source_id, target_id, type FROM relationships
       WHERE source_id IN (${ph}) AND target_id IS NOT NULL
-    `).all(...hop1Ids);
+        AND ${relVis.sql}
+    `).all(...hop1Ids, ...relVis.params);
   } catch {
     return;
   }
@@ -520,6 +684,7 @@ export function expandSecondHopAdaptive(db, seedIds, hop1Expanded, edgeTypes, op
 
   const hop1Ids = [...hop1Expanded.keys()];
   if (hop1Ids.length === 0) return { added: 0, budgetUsed: 0, candidates: 0 };
+  _assertInClauseSize(hop1Ids.length, 'graph-expansion.expand2HopRanked.hop1');
 
   const ph = hop1Ids.map(() => '?').join(',');
 
@@ -531,11 +696,13 @@ export function expandSecondHopAdaptive(db, seedIds, hop1Expanded, edgeTypes, op
   const typeList = [...edgeTypes].map(t => `'${t}'`).join(',');
   let degreeMap;
   try {
+    const relVis = _relationshipVisibility(db, options.manifestEpoch);
     const degRows = db.prepare(`
       SELECT source_id, COUNT(*) as deg FROM relationships
       WHERE source_id IN (${ph}) AND type IN (${typeList})
+        AND ${relVis.sql}
       GROUP BY source_id
-    `).all(...hop1Ids);
+    `).all(...hop1Ids, ...relVis.params);
     degreeMap = new Map(degRows.map(r => [r.source_id, r.deg]));
   } catch {
     degreeMap = new Map();
@@ -544,12 +711,15 @@ export function expandSecondHopAdaptive(db, seedIds, hop1Expanded, edgeTypes, op
   // Query candidate 2-hop targets with source, weights, and line ranges
   let rawCandidates;
   try {
+    const entityVis = _entityVisibility(db, options.manifestEpoch, 'e');
+    const relVis = _relationshipVisibility(db, options.manifestEpoch, 'r');
     rawCandidates = db.prepare(`
       SELECT r.source_id, r.target_id, r.type, r.weight, e.file_path, e.start_line, e.end_line
       FROM relationships r
-      JOIN entities e ON e.id = r.target_id AND e.stale_since IS NULL
+      JOIN entities e ON e.id = r.target_id AND ${entityVis.sql}
       WHERE r.source_id IN (${ph}) AND r.target_id IS NOT NULL
-    `).all(...hop1Ids);
+        AND ${relVis.sql}
+    `).all(...entityVis.params, ...hop1Ids, ...relVis.params);
   } catch {
     return { added: 0, budgetUsed: 0, candidates: 0 };
   }
@@ -667,16 +837,18 @@ export function expandSecondHopAdaptive(db, seedIds, hop1Expanded, edgeTypes, op
  * @param {Map<string, Object>} expansionMeta
  * @returns {Array}
  */
-function lookupEntities(db, expandedIds, expansionMeta) {
+function lookupEntities(db, expandedIds, expansionMeta, options = {}) {
   if (expandedIds.length === 0) return [];
+  _assertInClauseSize(expandedIds.length, 'graph-expansion.lookupEntities');
 
   const ph = expandedIds.map(() => '?').join(',');
   let entities;
   try {
+    const entityVis = _entityVisibility(db, options.manifestEpoch);
     entities = db.prepare(`
       SELECT id, file_path, type, name, signature, start_line, end_line
-      FROM entities WHERE id IN (${ph}) AND stale_since IS NULL
-    `).all(...expandedIds);
+      FROM entities WHERE id IN (${ph}) AND ${entityVis.sql}
+    `).all(...expandedIds, ...entityVis.params);
   } catch {
     return [];
   }
@@ -852,18 +1024,25 @@ export function applyTokenBudget(results, budget, options = {}) {
  * @param {string[]} entityIds
  * @returns {{ total: number, byType: Record<string, number> }}
  */
-export function getExpansionStats(db, entityIds) {
+export function getExpansionStats(db, entityIds, options = {}) {
   if (!entityIds || entityIds.length === 0) return { total: 0, byType: {} };
+  // The query interpolates `${ph}` twice (source_id IN OR target_id IN) and the
+  // `.all()` call binds entityIds twice in one prepared statement, so the
+  // SQLite-parameter ceiling is reached at half the array length — guard the
+  // actual bind count, not the array length.
+  _assertInClauseSize(2 * entityIds.length, 'graph-expansion.getExpansionStats (double-bind OR)');
 
   const ph = entityIds.map(() => '?').join(',');
   let rels;
   try {
+    const relVis = _relationshipVisibility(db, options.manifestEpoch);
     rels = db.prepare(`
       SELECT type, COUNT(*) as count FROM relationships
       WHERE (source_id IN (${ph}) OR target_id IN (${ph}))
       AND source_id IS NOT NULL AND target_id IS NOT NULL
+      AND ${relVis.sql}
       GROUP BY type
-    `).all(...entityIds, ...entityIds);
+    `).all(...entityIds, ...entityIds, ...relVis.params);
   } catch {
     return { total: 0, byType: {} };
   }