sweet-search 2.5.13 → 2.6.0

package/core/incremental-indexing/application/reconciler.mjs

@@ -46,14 +46,13 @@ import { verifyStamp, writeStamp, formatStampMismatch } from '../infrastructure/
  *     persistManifest(manifest): Promise<void>,
  *     applyGraphDelta(file, parsed, epoch):       Promise<{ ops }>,
  *     applyVectorDelta(file, chunks, hashes, epoch): Promise<{ ops }>,
- *     applyHNSWDelta(file, vectorOps, epoch):     Promise<{ ops }>,
  *     applyBinaryHNSWDelta(file, vectorOps, epoch): Promise<{ ops }>,
  *     applyLIDelta(file, tokenOps, epoch):        Promise<{ ops }>,
  *     applySparseGramDelta(file, gramOps, epoch): Promise<{ ops }>,
  *     // Any apply* call may also return either:
  *     //   { manifest: {...tier descriptor...} }
  *     // or:
- *     //   { manifestTiers: { sparseGram: {...}, hnsw: {...} } }
+ *     //   { manifestTiers: { sparseGram: {...}, binaryHnsw: {...} } }
  *     // These descriptors are merged into the next epoch manifest.
  *     readMaintenanceState(ctx):                  Promise<object>|object,
  *     scheduleMaintenance(job):                   Promise<void>|void,
