sweet-search 2.6.8 → 2.6.10

package/core/infrastructure/simd-distance.js

@@ -98,6 +98,23 @@ async function initWasm() {
 // Eager non-blocking init
 initWasm().catch(() => {});
 
+// WASM memory views are cached; both modules declare fixed-size memory (no
+// memory.grow anywhere), so the buffer identity check only fires if that
+// ever changes. Same pattern as _wasmPerTokenLayout.
+function wasmMemView() {
+  if (wasmMem === null || wasmMem.buffer !== wasmExports.memory.buffer) {
+    wasmMem = new Uint8Array(wasmExports.memory.buffer);
+  }
+  return wasmMem;
+}
+
+function maxsimMemView() {
+  if (maxsimMem === null || maxsimMem.buffer !== maxsimExports.memory.buffer) {
+    maxsimMem = new Uint8Array(maxsimExports.memory.buffer);
+  }
+  return maxsimMem;
+}
+
 // =============================================================================
 // POPCOUNT LUT (JS fallback)
 // =============================================================================
@@ -115,10 +132,9 @@ export function wasmHammingDistance(a, b) {
   if (wasmExports) {
     const aPtr = DATA_OFFSET;
     const bPtr = DATA_OFFSET + a.length;
-    // Re-acquire view in case memory grew
-    wasmMem = new Uint8Array(wasmExports.memory.buffer);
-    wasmMem.set(a, aPtr);
-    wasmMem.set(b, bPtr);
+    const mem = wasmMemView();
+    mem.set(a, aPtr);
+    mem.set(b, bPtr);
     return wasmExports.hamming_distance(aPtr, bPtr, a.length);
   }
   // JS fallback
@@ -137,9 +153,9 @@ export function wasmInt8Cosine(a, b) {
   if (wasmExports) {
     const aPtr = DATA_OFFSET;
     const bPtr = DATA_OFFSET + a.length;
-    wasmMem = new Uint8Array(wasmExports.memory.buffer);
-    wasmMem.set(new Uint8Array(a.buffer, a.byteOffset, a.byteLength), aPtr);
-    wasmMem.set(new Uint8Array(b.buffer, b.byteOffset, b.byteLength), bPtr);
+    const mem = wasmMemView();
+    mem.set(new Uint8Array(a.buffer, a.byteOffset, a.byteLength), aPtr);
+    mem.set(new Uint8Array(b.buffer, b.byteOffset, b.byteLength), bPtr);
 
     const dot = wasmExports.int8_dot(aPtr, bPtr, a.length);
     const normA = wasmExports.int8_norm_sq(aPtr, a.length);
@@ -193,18 +209,18 @@ export function wasmInt8BatchDot(query, candidates) {
     const alignedScoresPtr = (scoresPtr + 3) & ~3;
     const needed = alignedScoresPtr + count * 4;
 
-    wasmMem = new Uint8Array(wasmExports.memory.buffer);
-    if (needed > wasmMem.length) {
+    const mem = wasmMemView();
+    if (needed > mem.length) {
       return _jsInt8BatchDot(query, candidates);
     }
 
     // Copy query once
-    wasmMem.set(new Uint8Array(query.buffer, query.byteOffset, query.byteLength), queryPtr);
+    mem.set(new Uint8Array(query.buffer, query.byteOffset, query.byteLength), queryPtr);
 
     // Copy all candidates as contiguous slab
     for (let i = 0; i < count; i++) {
       const v = candidates[i];
-      wasmMem.set(new Uint8Array(v.buffer, v.byteOffset, v.byteLength), slabPtr + i * dim);
+      mem.set(new Uint8Array(v.buffer, v.byteOffset, v.byteLength), slabPtr + i * dim);
     }
 
     // Single WASM call: scores all candidates internally, writes to output buffer
@@ -267,9 +283,9 @@ export function wasmInt8Dot(a, b) {
   if (wasmExports) {
     const aPtr = DATA_OFFSET;
     const bPtr = DATA_OFFSET + a.length;
-    wasmMem = new Uint8Array(wasmExports.memory.buffer);
-    wasmMem.set(new Uint8Array(a.buffer, a.byteOffset, a.byteLength), aPtr);
-    wasmMem.set(new Uint8Array(b.buffer, b.byteOffset, b.byteLength), bPtr);
+    const mem = wasmMemView();
+    mem.set(new Uint8Array(a.buffer, a.byteOffset, a.byteLength), aPtr);
+    mem.set(new Uint8Array(b.buffer, b.byteOffset, b.byteLength), bPtr);
     return wasmExports.int8_dot(aPtr, bPtr, a.length);
   }
   // JS fallback
@@ -290,9 +306,9 @@ export function wasmAsymmetricDistance(docBinary, queryInt4, queryNormScaled) {
   if (wasmExports) {
     const docPtr = DATA_OFFSET;
     const queryPtr = DATA_OFFSET + docBinary.length;
-    wasmMem = new Uint8Array(wasmExports.memory.buffer);
-    wasmMem.set(docBinary, docPtr);
-    wasmMem.set(new Uint8Array(queryInt4.buffer, queryInt4.byteOffset, queryInt4.byteLength), queryPtr);
+    const mem = wasmMemView();
+    mem.set(docBinary, docPtr);
+    mem.set(new Uint8Array(queryInt4.buffer, queryInt4.byteOffset, queryInt4.byteLength), queryPtr);
     return wasmExports.asymmetric_distance(docPtr, queryPtr, queryInt4.length, queryNormScaled);
   }
   // JS fallback
@@ -336,9 +352,7 @@ export function wasmMaxSimF32(queryFlat, docFlat, numQ, numD, dim) {
   if (!maxsimExports?.maxsim_f32) return null;
   const exports = maxsimExports;
 
-  const mem = maxsimExports
-    ? new Uint8Array(maxsimExports.memory.buffer)
-    : (wasmMem = new Uint8Array(wasmExports.memory.buffer));
+  const mem = maxsimMemView();
 
   const qBytes = numQ * dim * 4;
   const dBytes = numD * dim * 4;
@@ -375,7 +389,7 @@ export function wasmMaxSimDequant(queryFlat, docInt8, numQ, numD, dim, min, scal
   const qBytes = numQ * dim * 4; // float32
   const dBytes = numD * dim;     // int8 (4x smaller!)
 
-  const mem = new Uint8Array(maxsimExports.memory.buffer);
+  const mem = maxsimMemView();
   if (qBytes + dBytes + 1024 > mem.length) return null;
 
   const qPtr = DATA_OFFSET;

package/core/infrastructure/tombstone-bitmap-reader.js

@@ -49,8 +49,10 @@ export function loadBitmap(filePath) {
   if (raw.length < expectedLength) {
     throw new Error(`loadBitmap: ${filePath} truncated payload (${raw.length} bytes, expected ${expectedLength})`);
   }
+  // View, not copy: `raw` is otherwise unreferenced, so this only keeps the
+  // 64-byte header alive alongside the payload bytes.
   const payload = raw.subarray(HEADER_RESERVED, HEADER_RESERVED + payloadByteLength(capacity));
-  return { capacity, payload: Buffer.from(payload) };
+  return { capacity, payload };
 }
 
 export function saveBitmap(filePath, bitmap) {

package/core/ranking/file-kind-ranking.js

@@ -533,11 +533,23 @@ function envFloat(name, dflt) {
   return Number.isFinite(n) && n > 0 ? n : dflt;
 }
 
+// Pure function of `preferred` (static ENTITY_KIND_KEYWORDS table) — memoize
+// the last kind so the per-result demotion loop reuses one Set.
+let _kindKeywordSetKey;
+let _kindKeywordSet;
+function kindKeywordSet(preferred) {
+  if (preferred !== _kindKeywordSetKey) {
+    _kindKeywordSetKey = preferred;
+    _kindKeywordSet = new Set((ENTITY_KIND_KEYWORDS[preferred] || []).map(normalizeType));
+  }
+  return _kindKeywordSet;
+}
+
 function entityKindMultiplier(r, preferred, opts = {}) {
   if (!preferred) return 1;
   const kindBoost = envFloat('SWEET_SEARCH_KIND_BOOST', 1.10);
   const kindDemote = envFloat('SWEET_SEARCH_KIND_DEMOTE', 0.90);
-  const wantSet = new Set((ENTITY_KIND_KEYWORDS[preferred] || []).map(normalizeType));
+  const wantSet = kindKeywordSet(preferred);
   const inferred = resolveEntityKindInfo(r, opts)?.type || '';
   const recorded = normalizeType(resolveResultType(r));
   const type = recorded && recorded !== 'code' && recorded !== 'chunk' ? recorded : normalizeType(inferred);
@@ -550,7 +562,7 @@ function namePrecisionMultiplier(r, preferred, nameHintsLower, opts = {}) {
   if (!preferred || nameHintsLower.size === 0) return 1;
   const exactBoost = envFloat('SWEET_SEARCH_NAME_EXACT_BOOST', 1.10);
   const substrBoost = envFloat('SWEET_SEARCH_NAME_SUBSTR_BOOST', 1.03);
-  const wantSet = new Set((ENTITY_KIND_KEYWORDS[preferred] || []).map(normalizeType));
+  const wantSet = kindKeywordSet(preferred);
   const entityInfo = resolveEntityKindInfo(r, opts);
   const recorded = normalizeType(resolveResultType(r));
   const type = recorded && recorded !== 'code' && recorded !== 'chunk'

package/core/ranking/late-interaction-index.js

@@ -12,6 +12,7 @@
 
 import fs from 'fs/promises';
 import { existsSync, createWriteStream, createReadStream, statSync } from 'fs';
+import readline from 'readline';
 import path from 'path';
 import { DB_PATHS, LATE_INTERACTION_CONFIG } from '../infrastructure/config/index.js';
 import { wasmMaxSimF32, wasmMaxSimDequantPerToken, wasmMaxSimDequant4Bit, nativeMaxSimBatch, nativeMaxSimBatchPerToken, nativeMaxSimBatch4Bit, initWasm, isNativeMaxSimAvailable, isNativePerTokenAvailable, isNative4BitAvailable } from '../infrastructure/simd-distance.js';
@@ -938,33 +939,90 @@ export class LateInteractionIndex {
   }
 
   async _saveAliasSidecar(indexPath = this.indexPath) {
+    const sidecarPath = this._aliasSidecarPath(indexPath);
     if (this.aliasPointers.size === 0) {
       // Remove any stale sidecar from a previous build.
-      try { await fs.unlink(this._aliasSidecarPath(indexPath)); } catch (_e) { /* not present */ }
+      try { await fs.unlink(sidecarPath); } catch (_e) { /* not present */ }
       return;
     }
-    const entries = [];
-    for (const [aliasId, ptr] of this.aliasPointers) {
-      entries.push({
-        aliasId,
-        exemplarId: ptr.exemplarId,
-        clusterId: ptr.clusterId,
-        metadata: ptr.metadata || {},
-      });
+    // NDJSON (version 2): one header line, then one alias pointer per line,
+    // flushed through a write stream in bounded batches. The previous
+    // monolithic JSON.stringify of the whole payload hits V8's ~512 MB string
+    // ceiling ("Invalid string length") on extreme-dedup repos, and the
+    // matching readFile on load had the same ceiling.
+    const ws = createWriteStream(sidecarPath, { encoding: 'utf8' });
+    const finished = new Promise((resolve, reject) => {
+      ws.on('error', reject);
+      ws.on('finish', resolve);
+    });
+    const flush = (str) => new Promise((resolve, reject) => {
+      ws.write(str, (err) => (err ? reject(err) : resolve()));
+    });
+    try {
+      let lines = [JSON.stringify({ version: 2, count: this.aliasPointers.size })];
+      for (const [aliasId, ptr] of this.aliasPointers) {
+        lines.push(JSON.stringify({
+          aliasId,
+          exemplarId: ptr.exemplarId,
+          clusterId: ptr.clusterId,
+          metadata: ptr.metadata || {},
+        }));
+        if (lines.length >= 20000) {
+          await flush(lines.join('\n') + '\n');
+          lines = [];
+        }
+      }
+      if (lines.length > 0) await flush(lines.join('\n') + '\n');
+      ws.end();
+      await finished;
+    } catch (err) {
+      finished.catch(() => { /* surfaced via throw below */ });
+      ws.destroy();
+      throw err;
     }
-    const payload = { version: 1, count: entries.length, aliases: entries };
-    await fs.writeFile(this._aliasSidecarPath(indexPath), JSON.stringify(payload));
   }
 
   async _loadAliasSidecar(indexPath = this.indexPath) {
     const p = this._aliasSidecarPath(indexPath);
     if (!existsSync(p)) return;
+    // Streamed line-by-line so no single string approaches V8's ~512 MB
+    // ceiling. Two on-disk formats:
+    //   v1 — one JSON.stringify'd { version: 1, aliases: [...] } line
+    //   v2 — NDJSON: { version: 2, count } header, then one alias per line
+    //
+    // The input stream is destroyed in `finally`: early returns abandon the
+    // readline iterator, and rl.close() does NOT destroy its input — an
+    // fs read stream only auto-closes on 'end'/'error', so without the
+    // explicit destroy every early return leaks an fd (fatal only in
+    // long-lived processes like the daemon, but a leak everywhere).
+    const input = createReadStream(p, { encoding: 'utf8' });
+    const rl = readline.createInterface({ input, crlfDelay: Infinity });
     try {
-      const raw = await fs.readFile(p, 'utf-8');
-      const payload = JSON.parse(raw);
-      if (!payload || !Array.isArray(payload.aliases)) return;
       this.aliasPointers.clear();
-      for (const { aliasId, exemplarId, clusterId, metadata } of payload.aliases) {
+      let first = true;
+      let expected = 0;
+      let parsed = 0;
+      for await (const line of rl) {
+        if (!line) continue;
+        if (first) {
+          first = false;
+          const head = JSON.parse(line);
+          if (head && Array.isArray(head.aliases)) {
+            // v1 monolithic payload — the whole sidecar is this one line,
+            // so JSON.parse succeeding IS the integrity check (any
+            // truncation makes it unparseable).
+            for (const { aliasId, exemplarId, clusterId, metadata } of head.aliases) {
+              if (!this.documents.has(exemplarId)) continue; // orphan guard, see below
+              this.aliasPointers.set(aliasId, { exemplarId, clusterId, metadata: metadata || {} });
+            }
+            return;
+          }
+          if (!head || head.version !== 2 || !Number.isFinite(head.count)) return;
+          expected = head.count;
+          continue;
+        }
+        const { aliasId, exemplarId, clusterId, metadata } = JSON.parse(line);
+        parsed++;
         // Orphan guard: drop aliases whose exemplar is no longer in documents.
         // Happens if the file containing the exemplar was removed between
         // save and load (incremental re-index removed the exemplar file
@@ -972,8 +1030,21 @@ export class LateInteractionIndex {
         if (!this.documents.has(exemplarId)) continue;
         this.aliasPointers.set(aliasId, { exemplarId, clusterId, metadata: metadata || {} });
       }
+      // Truncation guard: NDJSON has no whole-file parse to fail, so a file
+      // cut exactly at a line boundary (crash mid-save, disk full) is valid
+      // prefix NDJSON and would otherwise load a silent subset. The header's
+      // `count` restores v1's all-or-nothing semantics. Compared against
+      // PARSED lines, not kept aliases — the orphan guard intentionally
+      // drops entries and must not trip this.
+      if (parsed !== expected) {
+        this.aliasPointers.clear();
+      }
     } catch (_e) {
       // Malformed sidecar — treat as absent; aliases will be skipped at query time.
+      this.aliasPointers.clear();
+    } finally {
+      rl.close();
+      input.destroy();
     }
   }
 

package/core/ranking/late-interaction-model.js

@@ -26,6 +26,18 @@ let lateInteractionPipeline = null;
 let loadPromise = null;
 let lateInteractionRuntimeConfig = {
   intraOpThreads: null,
+  // G3-LI: background/maintainer ORT profile for the LI session. When truthy,
+  // the session is created with the CPU mem arena OFF and force_spinning_stop
+  // instead of allow_spinning — the same profile buildLocalSessionOptions
+  // applies to the dense session. ORT never returns arena memory once grown
+  // (#25325), and per-file reconcile encodes produce highly variable batch
+  // shapes, so an arena-ON LI session in the resident maintainer accrues
+  // monotonic RSS in 128MB arena-extension steps (measured: 354×128MB ≈ 34GB
+  // after one heavy edit day). Must be set BEFORE the first encode — the
+  // session singleton is built once; configuring after is a silent no-op.
+  // Default null/off everywhere else (search/query path keeps the foreground
+  // arena+spinning profile for latency).
+  background: null,
 };
 
 // Lightweight timing accumulators for profiling (Phase 6a).
@@ -90,6 +102,7 @@ export function configureLateInteractionRuntime(overrides = {}) {
 export function resetLateInteractionRuntime() {
   lateInteractionRuntimeConfig = {
     intraOpThreads: null,
+    background: null,
   };
 }
 
@@ -191,18 +204,26 @@ async function loadModel() {
   // 'extended' + memArena + memPattern: marginal overhead for no measurable gain.
   // Conclusion: keep LI session lean. Only proven-beneficial options added.
   const { getOptimizedGraphPath } = await import('../infrastructure/onnx-session-utils.js');
+  const liBackground = !!lateInteractionRuntimeConfig.background;
   const session = await ort.InferenceSession.create(onnxPath, {
     executionProviders: ['cpu'],
     logSeverityLevel: 3, // ERROR — silence ORT's expected "optimized model is machine-specific" warning
     intraOpNumThreads: lateInteractionRuntimeConfig.intraOpThreads ?? bestIntraOpThreads(),
     interOpNumThreads: 1,
     optimizedModelFilePath: getOptimizedGraphPath(modelConfig.hfId, 'lateon'),
+    // G3-LI: background (maintainer) profile disables the CPU mem arena — ORT
+    // never returns arena memory once grown (#25325), and variable-shaped
+    // per-file reconcile batches make the arena extend monotonically (128MB
+    // steps) in a resident daemon. Foreground keeps the arena for throughput.
+    enableCpuMemArena: !liBackground,
     // Thread spinning keeps ORT worker threads hot between batches — trades idle
-    // CPU for lower per-batch latency during sustained indexing runs.
+    // CPU for lower per-batch latency during sustained indexing runs. The
+    // background profile parks workers after the last Run() instead (the
+    // maintainer sits idle 20-60s between ticks; ~14% re-spin latency cost).
     extra: {
-      session: {
-        intra_op: { allow_spinning: '1' },
-      },
+      session: liBackground
+        ? { force_spinning_stop: '1' }
+        : { intra_op: { allow_spinning: '1' } },
     },
   });
   const coremlActive = false;

package/core/ranking/mmr.js

@@ -52,6 +52,11 @@ export const MMR_CONFIG = {
  * @param {Object} weights - Feature weights
  * @returns {number} Similarity score [0, 1]
  */
+// Static type groupings used by computeSimilarity — hoisted out of the
+// O(candidates × selected) MMR inner loop.
+const SIMILARITY_DEF_TYPES = new Set(['class', 'interface', 'struct', 'enum', 'trait']);
+const SIMILARITY_METHOD_TYPES = new Set(['method', 'function', 'constructor']);
+
 export function computeSimilarity(a, b, weights = MMR_CONFIG.weights) {
   let totalSim = 0;
   let totalWeight = 0;
@@ -83,11 +88,8 @@ export function computeSimilarity(a, b, weights = MMR_CONFIG.weights) {
       totalSim += weights.type * 1.0;
     } else {
       // Partial similarity for related types
-      const defTypes = new Set(['class', 'interface', 'struct', 'enum', 'trait']);
-      const methodTypes = new Set(['method', 'function', 'constructor']);
-
-      if ((defTypes.has(typeA) && defTypes.has(typeB)) ||
-          (methodTypes.has(typeA) && methodTypes.has(typeB))) {
+      if ((SIMILARITY_DEF_TYPES.has(typeA) && SIMILARITY_DEF_TYPES.has(typeB)) ||
+          (SIMILARITY_METHOD_TYPES.has(typeA) && SIMILARITY_METHOD_TYPES.has(typeB))) {
         totalSim += weights.type * 0.5;
       }
     }
@@ -237,11 +239,19 @@ export function applyMMR(results, options = {}) {
   while (selected.length < k && remaining.size > 0) {
     let bestIdx = -1;
     let bestMMR = -Infinity;
+    // Highest-relevance tracking shares the same pass (same iteration order
+    // and strict-> comparison as the reduce it replaces).
+    let highestRelevanceIdx = -1;
 
     // Find the candidate with highest MMR score
     for (const idx of remaining) {
       const candidate = normalized[idx];
 
+      if (highestRelevanceIdx === -1
+          || candidate._normalizedRelevance > normalized[highestRelevanceIdx]._normalizedRelevance) {
+        highestRelevanceIdx = idx;
+      }
+
       // Compute max similarity to already selected results
       let maxSim = 0;
       for (const selectedResult of selected) {
@@ -261,11 +271,6 @@ export function applyMMR(results, options = {}) {
     if (bestIdx >= 0) {
       const selectedCandidate = normalized[bestIdx];
 
-      // Track if this selection was reordered (not the highest relevance remaining)
-      const highestRelevanceIdx = [...remaining].reduce((maxIdx, idx) =>
-        normalized[idx]._normalizedRelevance > normalized[maxIdx]._normalizedRelevance ? idx : maxIdx
-      );
-
       if (bestIdx !== highestRelevanceIdx) {
         reorderCount++;
         totalDiversityPenalty += normalized[highestRelevanceIdx]._normalizedRelevance - selectedCandidate._normalizedRelevance;

package/core/search/search-anchor.js

@@ -129,7 +129,23 @@ function readUniquenessCeil(opts) {
  * @param {{ filePath: string, startLine: number, endLine: number }} entity
  * @returns {{ id: string, metadata: object, content?: string, text?: string }|null}
  */
-function findChunkForEntity(liIndex, entity) {
+// Bucket the LI documents Map by file in ONE pass, preserving per-file
+// iteration order, so findChunkForEntity scans only entity.filePath's chunks
+// instead of the whole index per entity.
+function bucketDocsByFile(liIndex) {
+  const byFile = new Map();
+  if (!liIndex?.documents) return byFile;
+  for (const [id, doc] of liIndex.documents) {
+    const file = doc?.metadata?.file;
+    if (!file) continue;
+    let arr = byFile.get(file);
+    if (!arr) byFile.set(file, arr = []);
+    arr.push([id, doc]);
+  }
+  return byFile;
+}
+
+function findChunkForEntity(liIndex, entity, docsByFile = null) {
   if (!liIndex || !entity) return null;
   let best = null;
   let bestSize = Infinity;
@@ -145,7 +161,8 @@ function findChunkForEntity(liIndex, entity) {
   let headerBest = null;
   let headerBestSize = Infinity;
   const entityNameLc = String(entity.name || '').toLowerCase();
-  for (const [id, doc] of liIndex.documents) {
+  const candidates = docsByFile ? (docsByFile.get(entity.filePath) || []) : liIndex.documents;
+  for (const [id, doc] of candidates) {
     const m = doc?.metadata;
     if (!m || m.file !== entity.filePath) continue;
     const cs = m.startLine, ce = m.endLine;
@@ -402,10 +419,11 @@ export function injectAnchorCandidates(fused, query, opts = {}) {
   let existingBoosted = 0;
   const out = fused.slice();    // copy — we'll append injections
   const seenInjected = new Set();
+  const docsByFile = bucketDocsByFile(liIndex);
 
   for (const entity of entities) {
     if (!entityMatchesAnchorHint(entity, hints)) continue;
-    const chunk = findChunkForEntity(liIndex, entity);
+    const chunk = findChunkForEntity(liIndex, entity, docsByFile);
     if (!chunk) continue;
     const key = chunkKey({ metadata: chunk.metadata });
     if (seenInjected.has(key)) continue;

package/core/search/search-boost.js

@@ -201,6 +201,18 @@ function envFloat(name, fallback, min = 0, max = 1) {
   return Number.isFinite(parsed) && parsed >= min && parsed <= max ? parsed : fallback;
 }
 
+// Query-term derivation is pure in `query`; memoize the last query so the
+// per-result map in applyPostFusionBoosts doesn't re-split identical input.
+let _lastIdTermsQuery = null;
+let _lastIdTerms = null;
+function identifierTermsForQuery(query) {
+  if (query !== _lastIdTermsQuery) {
+    _lastIdTermsQuery = query;
+    _lastIdTerms = new Set(splitIdentifierTerms(query));
+  }
+  return _lastIdTerms;
+}
+
 function splitIdentifierTerms(value) {
   return String(value || '')
     .replace(/_[0-9a-f]{8}(?=\.[^.]+$|$)/gi, '')
@@ -233,7 +245,7 @@ export function computeIdentifierAgreementBoost(result, query) {
   const weight = envFloat('SWEET_SEARCH_IDENTIFIER_AGREEMENT_BOOST', 0.40, 0, 1);
   if (weight === 0) return 1.0;
 
-  const queryTerms = new Set(splitIdentifierTerms(query));
+  const queryTerms = identifierTermsForQuery(query);
   if (queryTerms.size === 0) return 1.0;
 
   const fileName = (result.file || result.path || result.metadata?.file || '')
@@ -290,22 +302,22 @@ export function computeDefinitionBoost(result, queryLower, queryTokens) {
 /**
  * Compute syntax boost (PHASE_1_FIXES helper)
  */
+const DEFINITION_SIGNATURE_PATTERNS = [
+  /\b(?:public|private|protected)?\s*(?:abstract|final)?\s*class\s+(\w+)/,
+  /\b(?:public|private|protected)?\s*interface\s+(\w+)/,
+  /\b(?:public|private|protected)?\s*enum\s+(\w+)/,
+  /\bclass\s+(\w+)/,
+  /\bfunction\s+(\w+)/,
+  /\bexport\s+(?:default\s+)?(?:class|function)\s+(\w+)/,
+  /\binterface\s+(\w+)/,
+  /\btype\s+(\w+)\s*=/,
+];
+
 export function computeSyntaxBoost(result, queryTokens) {
   const signature = (result.signature || '').toLowerCase();
   if (!signature) return 1.0;
 
-  const definitionPatterns = [
-    /\b(?:public|private|protected)?\s*(?:abstract|final)?\s*class\s+(\w+)/,
-    /\b(?:public|private|protected)?\s*interface\s+(\w+)/,
-    /\b(?:public|private|protected)?\s*enum\s+(\w+)/,
-    /\bclass\s+(\w+)/,
-    /\bfunction\s+(\w+)/,
-    /\bexport\s+(?:default\s+)?(?:class|function)\s+(\w+)/,
-    /\binterface\s+(\w+)/,
-    /\btype\s+(\w+)\s*=/,
-  ];
-
-  for (const pattern of definitionPatterns) {
+  for (const pattern of DEFINITION_SIGNATURE_PATTERNS) {
     const match = signature.match(pattern);
     if (match && match[1]) {
       const definedName = match[1].toLowerCase();

package/core/search/search-fusion.js

@@ -109,20 +109,24 @@ export function quantileNormalize(scores, lowQuantile = 0.05, highQuantile = 0.9
 export function convexCombination(lexicalResults, semanticResults, routeType = 'mixed', options = {}) {
   const alpha = options.alpha ?? ROUTE_ALPHAS[routeType] ?? 0.5;
 
-  // Build score maps
+  // Build score + result maps in one key derivation per result
   const lexicalScoreMap = new Map();
   const semanticScoreMap = new Map();
+  const lexResultMap = new Map();
+  const semResultMap = new Map();
   const allKeys = new Set();
 
   for (const r of lexicalResults) {
     const key = this.getResultKey(r);
     lexicalScoreMap.set(key, r.score);
+    lexResultMap.set(key, r);
     allKeys.add(key);
   }
 
   for (const r of semanticResults) {
     const key = this.getResultKey(r);
     semanticScoreMap.set(key, r.score);
+    semResultMap.set(key, r);
     allKeys.add(key);
   }
 
@@ -148,8 +152,6 @@ export function convexCombination(lexicalResults, semanticResults, routeType = '
 
   // Compute CC scores
   const ccResults = [];
-  const lexResultMap = new Map(lexicalResults.map(r => [this.getResultKey(r), r]));
-  const semResultMap = new Map(semanticResults.map(r => [this.getResultKey(r), r]));
 
   for (const key of allKeys) {
     const lexScore = lexicalScoreMap.get(key);
@@ -253,7 +255,10 @@ export function rrfFusion(lexicalResults, semanticResults, k = 60) {
   });
 
   return [...results.values()]
-    .map(r => ({ ...r, score: scores.get(this.getResultKey(r)), ccScore: scores.get(this.getResultKey(r)) }))
+    .map(r => {
+      const score = scores.get(this.getResultKey(r));
+      return { ...r, score, ccScore: score };
+    })
     .sort((a, b) => b.score - a.score);
 }
 
@@ -310,7 +315,10 @@ export function robustCCFusion(lexicalResults, semanticResults, routeType = 'mix
 
   return {
     results: [...results.values()]
-      .map(r => ({ ...r, score: combinedScores.get(this.getResultKey(r)), ccScore: combinedScores.get(this.getResultKey(r)), alpha }))
+      .map(r => {
+        const score = combinedScores.get(this.getResultKey(r));
+        return { ...r, score, ccScore: score, alpha };
+      })
       .sort((a, b) => b.score - a.score),
     method: 'cc_robust',
     fallbackReason: null,