sweet-search 2.5.2 → 2.5.3

package/core/search/sweet-search.js

@@ -10,7 +10,7 @@
  */
 
 import fs from 'fs/promises';
-import { existsSync } from 'fs';
+import { existsSync, readFileSync } from 'fs';
 import path from 'path';
 import { DB_PATHS, PERFORMANCE_TARGETS, LOGGING, BINARY_HNSW_CONFIG, HCGS_CONFIG, LATE_INTERACTION_CONFIG, EMBEDDING_CONFIG, SEISMIC_CONFIG, CASCADE_CONFIG, loadProjectConfig, shouldUseLocalReranker } from '../infrastructure/config/index.js';
 import { getGlobalLocalReranker } from '../ranking/local-reranker.js';
@@ -44,6 +44,7 @@ import * as hybrid from './search-hybrid.js';
 import * as postprocess from './search-postprocess.js';
 import * as pattern from './search-pattern.js';
 import { packageForAgent } from './context-expander.js';
+import { beginPinnedRead, endPinnedRead } from './search-reader-pin.js';
 
 export { ROUTE_ALPHAS } from './search-fusion.js';
 
@@ -67,6 +68,18 @@ const STRUCTURAL_PATTERNS = {
  * @param {string} query
  * @returns {{ structuralType: string|null, targetEntity: string|null }}
  */
+// Per-stage profiling hooks. No-op unless `globalThis.__stageTimings` is set
+// by scripts/profile-search-stages.mjs.
+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);
+}
+
 function parseStructuralQuery(query) {
   for (const [type, pattern] of Object.entries(STRUCTURAL_PATTERNS)) {
     const match = query.match(pattern);
@@ -99,12 +112,25 @@ export class SweetSearch {
     // standard model path on every search. Env var still wins; see
     // applyPersistedLiModel for the full precedence ladder.
     this._liModelApply = applyPersistedLiModel(projectRoot);
+    const explicitLiModel = options.lateInteractionOptions?.modelId;
+    if (typeof explicitLiModel === 'string' && LATE_INTERACTION_CONFIG.models[explicitLiModel]) {
+      const before = LATE_INTERACTION_CONFIG.model;
+      LATE_INTERACTION_CONFIG.model = explicitLiModel;
+      this._liModelApply = {
+        applied: explicitLiModel,
+        before,
+        source: 'option',
+        persistedModel: this._liModelApply.persistedModel,
+        changed: explicitLiModel !== before,
+      };
+    }
     const projectConfig = loadProjectConfig(projectRoot);
     const projectCascade = projectConfig.cascade || {};
     const envOrProject = (envKey, cascadeKey, configKey) =>
       process.env[envKey] != null ? CASCADE_CONFIG[configKey] : projectCascade[cascadeKey];
 
     this.graphDbPath = options.graphDbPath || DB_PATHS.codeGraph;
+    this._manifestGraphDbPath = this.graphDbPath;
     this.graphSearch = new GraphSearch(this.graphDbPath);
     this.codeGraphRepo = new CodeGraphRepository(this.graphDbPath);
     this.hnswPath = options.hnswPath || DB_PATHS.hnswIndex;
@@ -115,6 +141,8 @@ export class SweetSearch {
     this.lateInteractionIndex = new LateInteractionIndex(options.lateInteractionOptions || {});
     this.router = new QueryRouter();
     this.codebaseDbPath = options.codebaseDbPath || DB_PATHS.codebase;
+    this._manifestCodebaseDbPath = this.codebaseDbPath;
+    this._manifestStateDir = path.dirname(this._manifestCodebaseDbPath);
     this.sparseGramIndexPath = options.sparseGramIndexPath || DB_PATHS.sparseGramIndex;
     this.verbose = options.verbose ?? LOGGING.verbose;
     this.timing = options.timing ?? LOGGING.timing;
@@ -167,10 +195,23 @@ export class SweetSearch {
       ?? CASCADE_CONFIG.shadowMode;
     setRepoMapModule({ pageRank, loadGraph, buildAdjacency });
     this._qualityScorer = null;
-    this.codebaseRepo = new CodebaseRepository(this.codebaseDbPath);
+    this.codebaseRepo = new CodebaseRepository(this._manifestCodebaseDbPath);
     this.sparseGramIndex = null;
+    this._sparseGramLoadedPath = null;
     this.grepInitialized = false;
     this.initialized = false;
+    this._lateInteractionOptions = { ...(options.lateInteractionOptions || {}) };
+    this._artifactManifestEpoch = null;
+  }
+
+  _clearChunkLocationCache() {
+    this._chunkLocationMap = null;
+    this._chunkLocationMapSize = 0;
+    this._chunkLocationMapIndex = null;
+  }
+
+  _clearCodebaseChunkTypeCache() {
+    this._codebaseChunkTypeMap = null;
   }
 
   /** @deprecated Use codebaseRepo methods instead. Bridge for legacy callers. */
@@ -184,6 +225,8 @@ export class SweetSearch {
     if (this.initialized) return;
     const start = Date.now();
 
+    this._syncManifestPaths(this._readReconcileManifest());
+
     this.hasGraphIndex = existsSync(this.graphDbPath);
     this.hasHnswIndex = existsSync(this.hnswPath.replace('.idx', '.meta.json'));
     this.hasBinaryHnswIndex = existsSync(this.binaryHnswPath.replace('.idx', '.meta.json'));
@@ -309,6 +352,7 @@ export class SweetSearch {
       try {
         this.sparseGramIndex = loadSparseGramIndex(this.sparseGramIndexPath);
         if (this.sparseGramIndex) {
+          this._sparseGramLoadedPath = this.sparseGramIndexPath;
           const stats = this.sparseGramIndex.getStats();
           this.log(
             `SparseGram: Loaded ${stats.grams} grams across ${stats.totalFiles} files ` +
@@ -321,11 +365,27 @@ export class SweetSearch {
         this.log(`SparseGram: Failed to load: ${err.message}`);
         this.hasSparseGramIndex = false;
         this.sparseGramIndex = null;
+        this._sparseGramLoadedPath = null;
       }
     }
 
     await warmupEmbedding({ initVocabulary: true, initSemanticCache: true });
 
+    // Pre-build the call-graph ref-count index so the first search query
+    // doesn't pay its 10-50 ms construction cost. This piggybacks on the
+    // existing warmup phase — model load already takes ~700 ms, so this
+    // adds at most a few ms to init and removes the cold-start spike from
+    // the search hot path. Skipped when the graph DB doesn't exist (e.g.
+    // grep-only mode).
+    if (this.hasGraphIndex && this.codeGraphRepo
+        && typeof this.codeGraphRepo.prebuildRefCountIndex === 'function') {
+      try {
+        this.codeGraphRepo.prebuildRefCountIndex();
+      } catch {
+        // Index build is purely an optimisation; failure is non-fatal.
+      }
+    }
+
     if (shouldUseLocalReranker()) {
       try {
         const localReranker = getGlobalLocalReranker();
@@ -337,19 +397,228 @@ export class SweetSearch {
     }
 
     this.initialized = true;
+    this._artifactManifestEpoch = this._readReconcileManifest()?.epoch ?? null;
     this.log(`SweetSearch: Initialized in ${Date.now() - start}ms`);
   }
 
+  _readReconcileManifest() {
+    try {
+      const manifestPath = path.join(this._manifestStateDir, 'reconcile-manifest.json');
+      const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+      return Number.isInteger(manifest?.epoch) ? manifest : null;
+    } catch {
+      return null;
+    }
+  }
+
+  _resolveStatePath(filePath) {
+    if (!filePath) return null;
+    if (path.isAbsolute(filePath)) return filePath;
+    return path.join(this._manifestStateDir, filePath);
+  }
+
+  _manifestArtifactPaths(manifest) {
+    if (!manifest) return {};
+    let liIndexPath = null;
+    const liDescriptor = manifest.lateInteraction?.path
+      || manifest.lateInteraction?.indexPath
+      || manifest.lateInteraction?.manifest;
+    if (liDescriptor) {
+      const resolved = this._resolveStatePath(liDescriptor);
+      const segmentDir = path.dirname(resolved);
+      liIndexPath = segmentDir.endsWith('.segments')
+        ? segmentDir.slice(0, -'.segments'.length)
+        : resolved;
+    }
+    return {
+      codebaseDbPath: this._resolveStatePath(manifest.vectors?.path),
+      graphDbPath: this._resolveStatePath(manifest.codeGraph?.path),
+      hnswPath: this._resolveStatePath(manifest.hnsw?.path),
+      hnswStalePath: this._resolveStatePath(manifest.hnsw?.stale),
+      binaryHnswPath: this._resolveStatePath(manifest.binaryHnsw?.path),
+      binaryHnswStalePath: this._resolveStatePath(manifest.binaryHnsw?.stale),
+      lateInteractionIndexPath: liIndexPath,
+      sparseGramIndexPath: this._resolveStatePath(manifest.sparseGram?.base),
+    };
+  }
+
+  _syncManifestPaths(manifest) {
+    const paths = this._manifestArtifactPaths(manifest);
+    if (!manifest) {
+      this.sparseGramDeltas = null;
+      this.sparseGramWeightsId = null;
+    }
+    if (paths.codebaseDbPath && paths.codebaseDbPath !== this.codebaseDbPath) {
+      this.codebaseRepo?.close?.();
+      this.codebaseDbPath = paths.codebaseDbPath;
+      this.codebaseRepo = new CodebaseRepository(this._manifestCodebaseDbPath);
+      this._clearCodebaseChunkTypeCache();
+    }
+    if (paths.graphDbPath && paths.graphDbPath !== this.graphDbPath) {
+      this.graphSearch?.close?.();
+      this.codeGraphRepo?.close?.();
+      this.graphDbPath = paths.graphDbPath;
+      this.graphSearch = new GraphSearch(this._manifestGraphDbPath);
+      this.codeGraphRepo = new CodeGraphRepository(this._manifestGraphDbPath);
+    }
+    if (paths.hnswPath && (paths.hnswPath !== this.hnswPath || paths.hnswStalePath !== this.hnswIndex?.stalePath)) {
+      this.hnswPath = paths.hnswPath;
+      this.hnswIndex = new HNSWIndex({ indexPath: this.hnswPath, stalePath: paths.hnswStalePath || `${this.hnswPath}.stale.bin` });
+    }
+    if (paths.binaryHnswPath && (paths.binaryHnswPath !== this.binaryHnswPath || paths.binaryHnswStalePath !== this.binaryHnswIndex?.stalePath)) {
+      this.binaryHnswPath = paths.binaryHnswPath;
+      this.binaryHnswIndex = new BinaryHNSWIndex({ indexPath: this.binaryHnswPath, stalePath: paths.binaryHnswStalePath || `${this.binaryHnswPath}.stale.bin` });
+    }
+    if (paths.lateInteractionIndexPath && paths.lateInteractionIndexPath !== this.lateInteractionIndex?.indexPath) {
+      this._lateInteractionOptions = { ...this._lateInteractionOptions, indexPath: paths.lateInteractionIndexPath };
+      this.lateInteractionIndex = new LateInteractionIndex(this._lateInteractionOptions);
+      this._clearChunkLocationCache();
+    }
+    if (paths.sparseGramIndexPath && paths.sparseGramIndexPath !== this.sparseGramIndexPath) {
+      this.sparseGramIndexPath = paths.sparseGramIndexPath;
+      this.sparseGramIndex = null;
+      this._sparseGramLoadedPath = null;
+    }
+    if (typeof manifest?.sparseGram?.weightsId === 'string') {
+      this.sparseGramWeightsId = manifest.sparseGram.weightsId;
+    }
+    if (Array.isArray(manifest?.sparseGram?.deltas)) {
+      this.sparseGramDeltas = manifest.sparseGram.deltas.filter((entry) => typeof entry === 'string');
+    } else if (manifest?.sparseGram) {
+      this.sparseGramDeltas = null;
+    }
+  }
+
+  async _reloadManifestArtifacts(manifest, options = {}) {
+    this._syncManifestPaths(manifest);
+    const reloadScope = options.reloadScope || 'all';
+    const grepOnly = reloadScope === 'grep';
+
+    if (!grepOnly) {
+      this.hasBinaryHnswIndex = existsSync(this.binaryHnswPath.replace('.idx', '.meta.json'));
+    }
+    if (!grepOnly && this.hasBinaryHnswIndex && this.use3Stage) {
+      try {
+        const nextBinary = new BinaryHNSWIndex({
+          indexPath: this.binaryHnswPath,
+          stalePath: this.binaryHnswIndex?.stalePath || `${this.binaryHnswPath}.stale.bin`,
+        });
+        await nextBinary.load();
+        this.binaryHnswIndex = nextBinary;
+        this.floatVectorStore = new FloatVectorStore();
+        await this.floatVectorStore.load(getFloatStorePath(this.binaryHnswPath));
+      } catch (err) {
+        this.log(`BinaryHNSW: Failed to reload after manifest publish: ${err.message}`);
+        this.hasBinaryHnswIndex = false;
+      }
+    }
+
+    if (!grepOnly) {
+      this.hasHnswIndex = existsSync(this.hnswPath.replace('.idx', '.meta.json'));
+    }
+    if (!grepOnly && this.hasHnswIndex) {
+      try {
+        const nextHnsw = new HNSWIndex({
+          indexPath: this.hnswPath,
+          stalePath: this.hnswIndex?.stalePath || `${this.hnswPath}.stale.bin`,
+        });
+        await nextHnsw.load(undefined, { mmap: true });
+        this.hnswIndex = nextHnsw;
+      } catch (err) {
+        this.log(`HNSW: Failed to reload after manifest publish: ${err.message}`);
+        this.hasHnswIndex = false;
+      }
+    }
+
+    if (!grepOnly) {
+      this.hasLateInteractionIndex = existsSync(this.lateInteractionIndex.indexPath);
+    }
+    if (!grepOnly && this.hasLateInteractionIndex) {
+      try {
+        const nextLi = new LateInteractionIndex(this._lateInteractionOptions);
+        await nextLi.init();
+        this.lateInteractionIndex = nextLi;
+        this._clearChunkLocationCache();
+        const liManifest = {
+          modelId: this.lateInteractionIndex.modelId ?? null,
+          tokenDim: this.lateInteractionIndex.tokenDim ?? null,
+          modelMismatch: this.lateInteractionIndex.modelMismatch === true,
+          exists: true,
+        };
+        const resolved = resolveSearchRerankPolicy({
+          optionOverride: this._liPolicyOptionOverride,
+          env: process.env,
+          persisted: this._liPolicyPersisted,
+          indexManifest: liManifest,
+          activeConfigModel: LATE_INTERACTION_CONFIG.model,
+        });
+        this._liPolicyResolved = resolved;
+        this.useLateInteraction = LATE_INTERACTION_CONFIG.enabled && resolved.effective;
+      } catch (err) {
+        this.log(`LateInteraction: Failed to reload after manifest publish: ${err.message}`);
+        this.hasLateInteractionIndex = false;
+        this.useLateInteraction = false;
+        this._clearChunkLocationCache();
+      }
+    }
+
+    this.hasSparseGramIndex = existsSync(this.sparseGramIndexPath);
+    if (this.hasSparseGramIndex) {
+      try {
+        this.sparseGramIndex = loadSparseGramIndex(this.sparseGramIndexPath);
+        this._sparseGramLoadedPath = this.sparseGramIndex ? this.sparseGramIndexPath : null;
+      } catch (err) {
+        this.log(`SparseGram: Failed to reload after manifest publish: ${err.message}`);
+        this.hasSparseGramIndex = false;
+        this.sparseGramIndex = null;
+        this._sparseGramLoadedPath = null;
+      }
+    } else {
+      this.sparseGramIndex = null;
+      this._sparseGramLoadedPath = null;
+    }
+  }
+
+  async _refreshManifestPins(options = {}) {
+    const manifest = this._readReconcileManifest();
+    const previousArtifactEpoch = this._artifactManifestEpoch;
+    const previousCodebaseEpoch = this.codebaseRepo?.getManifestEpoch?.();
+    const manifestEpoch = Number.isInteger(manifest?.epoch) ? manifest.epoch : null;
+    const shouldReloadArtifacts = manifestEpoch !== null
+      && previousArtifactEpoch !== manifestEpoch
+      && (this.initialized || this.grepInitialized);
+    this._syncManifestPaths(manifest);
+    const codebaseEpoch = this.codebaseRepo?.refreshManifestEpoch?.();
+    if (previousCodebaseEpoch !== codebaseEpoch) {
+      this._clearCodebaseChunkTypeCache();
+    }
+    const graphEpoch = this.graphSearch?.refreshManifestEpoch?.();
+    this.codeGraphRepo?.refreshManifestEpoch?.();
+    // Regex/sparse-gram helpers are not repository-backed, so expose the
+    // query-pinned epoch on the searcher for their delta overlay reader.
+    this.manifestEpoch = manifestEpoch !== null
+      ? manifestEpoch
+      : (Number.isInteger(codebaseEpoch) ? codebaseEpoch : graphEpoch);
+    if (shouldReloadArtifacts) {
+      await this._reloadManifestArtifacts(manifest, options);
+    }
+    if (manifestEpoch !== null) {
+      this._artifactManifestEpoch = manifestEpoch;
+    }
+  }
+
   async initGrepOnly() {
     if (this.grepInitialized || this.initialized) return;
     const start = Date.now();
 
+    this._syncManifestPaths(this._readReconcileManifest());
     this.hasCodebaseIndex = existsSync(this.codebaseDbPath);
     this.hasSparseGramIndex = existsSync(this.sparseGramIndexPath);
     if (this.hasSparseGramIndex) {
       try {
         this.sparseGramIndex = loadSparseGramIndex(this.sparseGramIndexPath);
         if (this.sparseGramIndex) {
+          this._sparseGramLoadedPath = this.sparseGramIndexPath;
           const stats = this.sparseGramIndex.getStats();
           this.log(
             `SparseGram: Loaded ${stats.grams} grams across ${stats.totalFiles} files ` +
@@ -362,10 +631,12 @@ export class SweetSearch {
         this.log(`SparseGram: Failed to load: ${err.message}`);
         this.hasSparseGramIndex = false;
         this.sparseGramIndex = null;
+        this._sparseGramLoadedPath = null;
       }
     }
 
     this.grepInitialized = true;
+    this._artifactManifestEpoch = this._readReconcileManifest()?.epoch ?? null;
     this.log(`SweetSearch: Grep-only initialized in ${Date.now() - start}ms`);
   }
 
@@ -384,7 +655,14 @@ export class SweetSearch {
     } else {
       await this.init();
     }
+    await this._refreshManifestPins({ reloadScope: mode === 'grep' ? 'grep' : 'all' });
 
+    const readPin = beginPinnedRead({
+      stateDir: this._manifestStateDir,
+      epoch: this.manifestEpoch,
+      meta: { tool: 'search', mode, query: String(query).slice(0, 200) },
+    });
+    try {
     const start = Date.now();
     const stats = { query };
 
@@ -435,6 +713,27 @@ export class SweetSearch {
     let results;
     let semanticStats = null;
 
+    // Search-scoped caches for the per-result helpers in
+    // applyResultDemotions. Shared across the two demotion sites (one inside
+    // hybridSearchV2, one inside _applyPostRetrieval). Most top-K chunks
+    // appear in BOTH sites' input sets, so cross-call reuse stacks on top of
+    // the intra-call memoization in file-kind-ranking.js. Freshly allocated
+    // per search() call — never reused across queries.
+    //   _entityKindCache     : SQLite enclosing/contained entity lookup
+    //   _entityNameCache     : SQLite findEntityWithNameInRange (symbol-target)
+    //   _resultTextCache     : readFileSync source-span
+    //   _fullFileTextCache   : readFileSync FULL file (test-support detection)
+    //   _isTestSupportCache  : isTestSupportFile() per-file verdict
+    //   _isTestChunkCache    : isTestChunk() per-chunk verdict
+    //   _fileKindCache       : detectFileKind() per-file verdict
+    const _entityKindCache = new Map();
+    const _entityNameCache = new Map();
+    const _resultTextCache = new Map();
+    const _fullFileTextCache = new Map();
+    const _isTestSupportCache = new Map();
+    const _isTestChunkCache = new Map();
+    const _fileKindCache = new Map();
+
     switch (searchMode) {
       case 'grep': {
         const grepResult = await this.bareGrep(query, routing, {
@@ -478,7 +777,13 @@ export class SweetSearch {
         break;
       }
       case 'semantic': {
-        const semanticResult = await this.semanticSearch(query, { k, rerank, useLateInteraction });
+        const semanticResult = await this.semanticSearch(query, {
+          k,
+          rerank,
+          useLateInteraction,
+          format: options.format,
+          ablations: options.ablations,
+        });
         results = semanticResult.results;
         semanticStats = semanticResult.stats;
         stats.path = 'semantic';
@@ -486,13 +791,40 @@ export class SweetSearch {
       }
       case 'hybrid':
       default: {
-        const hybridResult = await this.hybridSearchV2(query, { k, useLateInteraction, routing });
+        const hybridResult = await this.hybridSearchV2(query, {
+          k,
+          useLateInteraction,
+          format: options.format,
+          routing,
+          ablations: options.ablations,
+          useMMR: options.useMMR,
+          allowQueryRewrite: options.allowQueryRewrite,
+          allowKeywordFallback: options.allowKeywordFallback,
+          confidenceFloor: options.confidenceFloor,
+          fileKindWindow: options.fileKindWindow,
+          hybridDocFactor: options.hybridDocFactor,
+          hybridTestFactor: options.hybridTestFactor,
+          hybridTypeFactor: options.hybridTypeFactor,
+          hybridAncillaryFactor: options.hybridAncillaryFactor,
+          hybridTinyAncillaryFactor: options.hybridTinyAncillaryFactor,
+          resultDemotionWindow: options.resultDemotionWindow,
+          _entityKindCache,
+          _entityNameCache,
+          _resultTextCache,
+          _fullFileTextCache,
+          _isTestSupportCache,
+          _isTestChunkCache,
+          _fileKindCache,
+        });
         results = hybridResult.results || hybridResult;
         semanticStats = hybridResult.semanticStats || null;
         stats.path = 'hybrid';
         stats.fusion = hybridResult.fusionStats?.method || 'cc';
         stats.fusionFallback = hybridResult.fusionStats?.fallbackReason || null;
         stats.lexicalLatencyMs = hybridResult.fusionStats?.lexicalLatencyMs ?? null;
+        if (hybridResult.fusionStats?.queryRewrite) {
+          stats.queryRewrite = hybridResult.fusionStats.queryRewrite;
+        }
         break;
       }
     }
@@ -505,9 +837,62 @@ export class SweetSearch {
       effectiveGraphExpand = '2hop';
     }
 
+    // Empty-result rescue (added 2026-05-07 — FreshStack uv diagnosis).
+    // The joint hybrid pipeline can return [] in two cascading-failure
+    // scenarios:
+    //   (a) BM25 lexical returns nothing (FTS5 tokenization quirk on multi-
+    //       word NL queries with stop-words like "trace how X uses Y"), AND
+    //   (b) the dense path returns candidates that ALL trip post-fusion
+    //       demotions to ≈0 score, AND
+    //   (c) RRF fallback inside hybridSearchV2 also produces nothing because
+    //       its keyword splitter sees the same FTS-empty result.
+    // Diagnosed on UV-FLOW-1 / UV-FLOW-4 (post-cutoff uv): both well-formed
+    // NL queries with concrete tokens (uv, add, dependency, pyproject, toml)
+    // returned in 3ms. That is a query-pipeline pathology, not a corpus gap.
+    // The principled fix (cascading retrieval — Thakur et al. BEIR 2024;
+    // Lin & Ma "Tiered Retrieval" 2025): when all upstream paths produce
+    // empty, fall back to ONE pure-dense call on the raw query string with
+    // no rerank, no graph, no fusion — this guarantees we always return
+    // something for any NL query the encoder can embed. Disable via
+    // `ablations: ['no-empty-rescue']`.
+    const emptyRescueAllowed = !(options.ablations && (
+      options.ablations instanceof Set
+        ? options.ablations.has('no-empty-rescue')
+        : Array.isArray(options.ablations) && options.ablations.includes('no-empty-rescue')
+    ));
+    if (emptyRescueAllowed
+        && Array.isArray(results)
+        && results.length === 0
+        && (searchMode === 'hybrid' || searchMode === 'semantic' || searchMode === 'lexical')
+        && expand) {
+      try {
+        const rescue = await this.semanticSearch(query, {
+          k: Math.max(k, 10),
+          rerank: false,
+          useLateInteraction: false,
+        });
+        const rescuedResults = rescue.results || [];
+        if (rescuedResults.length > 0) {
+          results = rescuedResults.map(r => ({ ...r, searchPath: 'empty-rescue-dense' }));
+          stats.emptyRescue = {
+            triggered: true,
+            recovered: rescuedResults.length,
+            mode: 'pure-dense-raw',
+          };
+          this.log(`Empty-rescue: hybrid returned 0; pure-dense recovered ${rescuedResults.length} candidates`);
+        } else {
+          stats.emptyRescue = { triggered: true, recovered: 0 };
+        }
+      } catch (err) {
+        stats.emptyRescue = { triggered: true, error: err.message };
+      }
+    }
+
     // Step 3: Post-retrieval processing (delegated to extracted module)
     const postRetrievalResult = await this._applyPostRetrieval(results, query, options, {
-      stats, semanticStats, searchMode, effectiveGraphExpand, intentPolicy, start,
+      stats, semanticStats, searchMode, effectiveGraphExpand, intentPolicy, start, fromSearch: true,
+      _entityKindCache, _entityNameCache, _resultTextCache, _fullFileTextCache,
+      _isTestSupportCache, _isTestChunkCache, _fileKindCache,
     });
 
     // Step 4: Agent packaging (lexical/semantic/hybrid/structural).
@@ -519,6 +904,7 @@ export class SweetSearch {
     if (agentFormats.has(options.format)) {
       const finalResults = postRetrievalResult.results || [];
       const finalStats = postRetrievalResult.stats || {};
+      const __t_pkg = __ptStart();
       const agentResponse = packageForAgent(finalResults, {
         ...finalStats,
         candidatePoolSize: finalStats.results_count ?? finalResults.length,
@@ -533,12 +919,16 @@ export class SweetSearch {
         projectRoot: this.projectRoot,
         ablations: options.ablations,
       });
+      __ptEnd('packageForAgent', __t_pkg);
       // Preserve the underlying retrieval stats so callers can inspect both layers
       agentResponse.stats = finalStats;
       return agentResponse;
     }
 
     return postRetrievalResult;
+    } finally {
+      endPinnedRead(readPin);
+    }
   }
 
   /** Structural search path (GraphRAG structural queries — opt-in via explicit flag) */
@@ -588,10 +978,11 @@ export class SweetSearch {
   /** Semantic search dispatcher. Delegates to 3Stage or Standard based on config. */
   async semanticSearch(query, options = {}) {
     const { k = 10, rerank = true, useLateInteraction = this.useLateInteraction } = options;
+    const semanticOptions = { ...options, k, rerank, useLateInteraction };
     if (this.hasBinaryHnswIndex && this.use3Stage) {
-      return this.semanticSearch3Stage(query, { k, rerank, useLateInteraction });
+      return this.semanticSearch3Stage(query, semanticOptions);
     }
-    return this.semanticSearchStandard(query, { k, rerank });
+    return this.semanticSearchStandard(query, semanticOptions);
   }
 
   /** O(N) vector scan fallback (when HNSW not available). Filters stale entities. */
@@ -694,6 +1085,7 @@ Object.assign(SweetSearch.prototype, {
   variance: fusion.variance,
   getBoostIntent: boost.getBoostIntent,
   applyPostFusionBoosts: boost.applyPostFusionBoosts,
+  computeIdentifierAgreementBoost: boost.computeIdentifierAgreementBoost,
   computeDefinitionBoost: boost.computeDefinitionBoost,
   computeSyntaxBoost: boost.computeSyntaxBoost,
   computePositionBoost: boost.computePositionBoost,

package/core/skills/sweet-index/SKILL.md

@@ -32,18 +32,20 @@ lifecycle end-to-end:
    fighting with the GPU models about to be loaded.
 2. **Detect best backend** via `hardware-capability.js` —
    `coreml-cascade` on M3+ Apple Silicon, `candle-metal` on M1/M2,
-   `candle-cpu` elsewhere.
-3. **Load GPU models + warmup forward pass** — compiles Metal pipelines,
-   CoreML variant bundles, and BLAS thread pools so the first indexing
-   batch pays no cold-start cost.
+   `candle-cuda` on Linux + NVIDIA, and the optimized **ORT INT8 CPU** path
+   on any host with no usable accelerator (no GPU models are loaded there).
+3. **Load GPU models + warmup forward pass** (accelerator hosts only) —
+   compiles Metal pipelines, CoreML variant bundles, and BLAS thread pools
+   so the first indexing batch pays no cold-start cost.
 4. **Index the codebase** — code graph, vector embeddings, HNSW,
    late-interaction index, quantized artifacts, sparse-gram index.
 5. **Kill GPU models** — releases Metal queues and Neural Engine.
 6. **Load + warmup ORT CPU models** — both embedding and LI get one dummy
    forward pass so the first query after indexing is warm.
 
-On small-changeset incremental runs (under 20 files), the indexer skips the
-GPU swap entirely — the load/warmup overhead would dwarf the actual work.
+On small-changeset incremental runs (under 20 files) — and on any host with
+no usable accelerator — the indexer skips the GPU swap entirely and indexes on
+the optimized ORT INT8 CPU path.
 
 ## Usage