@@ -70,7 +69,6 @@ const DEFAULT_FILES_PER_TICK = 50;
 const MANIFEST_TIER_KEYS = new Set([
   'codeGraph',
   'vectors',
-  'hnsw',
   'binaryHnsw',
   'lateInteraction',
   'sparseGram',
@@ -171,6 +169,27 @@ export class Reconciler {
     this._running = false;
   }
 
+  /**
+   * Lever E.1: batch per-tier writes per tick. When enabled, the reconciler
+   * opens a tick-scoped store context once at tick start (via the adapter's
+   * `beginTick` hook), threads it through every `apply*Delta`, and persists the
+   * batched HNSW + float artifacts once at tick finalize (via `finalizeTick`),
+   * BEFORE the manifest advances. Default off → exact current per-file behavior.
+   *
+   * The adapter must expose `beginTick`/`finalizeTick` for this to engage;
+   * absent those hooks, the per-file path is used regardless of the flag.
+   *
+   * @returns {boolean}
+   */
+  _batchTierWritesEnabled() {
+    // Default-ON (verified byte-identical with det-levels + crash-safe + soak==baseline);
+    // disable with SWEET_SEARCH_RECONCILE_BATCH_TIER_WRITES=0. Still requires the adapter
+    // to expose the tick hooks; absent those, the per-file path is used regardless.
+    return process.env.SWEET_SEARCH_RECONCILE_BATCH_TIER_WRITES !== '0'
+      && typeof this.adapters.beginTick === 'function'
+      && typeof this.adapters.finalizeTick === 'function';
+  }
+
   progress(phase) {
     this.onProgress?.(phase);
   }
@@ -240,6 +259,8 @@ export class Reconciler {
     let dirtyCursor = 0;
     let deferredRequeued = false;
     let manifestPublished = false;
+    const batched = this._batchTierWritesEnabled();
+    let tickCtx = null;
 
     try {
       dirty = await this.adapters.readDirtySet();
@@ -248,6 +269,14 @@ export class Reconciler {
 
       counters.set('cpu_budget_total_ms', this.config.cpuBudgetMs);
 
+      // Lever E.1: open the tick-scoped store context once (load HNSW + float
+      // store, open RW/RO connections) before the per-file loop. Threaded into
+      // every apply*Delta so they accumulate ops instead of open/save per file.
+      if (batched) {
+        tickCtx = await this.adapters.beginTick({ epoch });
+        this.progress('reconciler:tick-begin');
+      }
+
       // Track per-file outcomes for the tick summary.
       const tierOps = {};
       const manifestTiers = {};
@@ -266,7 +295,7 @@ export class Reconciler {
           counters.observeContentUnchanged();
           continue;
         }
-        const fileRes = await this._reconcileOneFile(file, epoch, hashes);
+        const fileRes = await this._reconcileOneFile(file, epoch, hashes, tickCtx);
         this.progress('reconciler:file:done');
         filesProcessed.push({ file, ...fileRes });
         mergeManifestTiers(manifestTiers, fileRes?.manifestTiers);
@@ -304,6 +333,23 @@ export class Reconciler {
         }
       }
 
+      // Lever E.1 PERSIST-BEFORE-ADVANCE: save the batched HNSW + float store
+      // ONCE here, BEFORE the manifest publishes. The adapter returns the set
+      // of files whose ops are in the persisted batch (and, on a partial batch
+      // cut, the files to requeue). Only persisted files are promoted into the
+      // merkle (the adapter reads the same context inside `persistManifest`),
+      // so a crash between the SQLite commits and this save can never leave a
+      // file marked indexed-but-missing-from-HNSW.
+      if (batched && tickCtx) {
+        const fin = await this.adapters.finalizeTick(tickCtx, { epoch }) || {};
+        this.progress('reconciler:tick-finalized');
+        const requeueFiles = Array.isArray(fin.requeueFiles) ? fin.requeueFiles : [];
+        if (requeueFiles.length > 0 && this.adapters.requeueDirtyFiles) {
+          counters.inc('dirty_paths_deferred', requeueFiles.length);
+          await this.adapters.requeueDirtyFiles(requeueFiles);
+        }
+      }
+
       // Publish the new manifest. Plan § 8.1 step 4: write to *.tmp,
       // fsync, atomic rename, fsync parent dir. `writeManifest` already
       // does that.
@@ -355,35 +401,61 @@ export class Reconciler {
       }
       throw err;
     } finally {
+      // Lever E.1: always release the tick-scoped store context (close any
+      // still-open RW/RO connections). Idempotent: a successful finalizeTick
+      // already closed them; this is the crash/throw safety net. Best-effort.
+      if (batched && tickCtx && typeof this.adapters.disposeTick === 'function') {
+        try { await this.adapters.disposeTick(tickCtx); } catch { /* never throw from finally */ }
+      }
       this._running = false;
     }
   }
 
-  async _reconcileOneFile(file, epoch, hashes) {
+  async _reconcileOneFile(file, epoch, hashes, tickCtx = null) {
     // Dispatch to per-tier adapter methods. Adapters can return undefined
-    // when a tier has no work for this file.
+    // when a tier has no work for this file. `tickCtx` is the lever-E.1
+    // tick-scoped store context (null on the per-file path).
     const ops = {};
     this.progress('reconciler:graph:start');
-    const graph = await this.adapters.applyGraphDelta?.(file, hashes, epoch);
+    const graph = await this.adapters.applyGraphDelta?.(file, hashes, epoch, tickCtx);
     this.progress('reconciler:graph:done');
     const manifestTiers = {};
     collectManifestTier(manifestTiers, 'codeGraph', graph);
     if (graph?.ops?.graph_upsert != null) ops.graph_upsert = graph.ops.graph_upsert;
     if (graph?.ops?.graph_tombstone != null) ops.graph_tombstone = graph.ops.graph_tombstone;
     this.progress('reconciler:vector:start');
-    const vec = await this.adapters.applyVectorDelta?.(file, hashes?.chunks ?? [], hashes, epoch);
+    const vec = await this.adapters.applyVectorDelta?.(file, hashes?.chunks ?? [], hashes, epoch, tickCtx);
     this.progress('reconciler:vector:done');
     collectManifestTier(manifestTiers, 'vectors', vec);
     if (vec?.ops?.vectors_upsert != null) ops.vectors_upsert = vec.ops.vectors_upsert;
     if (vec?.ops?.vectors_delete != null) ops.vectors_delete = vec.ops.vectors_delete;
-    this.progress('reconciler:hnsw:start');
-    const hnsw = await this.adapters.applyHNSWDelta?.(file, vec?.vectorOps ?? [], epoch);
-    this.progress('reconciler:hnsw:done');
-    collectManifestTier(manifestTiers, 'hnsw', hnsw);
-    if (hnsw?.ops?.hnsw_add != null) ops.hnsw_add = hnsw.ops.hnsw_add;
-    if (hnsw?.ops?.hnsw_tombstone != null) ops.hnsw_tombstone = hnsw.ops.hnsw_tombstone;
+    // Lever E.6: a cutoff-skipped file returns `skipped:true` from the vector
+    // adapter — no encode, no dense/HNSW/LI/graph writes. BUT sparse-grams are
+    // derived from RAW file content (not encoder inputs), so a content change
+    // with byte-identical encoder inputs still needs a sparse update or ss-grep
+    // goes stale. Apply ONLY the sparse-gram tier on cutoff-skip, then return.
+    if (vec?.skipped) {
+      this.progress('reconciler:sparse:start');
+      const sgSkip = await this.adapters.applySparseGramDelta?.(file, vec?.gramOps ?? [], epoch);
+      this.progress('reconciler:sparse:done');
+      collectManifestTier(manifestTiers, 'sparseGram', sgSkip);
+      if (sgSkip?.ops?.sparse_gram_delta_upsert != null) ops.sparse_gram_delta_upsert = sgSkip.ops.sparse_gram_delta_upsert;
+      return {
+        chunksTotal: vec?.chunksTotal ?? 0,
+        chunksEncoded: 0,
+        chunksReused: vec?.chunksReused ?? 0,
+        chunksStructStable: 0,
+        chunksTextUnchanged: 0,
+        chunksMetadataDirty: 0,
+        chunksDedupRepaired: 0,
+        treeSitterErrorNodes: graph?.treeSitterErrorNodes ?? 0,
+        skipped: true,
+        manifestTiers,
+        ops,
+      };
+    }
     this.progress('reconciler:binary-hnsw:start');
-    const bin = await this.adapters.applyBinaryHNSWDelta?.(file, vec?.vectorOps ?? [], epoch);
+    const bin = await this.adapters.applyBinaryHNSWDelta?.(file, vec?.vectorOps ?? [], epoch, tickCtx);
     this.progress('reconciler:binary-hnsw:done');
     collectManifestTier(manifestTiers, 'binaryHnsw', bin);
     if (bin?.ops?.binary_hnsw_append != null) ops.binary_hnsw_append = bin.ops.binary_hnsw_append;

package/core/incremental-indexing/domain/cutoff-cache.mjs

@@ -0,0 +1,191 @@
+/**
+ * Chunk-hash early-cutoff cache (lever E.6).
+ *
+ * Persists, per file, the set of encoder-input hashes that the file's chunks
+ * fed to the embedding + late-interaction encoders on the LAST successful
+ * reconcile of that file:
+ *
+ *   { [relativePath]: { embeddingInputHashes: string[], liInputHashes: string[] } }
+ *
+ * Before re-embedding a *changed* file, the reconciler recomputes the same
+ * per-chunk hashes from the freshly parsed + graph-enriched chunks and compares
+ * them to the persisted set. If — and only if — BOTH the embedding-input and the
+ * li-input hash sets match exactly, the file's encode + all tier writes can be
+ * skipped: the encoders would produce byte-identical inputs and therefore
+ * byte-identical outputs.
+ *
+ * CORRECTNESS GATE (the §1.1 Tier-3 risk).
+ * The cutoff key is `embedding_input_hash` + `li_input_hash` (from
+ * `encoder-input.mjs::chunkInputHashes`). These fold in cross-file graph
+ * enrichment (scope + imports injected by `enrichChunksFromGraph`), so a change
+ * to a DEPENDENCY's symbols changes the dependent file's `embedding_text` and
+ * therefore its `embedding_input_hash` — which means the dependent file is NOT
+ * skipped. The key MUST NEVER be the file's own `chunk_text_hash` nor the raw
+ * `contentUnchanged` flag, both of which miss cross-file enrichment and would
+ * silently degrade recall. This module deliberately accepts ONLY the encoder-
+ * input hashes and exposes no API that takes a text/content hash, so the
+ * correctness gate is enforced structurally.
+ *
+ * This is a DOMAIN module: pure functions over plain data plus a tiny
+ * JSON-on-disk persistence helper. The reconciler (application layer) owns the
+ * decision of when to skip; this module only computes the key, compares, and
+ * persists.
+ *
+ * Gated by `SWEET_SEARCH_RECONCILE_CHUNK_CUTOFF` at the call site
+ * (production-reconciler). When the flag is off the cache is neither read nor
+ * written and behavior is exactly today's.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { denseInputHash, liInputHash } from './encoder-input.mjs';
+
+export const CUTOFF_CACHE_FILENAME = 'reconcile-cutoff-cache.json';
+export const CUTOFF_CACHE_VERSION = 1;
+
+/**
+ * @returns {boolean} whether the chunk-cutoff lever is enabled.
+ *
+ * DEFAULT-ON (disable with SWEET_SEARCH_RECONCILE_CHUNK_CUTOFF=0). The cutoff key
+ * is the per-chunk encoder-input hashes (dense + LI), which fold in cross-file
+ * graph enrichment, so a file is skipped ONLY when its encoder inputs are
+ * byte-identical → byte-identical encoder outputs (verified recall-neutral). Set
+ * the flag to '0' to always re-encode changed files (today's behavior).
+ */
+export function chunkCutoffEnabled(env = process.env) {
+  return env.SWEET_SEARCH_RECONCILE_CHUNK_CUTOFF !== '0';
+}
+
+/**
+ * Compute the cutoff signature for a file's chunk set. The signature is the
+ * ordered list of per-chunk encoder-input hashes (dense + LI) — ordered so the
+ * comparison is sensitive to chunk reordering, not just set membership (a moved
+ * symbol is a real change to LI segment ordering).
+ *
+ * The chunks passed in MUST be the post-enrichment chunks (after
+ * `enrichChunksFromGraph`), so the dense hash reflects cross-file scope/imports.
+ *
+ * @param {Array<object>} chunks  enriched chunks for one file
+ * @returns {{embeddingInputHashes: string[], liInputHashes: string[]}}
+ */
+export function computeCutoffSignature(chunks) {
+  const embeddingInputHashes = [];
+  const liInputHashes = [];
+  for (const chunk of chunks || []) {
+    embeddingInputHashes.push(denseInputHash(chunk));
+    liInputHashes.push(liInputHash(chunk));
+  }
+  return { embeddingInputHashes, liInputHashes };
+}
+
+function arraysEqual(a, b) {
+  if (!Array.isArray(a) || !Array.isArray(b)) return false;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i += 1) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+
+/**
+ * Decide whether a file's encode + tier writes can be skipped.
+ *
+ * Returns true only when BOTH the embedding-input and li-input hash lists match
+ * the persisted signature exactly (same hashes, same order). An empty current
+ * signature (no chunks) never matches a non-empty stored one and vice versa, so
+ * a file that lost or gained all chunks is never skipped.
+ *
+ * @param {{embeddingInputHashes: string[], liInputHashes: string[]}|null} previous
+ * @param {{embeddingInputHashes: string[], liInputHashes: string[]}} current
+ * @returns {boolean}
+ */
+export function signaturesMatch(previous, current) {
+  if (!previous || !current) return false;
+  // Never skip a file whose chunk set went empty (deletion / total rewrite) —
+  // that path must flow through the normal retire logic.
+  if ((current.embeddingInputHashes?.length ?? 0) === 0) return false;
+  return arraysEqual(previous.embeddingInputHashes, current.embeddingInputHashes)
+    && arraysEqual(previous.liInputHashes, current.liInputHashes);
+}
+
+function cachePath(stateDir) {
+  return path.join(stateDir, CUTOFF_CACHE_FILENAME);
+}
+
+/**
+ * Load the whole cutoff cache (best-effort). A missing / corrupt file yields an
+ * empty cache so the first run after enabling the flag re-embeds normally and
+ * then populates the cache.
+ *
+ * @param {string} stateDir
+ * @returns {{version: number, files: Record<string, {embeddingInputHashes: string[], liInputHashes: string[]}>}}
+ */
+export function loadCutoffCache(stateDir) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(cachePath(stateDir), 'utf8'));
+    if (parsed && parsed.version === CUTOFF_CACHE_VERSION && parsed.files && typeof parsed.files === 'object') {
+      return parsed;
+    }
+  } catch {
+    // missing / unreadable / version-skew → empty
+  }
+  return { version: CUTOFF_CACHE_VERSION, files: {} };
+}
+
+/**
+ * Look up one file's persisted signature.
+ *
+ * @param {{files: Record<string, object>}} cache
+ * @param {string} relativePath
+ * @returns {{embeddingInputHashes: string[], liInputHashes: string[]}|null}
+ */
+export function getFileSignature(cache, relativePath) {
+  return cache?.files?.[relativePath] || null;
+}
+
+/**
+ * Record a file's new signature into an in-memory cache object (mutates it).
+ * Persist with `saveCutoffCache` once at tick-finalize.
+ *
+ * @param {{files: Record<string, object>}} cache
+ * @param {string} relativePath
+ * @param {{embeddingInputHashes: string[], liInputHashes: string[]}} signature
+ */
+export function setFileSignature(cache, relativePath, signature) {
+  if (!cache.files) cache.files = {};
+  cache.files[relativePath] = {
+    embeddingInputHashes: [...(signature.embeddingInputHashes || [])],
+    liInputHashes: [...(signature.liInputHashes || [])],
+  };
+}
+
+/**
+ * Drop a file from the cache (deletion / retirement).
+ *
+ * @param {{files: Record<string, object>}} cache
+ * @param {string} relativePath
+ */
+export function deleteFileSignature(cache, relativePath) {
+  if (cache?.files) delete cache.files[relativePath];
+}
+
+/**
+ * Persist the cutoff cache atomically (temp-file + rename). Best-effort: a
+ * write failure leaves the previous cache in place, which only costs a redundant
+ * re-embed on the next tick — never a correctness loss.
+ *
+ * @param {string} stateDir
+ * @param {{version: number, files: Record<string, object>}} cache
+ */
+export function saveCutoffCache(stateDir, cache) {
+  try {
+    fs.mkdirSync(stateDir, { recursive: true });
+    const filePath = cachePath(stateDir);
+    const tmp = `${filePath}.tmp.${process.pid}`;
+    fs.writeFileSync(tmp, JSON.stringify({ version: CUTOFF_CACHE_VERSION, files: cache?.files || {} }));
+    fs.renameSync(tmp, filePath);
+  } catch {
+    // best-effort; never throw on the maintainer path
+  }
+}

package/core/incremental-indexing/domain/interval-autotune.mjs

@@ -105,6 +105,88 @@ export function nextInterval(input) {
  */
 const TIER_TABLE = Object.freeze({ low: 60_000, mid: 30_000, high: 20_000 });
 
+/**
+ * Memory-tier table for the footprint levers (idle-TTL / RSS-budget soft cap) —
+ * the lever-D analogue of TIER_TABLE. Detect once at startup from system RAM:
+ * small-RAM hosts (laptops / constrained CI — the ~16 GB cross-repo OOM case in
+ * `project_ss_daemon_footprint_safety`) auto-enable the footprint levers; roomy
+ * hosts keep them OFF (no footprint pressure, and idle-TTL's respawn latency
+ * would only cost them with nothing to reclaim). The env overrides
+ * (`SWEET_SEARCH_MAINTAINER_IDLE_TTL_MS`, `SWEET_SEARCH_RSS_BUDGET_FRACTION`)
+ * always win over the tier default.
+ *
+ *   tight    (≤12 GiB) → idle-TTL 10 min, RSS soft cap 0.55
+ *   moderate (≤24 GiB) → idle-TTL 30 min, RSS soft cap 0.60
+ *   roomy    (>24 GiB) → idle-TTL OFF (0), no RSS cap (null)
+ *
+ * Pure: the caller injects `totalMemBytes` (os.totalmem()); a non-finite/absent
+ * value resolves to `roomy` — the safe, no-surprise default (levers stay off if
+ * detection ever fails).
+ */
+const MEMORY_TIER_TABLE = Object.freeze({
+  tight: { maxGiB: 12, idleTtlMs: 600_000, rssBudgetFraction: 0.55 },
+  moderate: { maxGiB: 24, idleTtlMs: 1_800_000, rssBudgetFraction: 0.60 },
+  roomy: { maxGiB: Infinity, idleTtlMs: 0, rssBudgetFraction: null },
+});
+
+/**
+ * @param {{ totalMemBytes?: number }} [options]  totalMemBytes = os.totalmem(), injected by the caller
+ * @returns {{ tier:'tight'|'moderate'|'roomy', totalGiB:number, idleTtlMs:number, rssBudgetFraction:(number|null) }}
+ */
+export function resolveMaintainerMemoryProfile({ totalMemBytes } = {}) {
+  const giB = Number.isFinite(totalMemBytes) ? totalMemBytes / (1024 ** 3) : Infinity;
+  let tier = 'roomy';
+  if (giB <= MEMORY_TIER_TABLE.tight.maxGiB) tier = 'tight';
+  else if (giB <= MEMORY_TIER_TABLE.moderate.maxGiB) tier = 'moderate';
+  const p = MEMORY_TIER_TABLE[tier];
+  return {
+    tier,
+    totalGiB: Number.isFinite(giB) ? Math.round(giB * 10) / 10 : Infinity,
+    idleTtlMs: p.idleTtlMs,
+    rssBudgetFraction: p.rssBudgetFraction,
+  };
+}
+
+/**
+ * Backstop full-walk cadence for the event-driven watcher (lever C / group G6).
+ *
+ * When the `@parcel/watcher` event stream is the primary dirty-set producer,
+ * the full `scanDirtyAndEnqueue` stat-walk is demoted to a periodic backstop
+ * (it still runs on the first tick, on watcher overflow, and on a forced walk).
+ * This resolver returns that cadence in milliseconds, clamped to [5min, 15min]
+ * — the window the design (§4.C) accepts as the worst-case convergence latency
+ * for a gitignore/exclude change that produced no file event. G4 owns this file;
+ * G6 consumes the resolved value from the maintainer loop.
+ *
+ * Precedence (highest first):
+ *   1. `SWEET_SEARCH_MAINTAINER_BACKSTOP_WALK_MS` (milliseconds)
+ *   2. default 10 min
+ *
+ * Values are clamped into [BACKSTOP_MIN_MS, BACKSTOP_MAX_MS]; a non-finite or
+ * non-positive override falls back to the default.
+ */
+const BACKSTOP_MIN_MS = 300_000;   // 5 min
+const BACKSTOP_MAX_MS = 900_000;   // 15 min
+const BACKSTOP_DEFAULT_MS = 600_000; // 10 min
+
+/**
+ * @param {{ env?: NodeJS.ProcessEnv }} [options]
+ * @returns {{ intervalMs:number, source:'env-override-ms'|'default' }}
+ */
+export function backstopWalkIntervalMs({ env = process.env } = {}) {
+  const raw = env.SWEET_SEARCH_MAINTAINER_BACKSTOP_WALK_MS;
+  if (raw !== undefined && raw !== '') {
+    const ms = Number(raw);
+    if (Number.isFinite(ms) && ms > 0) {
+      return {
+        intervalMs: Math.min(Math.max(ms, BACKSTOP_MIN_MS), BACKSTOP_MAX_MS),
+        source: 'env-override-ms',
+      };
+    }
+  }
+  return { intervalMs: BACKSTOP_DEFAULT_MS, source: 'default' };
+}
+
 /**
  * `SWEET_SEARCH_RECONCILE_PROFILE` lets operators pin the startup interval
  * by intent rather than by tier. `balanced` is a no-op (falls through to
@@ -251,5 +333,6 @@ export function reconcileEnablement(env = process.env) {
 export const __testing = {
   MIN_MS, MAX_MS, NOMINAL_MS,
   TARGET_TICK_WALLCLOCK_FRACTION, MAX_RATIO_CHANGE_PER_TICK,
-  TIER_TABLE, PROFILE_TABLE,
+  TIER_TABLE, PROFILE_TABLE, MEMORY_TIER_TABLE,
+  BACKSTOP_MIN_MS, BACKSTOP_MAX_MS, BACKSTOP_DEFAULT_MS,
 };

package/core/incremental-indexing/domain/reconcile-counters.mjs

@@ -42,15 +42,12 @@ const DEFAULT_FIELDS = Object.freeze({
   cpu_budget_total_ms: 0,
 
   manifest_epoch_mismatch_total: 0,
-  hnsw_live_candidate_shortfall: 0,
 });
 
 function freshOpsTier() {
   return {
     graph_upsert: 0, graph_tombstone: 0,
     vectors_upsert: 0, vectors_delete: 0,
-    hnsw_add: 0, hnsw_tombstone: 0,
-    hnsw_capacity_used: 0,
     binary_hnsw_tombstone: 0, binary_hnsw_append: 0,
     li_segment_append: 0, li_tombstone: 0,
     sparse_gram_delta_upsert: 0,
@@ -61,7 +58,6 @@ function freshOpsTier() {
 
 function freshWatermarks() {
   return {
-    hnsw_tombstone_fraction: 0,
     binary_hnsw_dead_doc_ratio: 0,
     li_segments_over_threshold: [],
     fts5_segment_count: 0,

package/core/incremental-indexing/domain/watermark-scheduler.mjs

@@ -8,8 +8,6 @@
  *
  * Watermarks (plan § 6.2):
  *
- *   - Float HNSW: `tombstone_fraction > 0.15` OR `delete_cycles > 1000`
- *     OR live-candidate shortfall observed → `float_hnsw` clean replacement.
  *   - Binary HNSW: `dead_doc_ratio > 0.30` → replacement.
  *   - LI segment: per-segment `stale_doc_ratio > 0.20` → per-segment recompaction.
  *   - Sparse-gram: `delta_size_ratio > 0.10` OR `delta_segment_count > 64`
@@ -23,8 +21,6 @@
  */
 
 export const DEFAULT_WATERMARKS = Object.freeze({
-  hnswTombstoneFraction: 0.15,
-  hnswDeleteCycles: 1000,
   binaryHnswDeadRatio: 0.30,
   liSegmentStaleRatio: 0.20,
   liSmallSegmentCount: 16,
@@ -51,8 +47,6 @@ export function loadWatermarkConfig(env = process.env) {
     return Number.isFinite(parsed) ? parsed : def;
   };
   return {
-    hnswTombstoneFraction: num('SWEET_SEARCH_HNSW_TOMBSTONE_THRESHOLD', DEFAULT_WATERMARKS.hnswTombstoneFraction),
-    hnswDeleteCycles: num('SWEET_SEARCH_HNSW_DELETE_CYCLES', DEFAULT_WATERMARKS.hnswDeleteCycles),
     binaryHnswDeadRatio: num('SWEET_SEARCH_BINARY_HNSW_DEAD_THRESHOLD', DEFAULT_WATERMARKS.binaryHnswDeadRatio),
     liSegmentStaleRatio: num('SWEET_SEARCH_LI_SEGMENT_STALE_THRESHOLD', DEFAULT_WATERMARKS.liSegmentStaleRatio),
     liSmallSegmentCount: num('SWEET_SEARCH_LI_SMALL_SEGMENT_THRESHOLD', DEFAULT_WATERMARKS.liSmallSegmentCount),
@@ -71,7 +65,6 @@ export function loadWatermarkConfig(env = process.env) {
  * Tier-state input shape:
  *
  *   {
- *     floatHnsw:    { tombstoneFraction, deleteCycles, liveCandidateShortfall },
  *     binaryHnsw:   { deadDocRatio },
  *     liSegments:   Array<{ segmentId, staleDocRatio }>,
  *     sparseGram:   { deltaSizeRatio, deltaSegmentCount },
@@ -88,23 +81,6 @@ export function loadWatermarkConfig(env = process.env) {
  */
 export function evaluateWatermarks(state, config = DEFAULT_WATERMARKS) {
   const jobs = [];
-  const floatH = state.floatHnsw || {};
-  if (
-    (floatH.tombstoneFraction ?? 0) > config.hnswTombstoneFraction
-    || (floatH.deleteCycles ?? 0) > config.hnswDeleteCycles
-    || floatH.liveCandidateShortfall === true
-  ) {
-    jobs.push({
-      tier: 'float_hnsw',
-      reason: floatH.liveCandidateShortfall ? 'live_candidate_shortfall'
-        : (floatH.tombstoneFraction > config.hnswTombstoneFraction
-            ? 'tombstone_watermark' : 'delete_cycles'),
-      payload: {
-        tombstoneFraction: floatH.tombstoneFraction ?? 0,
-        deleteCycles: floatH.deleteCycles ?? 0,
-      },
-    });
-  }
   const binH = state.binaryHnsw || {};
   // Reclaim on the dead-doc ratio (batched) OR on any *unexplained* divergence
   // from codebase.db — a vector retired there but never stale-marked in the

package/core/incremental-indexing/infrastructure/maintenance-state-reader.mjs

@@ -17,7 +17,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import Database from 'better-sqlite3';
 
-import { loadBitmap, popcount, tombstoneFraction } from './tombstone-bitmap.mjs';
+import { loadBitmap, popcount } from './tombstone-bitmap.mjs';
 import { deltaSizeStats } from './sparse-gram-delta.mjs';
 import { evaluateSegmentRatios, LI_SEGMENT_SIZE } from './li-segment-state.mjs';
 import { fts5SegmentCount } from './sqlite-fts5.mjs';
@@ -60,29 +60,6 @@ export function readSparseGramState(stateDir) {
   }
 }
 
-/**
- * Float HNSW: meta.json carries `idMap` (live ids — pruned on `remove()`)
- * and the stale bitmap at `.idx.stale.bin` mirrors the soft-delete state.
- *
- *   tombstoneFraction = popcount(bitmap) / (popcount + liveTotal)
- *
- * `liveCandidateShortfall` stays undefined here — that signal must come
- * from a query-path counter (plan § 7.3), not from offline state.
- */
-export function readFloatHnswState(stateDir) {
-  const empty = { tombstoneFraction: 0, deleteCycles: 0 };
-  const metaPath = path.join(stateDir, 'codebase-hnsw.meta.json');
-  if (!fs.existsSync(metaPath)) return empty;
-  const meta = readJson(metaPath);
-  if (!meta) return empty;
-  const idMap = Array.isArray(meta.idMap) ? meta.idMap : [];
-  const liveTotal = idMap.length;
-  let bitmap = null;
-  try { bitmap = loadBitmap(path.join(stateDir, 'codebase-hnsw.idx.stale.bin')); } catch { bitmap = null; }
-  const fraction = bitmap ? tombstoneFraction(bitmap, liveTotal) : 0;
-  return { tombstoneFraction: fraction, deleteCycles: 0 };
-}
-
 /**
  * Binary HNSW: meta.json's `vectorCount` is the row count in `vectors.json`
  * (never pruned — see `binary-hnsw-index.js::save`). The bitmap at
@@ -266,14 +243,13 @@ export function readGraphGcState(stateDir) {
 
 /**
  * One-shot bundle for the reconciler adapter. Returns the full shape
- * `evaluateWatermarks` expects: `fts5 / sparseGram / floatHnsw /
+ * `evaluateWatermarks` expects: `fts5 / sparseGram /
  * binaryHnsw / liSegments / liSegmentStats / vectors / graph`.
  */
 export function readMaintenanceState(stateDir) {
   return {
     fts5: readFts5State(stateDir),
     sparseGram: readSparseGramState(stateDir),
-    floatHnsw: readFloatHnswState(stateDir),
     binaryHnsw: readBinaryHnswState(stateDir),
     liSegments: readLiSegmentsState(stateDir),
     liSegmentStats: readLiSegmentStats(stateDir),

package/core/incremental-indexing/infrastructure/manifest.mjs

@@ -15,9 +15,6 @@
  *     "publishedAt": "2026-05-15T23:00:00.000Z",
  *     "codeGraph":      { "path": "code-graph.db", "epoch": 12847 },
  *     "vectors":        { "path": "codebase.db", "epoch": 12847 },
- *     "hnsw":           { "path": "codebase-hnsw.idx",
- *                          "stale": "codebase-hnsw.idx.stale.bin",
- *                          "epoch": 12847 },
  *     "binaryHnsw":     { "path": "codebase-binary-hnsw.idx", "epoch": 12847 },
  *     "lateInteraction":{ "manifest": "codebase-late-interaction.db.segments/manifest.json",
  *                          "epoch": 12847 },
@@ -61,11 +58,6 @@ export function zeroManifest(paths) {
     publishedAt: new Date().toISOString(),
     codeGraph: { path: paths.codeGraph || 'code-graph.db', epoch: 0 },
     vectors: { path: paths.vectors || 'codebase.db', epoch: 0 },
-    hnsw: {
-      path: paths.hnsw || 'codebase-hnsw.idx',
-      stale: paths.hnswStale || 'codebase-hnsw.idx.stale.bin',
-      epoch: 0,
-    },
     binaryHnsw: {
       path: paths.binaryHnsw || 'codebase-binary-hnsw.idx',
       epoch: 0,
@@ -160,7 +152,7 @@ export function buildNextManifest(prev, delta) {
     publishedAt: new Date().toISOString(),
   };
   const tiers = delta.tiers || {};
-  for (const key of ['codeGraph', 'vectors', 'hnsw', 'binaryHnsw', 'lateInteraction', 'sparseGram']) {
+  for (const key of ['codeGraph', 'vectors', 'binaryHnsw', 'lateInteraction', 'sparseGram']) {
     if (!tiers[key]) {
       // Carry forward the previous tier descriptor with the new epoch.
       out[key] = { ...(prev[key] || {}), epoch: delta.epoch };