sweet-search 2.6.8 → 2.6.10

package/README.md

@@ -711,6 +711,21 @@ without you ever running a command.
 - **Resource-polite:** ticks are budgeted (≤50 files / ≤2 s CPU per tick), run CPU-only (the GPU is reserved for cold full indexing), and the interval auto-tunes from load average, churn, and backlog.
 - `sweet-search reconcile status` / `reconcile inspect <path>` explain exactly what the daemon thinks and why. Opt out any time with `SWEET_SEARCH_RECONCILE_V2=0`.
 
+**Memory controls.** The resident daemons show up in `ps` / Activity Monitor as
+`sweet-search-maintainer` and `sweet-search-daemon`. A maintainer's steady state is
+roughly 2–3 GB (embedding + late-interaction models stay loaded so ticks are fast),
+and four independent mechanisms keep that bounded:
+
+| Mechanism | Default | Override |
+|-----------|---------|----------|
+| Background ORT profile (arena-off + parked threads) in the maintainer | on | `SWEET_SEARCH_ORT_BACKGROUND=0` |
+| Per-process recycle ceiling — the maintainer finishes its tick, exits cleanly, and respawns fresh on the next edit when its RSS crosses the line | clamp(25 % of RAM, 4 GiB, 8 GiB) | `SWEET_SEARCH_MAINTAINER_RSS_MAX_MB` (0 disables) |
+| Idle TTL — unattended daemons shut down and respawn on demand | tier-aware | `SWEET_SEARCH_MAINTAINER_IDLE_TTL_MS` / `SWEET_SEARCH_DAEMON_IDLE_TTL_MS` |
+| Fleet RSS budget — across all repos' daemons, the longest-idle one is evicted when the sum crosses a RAM-scaled budget | tier-aware | `SWEET_SEARCH_RSS_BUDGET_FRACTION` |
+
+A recycle or eviction never touches index state: every tick publishes atomically
+before the process exits, and the next edit (or query) respawns a fresh daemon.
+
 </details>
 
 ## 🦀 The Native Engine Room

package/core/cli.js

@@ -94,6 +94,13 @@ if (args[0] === 'init') {
     await runIndexer();
   }
 } else if (args[0] === '--serve' || args[0] === '--stop') {
+  // Name the resident daemon so ps/Activity Monitor shows what it is instead
+  // of an anonymous `node`. Entrypoint-scoped: library consumers of the
+  // search modules are never retitled. Liveness checks are lock/pid-based,
+  // never command-line matching, so this is cosmetic-only.
+  if (args[0] === '--serve') {
+    try { process.title = 'sweet-search-daemon'; } catch { /* best-effort */ }
+  }
   // Warm search server lifecycle is implemented in JS.
   const { runCli } = await import('./search/index.js');
   await runCli(args);

package/core/graph/graph-extractor.js

@@ -2351,7 +2351,28 @@ function resolveThrows(exceptionName, entityByName) {
  * Insert entities and relationships into database
  * Uses better-sqlite3 (sync API, no .free() needed)
  */
-export function insertGraph(db, entities, relationships, hasFts5 = false) {
+/**
+ * Rebuild + optimize the external-content FTS5 mirrors from the entities
+ * table. 'rebuild' reconstructs the whole FTS index from current content, so
+ * only the LAST rebuild before any FTS read matters — batch loops should
+ * pass { syncFts: false } to insertGraph and call this once at the end.
+ */
+export function rebuildGraphFts(db) {
+  try {
+    db.exec(`INSERT INTO entities_fts(entities_fts) VALUES('rebuild')`);
+    db.exec(`INSERT INTO entities_trigram(entities_trigram) VALUES('rebuild')`);
+    console.log('  FTS5 indexes rebuilt (porter + trigram)');
+
+    // Best-effort post-build compaction for faster reads.
+    db.exec(`INSERT INTO entities_fts(entities_fts) VALUES('optimize')`);
+    db.exec(`INSERT INTO entities_trigram(entities_trigram) VALUES('optimize')`);
+    console.log('  FTS5 indexes optimized (segments merged)');
+  } catch (err) {
+    // FTS5 rebuild/optimize failed, ignore
+  }
+}
+
+export function insertGraph(db, entities, relationships, hasFts5 = false, { syncFts = true } = {}) {
   // Insert entities with HCGS hierarchy support
   // Includes signature_hash for collision-proof backup/restore
   const entityStmt = db.prepare(`
@@ -2481,19 +2502,8 @@ export function insertGraph(db, entities, relationships, hasFts5 = false) {
   // }
 
   // Rebuild FTS indexes if available
-  if (hasFts5) {
-    try {
-      db.exec(`INSERT INTO entities_fts(entities_fts) VALUES('rebuild')`);
-      db.exec(`INSERT INTO entities_trigram(entities_trigram) VALUES('rebuild')`);
-      console.log('  FTS5 indexes rebuilt (porter + trigram)');
-
-      // Best-effort post-build compaction for faster reads.
-      db.exec(`INSERT INTO entities_fts(entities_fts) VALUES('optimize')`);
-      db.exec(`INSERT INTO entities_trigram(entities_trigram) VALUES('optimize')`);
-      console.log('  FTS5 indexes optimized (segments merged)');
-    } catch (err) {
-      // FTS5 rebuild/optimize failed, ignore
-    }
+  if (hasFts5 && syncFts) {
+    rebuildGraphFts(db);
   }
 }
 

package/core/graph/hcgs-generator.js

@@ -428,9 +428,10 @@ async function generateSummariesForEntities(entityIds, options = {}) {
     const dbWrite = new Database(dbPath);
     const stmt = dbWrite.prepare(`UPDATE entities SET summary = NULL WHERE id = ?`);
 
-    for (const entity of entities) {
-      stmt.run(entity.id);
-    }
+    const clearSummaries = dbWrite.transaction((rows) => {
+      for (const entity of rows) stmt.run(entity.id);
+    });
+    clearSummaries(entities);
 
     dbWrite.close();
 

package/core/incremental-indexing/application/production-li-delta.mjs

@@ -117,6 +117,7 @@ export async function applyLateInteractionDelta({
   liEncoder,
   pickLiInput,
   onProgress = null,
+  readerCache = null,
 }) {
   const progress = typeof onProgress === 'function'
     ? (phase) => { onProgress(phase); }
@@ -128,11 +129,35 @@ export async function applyLateInteractionDelta({
   const encode = liEncoder || ((texts) => encodeDocumentsCpu(texts));
   const existing = fs.existsSync(indexPath);
   const segmented = existing ? segmentedState(indexPath) : null;
-  const index = new LateInteractionIndex({ indexPath, loadExisting: true });
-  await index.init();
-  progress('li:init');
+
+  // E.1-LI reader cache: reuse the loaded read view across the tick's files.
+  // Only the SEGMENTED path is cacheable — everything the reader serves there
+  // (config fields, positions/counts of pre-tick docs) is immutable within a
+  // tick: per-file ops only reference the file's own pre-tick docs, appends
+  // go through appendGrowingSegment (which re-reads the manifest from disk),
+  // and tombstone sidecar state is opened fresh per call. The legacy path
+  // MUTATES the loaded index (rewriteLegacyIndex), so it always loads fresh
+  // and drops any cached reader.
+  const cacheable = !!(readerCache && segmented);
+  let index;
+  if (cacheable && readerCache.index && readerCache.key === indexPath) {
+    index = readerCache.index;
+    progress('li:init-cached');
+  } else {
+    index = new LateInteractionIndex({ indexPath, loadExisting: true });
+    await index.init();
+    progress('li:init');
+    if (cacheable) {
+      readerCache.key = indexPath;
+      readerCache.index = index;
+    }
+  }
 
   if (existing && !segmented) {
+    if (readerCache) {
+      readerCache.key = null;
+      readerCache.index = null;
+    }
     return rewriteLegacyIndex(index, ops, encode, pickLiInput, progress);
   }
 

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

@@ -34,6 +34,7 @@ import { floatToBinary, normalizedFloatToInt8, truncateForHNSW } from '../../inf
 import { extractSparseGramDeltaRecord } from '../../infrastructure/native-sparse-gram.js';
 import { migrateEntitiesSchema, migrateRelationshipsSchema } from '../infrastructure/schema-migrations.mjs';
 import { readMaintenanceState as readMaintenanceStateFromArtifacts } from '../infrastructure/maintenance-state-reader.mjs';
+import { prepareCached } from '../../infrastructure/db-utils.js';
 
 const DIRTY_QUEUE = 'index-maintainer-queue.jsonl';
 const PROCESSING_QUEUE = 'index-maintainer-queue.processing.jsonl';
@@ -270,9 +271,9 @@ async function enrichChunksFromGraph(chunks, stateDir, tickCtx = null) {
     ownConn = true;
   }
   try {
-    const entityStmt = db.prepare('SELECT type, name, start_line, end_line FROM entities WHERE file_path = ? AND epoch_retired IS NULL ORDER BY start_line ASC');
-    const fileEntityStmt = db.prepare('SELECT id FROM entities WHERE file_path = ? AND logical_entity_id = ? AND epoch_retired IS NULL ORDER BY epoch_written DESC LIMIT 1');
-    const importStmt = db.prepare("SELECT DISTINCT target_name FROM relationships WHERE source_id = ? AND type IN ('imports', 'plainImport') AND epoch_retired IS NULL ORDER BY target_name");
+    const entityStmt = prepareCached(db, 'SELECT type, name, start_line, end_line FROM entities WHERE file_path = ? AND epoch_retired IS NULL ORDER BY start_line ASC');
+    const fileEntityStmt = prepareCached(db, 'SELECT id FROM entities WHERE file_path = ? AND logical_entity_id = ? AND epoch_retired IS NULL ORDER BY epoch_written DESC LIMIT 1');
+    const importStmt = prepareCached(db, "SELECT DISTINCT target_name FROM relationships WHERE source_id = ? AND type IN ('imports', 'plainImport') AND epoch_retired IS NULL ORDER BY target_name");
     for (const chunk of chunks) {
       const file = chunk.file || chunk.metadata?.relative_path;
       const symbol = chunk.metadata?.symbol;
@@ -376,6 +377,23 @@ class ProductionReconcileAdapter {
     // when the flag is on; null when disabled.
     this._cutoffCache = null;
     this._cutoffDirty = false;
+    // merkle-state.json is written exactly once per tick (persistManifest);
+    // every other reader gets one shared parse. `undefined` = not read yet,
+    // `null` = missing/corrupt file.
+    this._merkleCache = undefined;
+  }
+
+  /**
+   * Shared read of merkle-state.json — parsed once per adapter lifetime and
+   * invalidated by persistManifest (the only writer). All consumers treat the
+   * object as read-only.
+   * @returns {object|null}
+   */
+  _merkleRead() {
+    if (this._merkleCache === undefined) {
+      this._merkleCache = readJson(path.join(this.stateDir, MERKLE_STATE), null);
+    }
+    return this._merkleCache;
   }
 
   progress(phase) {
@@ -401,7 +419,7 @@ class ProductionReconcileAdapter {
       applyGraphDelta: (file, hashes, epoch, ctx) => this.applyGraphDelta(file, hashes, epoch, ctx),
       applyVectorDelta: (file, chunks, hashes, epoch, ctx) => this.applyVectorDelta(file, chunks, hashes, epoch, ctx),
       applyBinaryHNSWDelta: (file, ops, epoch, ctx) => this.applyBinaryHNSWDelta(file, ops, epoch, ctx),
-      applyLIDelta: (file, ops, epoch) => this.applyLIDelta(file, ops, epoch),
+      applyLIDelta: (file, ops, epoch, ctx) => this.applyLIDelta(file, ops, ctx),
       applySparseGramDelta: (file, ops, epoch) => this.applySparseGramDelta(file, ops, epoch),
       readMaintenanceState: () => this.readMaintenanceState(),
       scheduleMaintenance: (job) => enqueueMaintenanceJob(this.stateDir, job),
@@ -697,7 +715,7 @@ class ProductionReconcileAdapter {
     // dropped if it was never indexed, and retired if it was (so the index
     // converges to a fresh full rebuild). Existence + shape + size are sync;
     // gitignore is ONE batched check over the admissible candidates.
-    const merkle = readJson(path.join(this.stateDir, MERKLE_STATE), { files: {} }).files || {};
+    const merkle = (this._merkleRead() ?? { files: {} }).files || {};
     const info = rels.map((rel) => {
       const abs = path.join(this.projectRoot, rel);
       const exists = fs.existsSync(abs);
@@ -736,7 +754,7 @@ class ProductionReconcileAdapter {
   async hashFile(file) {
     const rel = typeof file === 'string' ? file : file.path;
     const abs = path.join(this.projectRoot, rel);
-    const merkle = readJson(path.join(this.stateDir, MERKLE_STATE), { files: {} });
+    const merkle = this._merkleRead() ?? { files: {} };
     // Deleted on disk, or flagged inadmissible by readDirtySet (a previously
     // indexed file that became excluded/oversized/gitignored): retire it so all
     // tiers tombstone and the merkle entry is dropped.
@@ -784,7 +802,7 @@ class ProductionReconcileAdapter {
       ownConn = true;
     }
     try {
-      const oldRows = db.prepare('SELECT rowid, id, logical_entity_id, signature_hash FROM entities WHERE file_path = ? AND epoch_retired IS NULL').all(rel);
+      const oldRows = prepareCached(db, 'SELECT rowid, id, logical_entity_id, signature_hash FROM entities WHERE file_path = ? AND epoch_retired IS NULL').all(rel);
       const oldByLogical = new Map(oldRows.map((r) => [r.logical_entity_id || r.id, r]));
       const oldIds = oldRows.map((r) => r.id);
       const extractor = new GraphExtractor();
@@ -811,7 +829,7 @@ class ProductionReconcileAdapter {
       let tombstone = 0;
       const liveIdFor = new Map();
       const tx = db.transaction(() => {
-        const retireEntity = db.prepare('UPDATE entities SET epoch_retired = ?, stale_since = COALESCE(stale_since, ?) WHERE id = ? AND epoch_retired IS NULL');
+        const retireEntity = prepareCached(db, 'UPDATE entities SET epoch_retired = ?, stale_since = COALESCE(stale_since, ?) WHERE id = ? AND epoch_retired IS NULL');
         const retireRel = oldIds.length > 0
           ? db.prepare(`UPDATE relationships SET epoch_retired = ? WHERE source_id IN (${oldIds.map(() => '?').join(',')}) AND epoch_retired IS NULL`)
           : null;
@@ -913,7 +931,7 @@ class ProductionReconcileAdapter {
           // tier write. The merkle still records the new content hash so the
           // file is not re-queued forever.
           const prevTouched = this.touched.get(rel) || {};
-          const prevChunkIds = readJson(path.join(this.stateDir, MERKLE_STATE), { files: {} }).files?.[rel]?.chunkIds || prevTouched.chunkIds || [];
+          const prevChunkIds = (this._merkleRead() ?? { files: {} }).files?.[rel]?.chunkIds || prevTouched.chunkIds || [];
           this.touched.set(rel, { ...prevTouched, hash: hashes, chunkIds: prevChunkIds, content: hashes.content });
           if (ctx) ctx.persistedFiles.add(rel);
           return {
@@ -1139,7 +1157,7 @@ class ProductionReconcileAdapter {
     return { ops: { binary_hnsw_append: append, binary_hnsw_tombstone: tombstone }, manifest: { path: 'codebase-binary-hnsw.idx' } };
   }
 
-  async applyLIDelta(file, ops) {
+  async applyLIDelta(file, ops, ctx = null) {
     if (!Array.isArray(ops) || ops.length === 0) return { ops: { li_segment_append: 0, li_tombstone: 0 } };
     // LI generated-content parity: full indexing's buildLateInteractionIndex runs
     // applyIndexingChunkPolicy so @generated / config-excluded files never reach
@@ -1152,12 +1170,21 @@ class ProductionReconcileAdapter {
       ? ops.filter((op) => !(op.addId && op.chunk))
       : ops;
     const { applyLateInteractionDelta } = await import('./production-li-delta.mjs');
+    // E.1-LI: tick-scoped READER cache. The per-file delta previously paid a
+    // full loadExisting init (segment manifest + doc positions over a multi-
+    // hundred-MB index) once per file; within one tick the reader view it
+    // needs is stable (per-file ops only reference the file's own pre-tick
+    // docs, appendGrowingSegment re-reads the manifest from disk, and segment
+    // compaction only runs in maintenance after the tick). Null ctx (per-file
+    // path) ⇒ fresh load per file, exactly as before.
+    const readerCache = ctx ? (ctx._liReaderCache ??= { key: null, index: null }) : null;
     const { appended, tombstone } = await applyLateInteractionDelta({
       indexPath: path.join(this.stateDir, 'codebase-late-interaction.db'),
       ops: filteredOps,
       liEncoder: this.liEncoder,
       pickLiInput,
       onProgress: () => this.progress('production:li-delta'),
+      readerCache,
     });
     return { ops: { li_segment_append: appended, li_tombstone: tombstone }, manifest: { path: 'codebase-late-interaction.db', segments: 'codebase-late-interaction.db.segments/manifest.json' } };
   }
@@ -1170,7 +1197,7 @@ class ProductionReconcileAdapter {
    * @returns {number}
    */
   _publishedEpoch() {
-    const merkle = readJson(path.join(this.stateDir, MERKLE_STATE), {});
+    const merkle = this._merkleRead() ?? {};
     return Number.isInteger(merkle?.epoch) ? merkle.epoch : -1;
   }
 
@@ -1225,6 +1252,8 @@ class ProductionReconcileAdapter {
     merkle.epoch = manifest.epoch;
     merkle.stats = { ...(merkle.stats || {}), totalFiles: Object.keys(merkle.files).length };
     safeWriteJson(merklePath, merkle);
+    // Invalidate the shared read cache — this is the one merkle writer.
+    this._merkleCache = undefined;
     // E.6: persist the updated chunk-cutoff cache once per tick (after the
     // merkle advances). Best-effort; a failure only costs a redundant re-embed.
     if (this._cutoffCache && this._cutoffDirty) {

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

@@ -461,7 +461,7 @@ export class Reconciler {
     if (bin?.ops?.binary_hnsw_append != null) ops.binary_hnsw_append = bin.ops.binary_hnsw_append;
     if (bin?.ops?.binary_hnsw_tombstone != null) ops.binary_hnsw_tombstone = bin.ops.binary_hnsw_tombstone;
     this.progress('reconciler:li:start');
-    const li = await this.adapters.applyLIDelta?.(file, vec?.tokenOps ?? [], epoch);
+    const li = await this.adapters.applyLIDelta?.(file, vec?.tokenOps ?? [], epoch, tickCtx);
     this.progress('reconciler:li:done');
     collectManifestTier(manifestTiers, 'lateInteraction', li);
     if (li?.ops?.li_segment_append != null) ops.li_segment_append = li.ops.li_segment_append;

package/core/incremental-indexing/domain/encoder-input.mjs

@@ -192,13 +192,17 @@ function firstSafeRelativePath(...candidates) {
  * carried inside the encoder-input dependency registry; see
  * `core/incremental-indexing/domain/encoder-deps.mjs`).
  *
+ * Pass `{ includeDedup: false }` when the caller never persists the dedup
+ * fingerprint (the full-indexing insert path) to skip that hash entirely.
+ *
  * @param {object} chunk
- * @returns {{chunk_text_hash:string, embedding_input_hash:string, li_input_hash:string, metadata_fingerprint:string, dedup_fingerprint:string}}
+ * @param {{includeDedup?: boolean}} [opts]
+ * @returns {{chunk_text_hash:string, embedding_input_hash:string, li_input_hash:string, metadata_fingerprint:string, dedup_fingerprint?:string}}
  */
-export function chunkInputHashes(chunk) {
+export function chunkInputHashes(chunk, { includeDedup = true } = {}) {
   const text = chunk?.content || chunk?.text || '';
   const meta = chunk?.metadata || {};
-  return {
+  const hashes = {
     chunk_text_hash: contentHashSync(text),
     embedding_input_hash: denseInputHash(chunk),
     li_input_hash: liInputHash(chunk),
@@ -214,8 +218,9 @@ export function chunkInputHashes(chunk) {
       policy_embed: EMBED_TEXT_POLICY_VERSION,
       policy_li: LI_INPUT_POLICY_VERSION,
     })),
-    dedup_fingerprint: dedupFingerprint(chunk),
   };
+  if (includeDedup) hashes.dedup_fingerprint = dedupFingerprint(chunk);
+  return hashes;
 }
 
 /**

package/core/indexing/artifact-builder.js

@@ -52,7 +52,7 @@ export const ARTIFACT_THRESHOLDS = {
   stateFile: '.sweet-search/artifact-rebuild-state.json',
 };
 
-import { BinaryHNSWIndex } from '../vector-store/binary-hnsw-index.js';
+import { BinaryHNSWIndex, int8SidecarCount } from '../vector-store/binary-hnsw-index.js';
 import { truncateForHNSW, fisherYatesShuffle, normalizedFloatToInt8, floatToBinary } from '../infrastructure/quantization.js';
 import { FloatVectorStore, getFloatStorePath } from '../vector-store/float-vector-store.js';
 
@@ -828,8 +828,10 @@ export async function getArtifactStats() {
   if (existsSync(int8SidecarPath)) {
     try {
       const fileStats = await fs.stat(int8SidecarPath);
-      const int8Data = JSON.parse(await fs.readFile(int8SidecarPath, 'utf-8'));
-      const count = Object.keys(int8Data).length;
+      // Header-only count (NDJSON v2 sidecar; v1 back-compat) — never
+      // JSON.parse the whole file, which exceeds V8's string ceiling on
+      // large indexes.
+      const count = await int8SidecarCount(int8SidecarPath);
 
       stats.int8Sidecar = {
         exists: true,

package/core/indexing/ast-chunker.js

@@ -151,12 +151,12 @@ function buildEmbeddingText({ variant: variantOverride, content, relativePath, l
   const pathLine = relativePath ? `# ${relativePath}` : null;
   const parentLine = hierarchyInfo?.parentSymbol
     ? `# Parent: ${hierarchyInfo.parentType} ${hierarchyInfo.parentSymbol}` : null;
-  // Ruby method chunks keep metadata anchors, but omit method-name header
-  // text so top-level Ruby snippets stay aligned with the pre-method-boundary
-  // embedding surface.
-  const isRubyMethodChunk = language === 'ruby'
-    && (chunkType === 'method' || chunkType === 'singleton_method');
-  const symbolLine = (symbol && symbol !== 'unknown' && !isRubyMethodChunk)
+  // Ruby method chunks keep metadata anchors, but omit method-name header
+  // text so top-level Ruby snippets stay aligned with the pre-method-boundary
+  // embedding surface.
+  const isRubyMethodChunk = language === 'ruby'
+    && (chunkType === 'method' || chunkType === 'singleton_method');
+  const symbolLine = (symbol && symbol !== 'unknown' && !isRubyMethodChunk)
     ? `# ${chunkType}: ${symbol}` : null;
   const langLine = (language && language !== 'text')
     ? `# Language: ${language}` : null;
@@ -293,10 +293,10 @@ function buildLiText({ content, relativePath, language, chunkType, symbol, hiera
   if (hierarchyInfo?.parentSymbol) {
     lines.push(`# Parent: ${hierarchyInfo.parentType} ${hierarchyInfo.parentSymbol}`);
   }
-  // Mirror the Ruby method header carve-out used by embedding_text.
-  const isRubyMethodChunk = language === 'ruby'
-    && (chunkType === 'method' || chunkType === 'singleton_method');
-  if (symbol && symbol !== 'unknown' && !isRubyMethodChunk) {
+  // Mirror the Ruby method header carve-out used by embedding_text.
+  const isRubyMethodChunk = language === 'ruby'
+    && (chunkType === 'method' || chunkType === 'singleton_method');
+  if (symbol && symbol !== 'unknown' && !isRubyMethodChunk) {
     lines.push(`# ${chunkType}: ${symbol}`);
   }
   // Mirror embedding_text: surface sibling symbol names so the LI MaxSim
@@ -391,27 +391,27 @@ export class ASTChunker {
     const tsChunks = await provider.parseFileToChunks(content, langInfo.id);
     if (!tsChunks || tsChunks.length === 0) return null;
 
-    return tsChunks.map(chunk => {
-      const isTopLevelRubyMethod = langInfo.id === 'ruby'
-        && (chunk.type === 'method' || chunk.type === 'singleton_method')
-        && !chunk.parentSymbol;
-
-      return this.buildChunk(
-        chunk.text, filePath, langInfo.id,
-        isTopLevelRubyMethod ? 'code' : chunk.type,
-        isTopLevelRubyMethod ? null : chunk.name,
-        chunk.startLine, chunk.endLine,
-        {
-          chunkId: chunk.chunkId,
-          parentChunkId: chunk.parentChunkId,
-          parentSymbol: chunk.parentSymbol,
-          parentType: chunk.parentType,
-          signature: chunk.signature || null,
-          additionalSymbols: chunk.additionalSymbols || null,
-        }
-      );
-    });
-  }
+    return tsChunks.map(chunk => {
+      const isTopLevelRubyMethod = langInfo.id === 'ruby'
+        && (chunk.type === 'method' || chunk.type === 'singleton_method')
+        && !chunk.parentSymbol;
+
+      return this.buildChunk(
+        chunk.text, filePath, langInfo.id,
+        isTopLevelRubyMethod ? 'code' : chunk.type,
+        isTopLevelRubyMethod ? null : chunk.name,
+        chunk.startLine, chunk.endLine,
+        {
+          chunkId: chunk.chunkId,
+          parentChunkId: chunk.parentChunkId,
+          parentSymbol: chunk.parentSymbol,
+          parentType: chunk.parentType,
+          signature: chunk.signature || null,
+          additionalSymbols: chunk.additionalSymbols || null,
+        }
+      );
+    });
+  }
 
   parseBraceBasedFile(filePath, content, language, patterns, comment, multiLine) {
     const chunks = [];
@@ -942,6 +942,7 @@ export class ASTChunker {
     // Production embedding text. With the default variant (current) this
     // is byte-identical to shipped v6.2; under a research-only variant
     // (SWEET_SEARCH_EMBED_TEXT_VARIANT) it produces the experimental form.
+    const activeVariant = getEmbedTextVariant();
     const embedding_text = buildEmbeddingText({
       content,
       relativePath,
@@ -954,17 +955,19 @@ export class ASTChunker {
     // Research isolation: always build the shipped (current-variant)
     // form alongside, so the LI stage can read a canonical input even
     // when an R1 experiment is active on embedding_text. In production
-    // (variant=current) this is the same content as embedding_text and
-    // pickLiInput's preference for li_greedy_text changes nothing.
-    const li_greedy_text = buildEmbeddingText({
-      variant: 'current',
-      content,
-      relativePath,
-      language,
-      chunkType,
-      symbol,
-      hierarchyInfo,
-    });
+    // (variant=current) it IS the embedding_text — reuse the string
+    // instead of rebuilding it.
+    const li_greedy_text = activeVariant === 'current'
+      ? embedding_text
+      : buildEmbeddingText({
+        variant: 'current',
+        content,
+        relativePath,
+        language,
+        chunkType,
+        symbol,
+        hierarchyInfo,
+      });
 
     // Build LI text via the v6.2 builder (language-conditioned path
     // policy). See buildLiText() docstring for rationale.
@@ -1034,26 +1037,26 @@ export class ASTChunker {
     const parts = [];
     parts.push(`# ${chunk.metadata.path}`);
 
-    const isRubyMethodChunk = chunk.metadata.language === 'ruby'
-      && (chunk.metadata.chunk_type === 'method'
-        || chunk.metadata.chunk_type === 'singleton_method');
-    const hasOnlySelfScope = scopeChain
-      && scopeChain.length === 1
-      && scopeChain[0] === chunk.metadata.symbol
-      && !chunk.metadata.parent_symbol;
-
-    if (scopeChain && scopeChain.length > 0 && !(isRubyMethodChunk && hasOnlySelfScope)) {
-      parts.push(`# Scope: ${scopeChain.join(' > ')}`);
-    } else if (chunk.metadata.parent_symbol) {
-      // Preserve cAST parent context when no scope chain from code graph
-      parts.push(`# Parent: ${chunk.metadata.parent_type} ${chunk.metadata.parent_symbol}`);
-    }
-    // Keep Ruby method metadata, but avoid injecting the method name into
-    // the production embedding/LI text. Top-level Ruby method chunks also
-    // skip self-only scope above.
-    if (chunk.metadata.symbol && chunk.metadata.symbol !== 'unknown' && !isRubyMethodChunk) {
-      parts.push(`# Defines: ${chunk.metadata.chunk_type} ${chunk.metadata.symbol}`);
-    }
+    const isRubyMethodChunk = chunk.metadata.language === 'ruby'
+      && (chunk.metadata.chunk_type === 'method'
+        || chunk.metadata.chunk_type === 'singleton_method');
+    const hasOnlySelfScope = scopeChain
+      && scopeChain.length === 1
+      && scopeChain[0] === chunk.metadata.symbol
+      && !chunk.metadata.parent_symbol;
+
+    if (scopeChain && scopeChain.length > 0 && !(isRubyMethodChunk && hasOnlySelfScope)) {
+      parts.push(`# Scope: ${scopeChain.join(' > ')}`);
+    } else if (chunk.metadata.parent_symbol) {
+      // Preserve cAST parent context when no scope chain from code graph
+      parts.push(`# Parent: ${chunk.metadata.parent_type} ${chunk.metadata.parent_symbol}`);
+    }
+    // Keep Ruby method metadata, but avoid injecting the method name into
+    // the production embedding/LI text. Top-level Ruby method chunks also
+    // skip self-only scope above.
+    if (chunk.metadata.symbol && chunk.metadata.symbol !== 'unknown' && !isRubyMethodChunk) {
+      parts.push(`# Defines: ${chunk.metadata.chunk_type} ${chunk.metadata.symbol}`);
+    }
 
     if (chunk.metadata.additional_symbols && chunk.metadata.additional_symbols.length > 0) {
       parts.push(`# Additional: ${chunk.metadata.additional_symbols.join(', ')}`);

package/core/indexing/index-maintainer.mjs

@@ -1267,12 +1267,14 @@ async function runReconcileV2Main({ runOnce, merkleOnce }) {
   // Best-effort — never block startup on the embedding module.
   if (process.env.SWEET_SEARCH_ORT_BACKGROUND !== '0') {
     try {
-      const [{ configureLocalModelRuntime }, { backgroundIntraOpThreads }] = await Promise.all([
-        import('../embedding/embedding-local-model.js'),
-        import('../infrastructure/onnx-session-utils.js'),
-      ]);
-      configureLocalModelRuntime({ intraOpThreads: backgroundIntraOpThreads(), background: true });
-      log('INFO', 'ORT background profile armed for maintainer daemon (force_spinning_stop + arena-off + bg threads)');
+      // Arms BOTH resident CPU sessions (dense + late-interaction) — the LI
+      // session previously stayed on the foreground profile (arena ON +
+      // allow_spinning) inside the daemon; measured consequence: 354 × 128MB
+      // arena extensions (~34GB RSS) after one edit-heavy day plus ~40% idle
+      // CPU from spinning workers.
+      const { armBackgroundOrtProfiles } = await import('./model-pool.js');
+      armBackgroundOrtProfiles();
+      log('INFO', 'ORT background profile armed for maintainer daemon (dense + LI: force_spinning_stop + arena-off + bg threads)');
     } catch (err) {
       log('WARN', `ORT background profile arming failed (continuing on foreground profile): ${err?.message ?? err}`);
     }
@@ -1314,15 +1316,30 @@ async function runReconcileV2Main({ runOnce, merkleOnce }) {
   // system-RAM tier auto-enables a cap (small-RAM hosts). Best-effort, guarded
   // so a missing module is a no-op.
   let rssRegistration = null;
+  // D.5 per-process recycle ceiling: fleet-budget eviction only sheds the
+  // longest-IDLE daemon, so an active maintainer needs its own line. Resolved
+  // once; checked at tick boundaries below. 0 ⇒ disabled.
+  let rssCeiling = { ceilingBytes: 0, minUptimeMs: 0, shouldRecycleForRss: null };
   try {
     const mod = await import('./rss-budget.mjs');
     if (typeof mod.isEnabled === 'function' && mod.isEnabled()
         && typeof mod.registerDaemon === 'function') {
       rssRegistration = await mod.registerDaemon({ pid: process.pid, stateDir: ctx.stateDir, kind: 'maintainer' });
     }
+    if (typeof mod.maintainerRssCeilingBytes === 'function') {
+      rssCeiling = {
+        ceilingBytes: mod.maintainerRssCeilingBytes(),
+        minUptimeMs: mod.maintainerRssMinUptimeMs(),
+        shouldRecycleForRss: mod.shouldRecycleForRss,
+      };
+      if (rssCeiling.ceilingBytes > 0) {
+        log('INFO', `Maintainer RSS recycle ceiling armed: ${(rssCeiling.ceilingBytes / 1048576).toFixed(0)}MB (min uptime ${rssCeiling.minUptimeMs}ms; override SWEET_SEARCH_MAINTAINER_RSS_MAX_MB)`);
+      }
+    }
   } catch (err) {
     log('WARN', `RSS-budget registry unavailable (no soft cap on this daemon): ${err?.message ?? err}`);
   }
+  let completedTicks = 0;
 
   // D.1 idle-TTL: an unattended maintainer self-shuts-down after the configured
   // wall-clock idle budget so N resident model-loaded daemons collapse to 1–2
@@ -1432,6 +1449,23 @@ async function runReconcileV2Main({ runOnce, merkleOnce }) {
             maintenanceBacklog: backlog,
             skipped: tickCounters?.skipped === true,
           });
+          // D.5: per-process RSS recycle check — tick boundary only (the tick
+          // above has published; a recycle here can never tear an artifact).
+          completedTicks += 1;
+          if (rssCeiling.ceilingBytes > 0 && typeof rssCeiling.shouldRecycleForRss === 'function') {
+            const rssNow = process.memoryUsage.rss();
+            const verdict = rssCeiling.shouldRecycleForRss({
+              rssBytes: rssNow,
+              ceilingBytes: rssCeiling.ceilingBytes,
+              uptimeMs: process.uptime() * 1000,
+              minUptimeMs: rssCeiling.minUptimeMs,
+              ticksCompleted: completedTicks,
+            });
+            if (verdict.recycle) {
+              log('WARN', `Maintainer RSS ${(rssNow / 1048576).toFixed(0)}MB exceeds recycle ceiling ${(rssCeiling.ceilingBytes / 1048576).toFixed(0)}MB; requesting clean shutdown for on-demand respawn. If this repeats right after startup, raise SWEET_SEARCH_MAINTAINER_RSS_MAX_MB.`);
+              shutdownRequested = true;
+            }
+          }
         } catch (err) {
           if (err instanceof MaintainerLifecycleAbort) {
             log('WARN', `Reconcile v2 lifecycle abort: ${err.message}. Cleaning up cancellation-orphaned temps and exiting cleanly.`);
@@ -1457,6 +1491,10 @@ async function runReconcileV2Main({ runOnce, merkleOnce }) {
           log('ERROR', `Reconcile v2 tick failed: ${err?.message ?? err}`);
         }
       }
+      // Skip the sleep when a shutdown was requested during this iteration
+      // (idle-TTL, signal, or D.5 RSS recycle) — exit promptly instead of
+      // waiting out one more interval.
+      if (shutdownRequested) break;
       await sleepWithProgress(intervalMs, lock.lockFile, {
         // G6 early-wake: break the sleep the instant the watcher reports new
         // events so a fresh edit is reconciled without waiting out the interval.
@@ -2482,6 +2520,11 @@ async function main() {
   const dryRun = process.argv.includes('--dry-run');
   const merkleOnce = process.argv.includes('--merkle-once');
 
+  // Name the resident daemon so ps/Activity Monitor shows what it is instead
+  // of an anonymous `node`. Cosmetic-only: all liveness/takeover checks are
+  // lock/pid-based, never command-line matching.
+  try { process.title = 'sweet-search-maintainer'; } catch { /* best-effort */ }
+
   // A.1 (Tier-1, UNGATED): demote the maintainer daemon to low OS priority so
   // the foreground (editor / git / shell) never feels the background indexer's
   // CPU. Identical index output — only *when* CPU is granted changes. Covers