sweet-search 2.5.4 → 2.5.6

package/assets/banner/banner-manifest.json

@@ -0,0 +1,10 @@
+{
+  "format": "grid-webp",
+  "file": "banner-frames.webp",
+  "gridCols": 8,
+  "cellW": 1200,
+  "cellH": 400,
+  "count": 96,
+  "fps": 12,
+  "frameMs": 83
+}

package/core/banner/render-banner.js

@@ -0,0 +1,209 @@
+/**
+ * Animated terminal banner — universal renderer.
+ *
+ * Decodes the pre-baked lossless WebP sprite-sheet (assets/banner/) once with sharp,
+ * then animates it via the best path the terminal supports:
+ *
+ *   Kitty graphics  (Ghostty, kitty, WezTerm, Konsole)        — pixel-perfect
+ *   iTerm2 inline   (iTerm.app)                                — pixel-perfect
+ *   Sixel           (Windows Terminal, Konsole, xterm, foot…) — crisp raster
+ *   half-blocks     (everything else: Apple Terminal, VS Code, SSH, CI-tty) — truecolor ▀
+ *
+ * Zero prerequisites for users: the only dependency is sharp (already a package dep,
+ * auto-installed per-platform by npm). Chrome is used ONLY at bake time (scripts/bake-banner.mjs).
+ *
+ * Safe by construction: renders only to an interactive TTY, never throws, honours
+ * NO_BANNER / SWEET_SEARCH_NO_BANNER / CI, and leaves the final frame in place when done.
+ */
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { encodeSixelFrame, buildPalette, makeMapper, sampleColors } from './sixel.js';
+
+const require = createRequire(import.meta.url);
+
+const ASSET_DIR = join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'assets', 'banner');
+const ESC = '\x1b', BEL = '\x07', ST = ESC + '\\';
+const SYNC_ON = `${ESC}[?2026h`, SYNC_OFF = `${ESC}[?2026l`;
+const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+
+// ---------------- gating ----------------
+function shouldRender(stream, env) {
+  if (env.SWEET_SEARCH_NO_BANNER || env.NO_BANNER) return false;
+  if (env.CI) return false;
+  if (!stream || !stream.isTTY) return false;
+  if ((env.TERM || '') === 'dumb') return false;
+  return true;
+}
+
+// ---------------- terminal capability query (DA1 + text-area size) ----------------
+function queryTerminal(stream, env, timeout = 140) {
+  return new Promise((resolve) => {
+    const stdin = process.stdin;
+    if (env.SS_NO_QUERY || !stdin || !stdin.isTTY) { resolve({}); return; }
+    let buf = '', done = false, t;
+    const finish = () => {
+      if (done) return; done = true;
+      try { stdin.removeListener('data', onData); stdin.setRawMode(false); stdin.pause(); } catch { /* noop */ }
+      clearTimeout(t);
+      const da1 = (buf.match(/\x1b\[\?([0-9;]+)c/) || [])[1] || '';
+      const size = buf.match(/\x1b\[4;(\d+);(\d+)t/);
+      resolve({ sixel: da1.split(';').includes('4'), areaH: size ? +size[1] : 0, areaW: size ? +size[2] : 0 });
+    };
+    const onData = (d) => { buf += d.toString('latin1'); if (/\x1b\[\?[0-9;]+c/.test(buf) && (/\x1b\[4;\d+;\d+t/.test(buf) || buf.length > 64)) finish(); };
+    try { stdin.setRawMode(true); stdin.resume(); stdin.on('data', onData); } catch { resolve({}); return; }
+    stream.write(`${ESC}[14t${ESC}[c`);     // text-area pixel size, then primary device attributes
+    t = setTimeout(finish, timeout);
+  });
+}
+
+function detectProto(env, caps) {
+  if (env.SS_PROTO) return env.SS_PROTO;
+  const tp = env.TERM_PROGRAM || '';
+  if (env.KITTY_WINDOW_ID || env.GHOSTTY_RESOURCES_DIR || tp === 'ghostty' || tp === 'WezTerm' || /kitty/i.test(env.TERM || '')) return 'kitty';
+  if (tp === 'iTerm.app') return 'iterm';
+  if (caps.sixel || env.WT_SESSION || /foot|contour|mlterm/i.test(env.TERM || '')) return 'sixel';
+  return 'blocks';
+}
+
+// ---------------- color (truecolor default; 256 fallback) ----------------
+function rgb256(r, g, b) {
+  if (Math.abs(r - g) < 10 && Math.abs(g - b) < 10) { if (r < 8) return 16; if (r > 248) return 231; return 232 + Math.round(((r - 8) / 247) * 24); }
+  return 16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5);
+}
+const GHALF = [' ', '▀', '▄', '█'];
+function sextantChar(v) {
+  if (v === 0) return ' '; if (v === 63) return '█'; if (v === 21) return '▌'; if (v === 42) return '▐';
+  return String.fromCodePoint(0x1FB00 + (v - 1 - (v > 21 ? 1 : 0) - (v > 42 ? 1 : 0)));
+}
+
+// ---------------- main ----------------
+export async function showBanner(opts = {}) {
+  const env = opts.env || process.env;
+  const out = opts.stream || process.stdout;
+  let onSig = null;
+  try {
+    if (!shouldRender(out, env)) return false;
+
+    const sharp = require('sharp');
+    const man = JSON.parse(readFileSync(join(ASSET_DIR, 'banner-manifest.json'), 'utf8'));
+    const { gridCols: GC, cellW: CW, cellH: CH, count: N, frameMs } = man;
+    const maxMs = opts.maxMs ?? Number(env.SS_BANNER_MS || 2600);
+    const color = opts.color || env.SS_COLOR || 'truecolor';
+    const cellMode = opts.cells || env.SS_CELLS || 'half';
+
+    const caps = opts.query === false ? {} : await queryTerminal(out, env);
+    const proto = opts.proto || detectProto(env, caps);
+    const capCols = Number(opts.cols || env.SS_COLS || 120);
+    const cols = Math.max(20, Math.min((out.columns || 80) - 2, capCols));
+
+    // decode the sprite sheet once
+    const { data: big, info } = await sharp(join(ASSET_DIR, man.file)).raw().toBuffer({ resolveWithObject: true });
+    const BW = info.width, ch = info.channels;
+    const frameRaw = (i) => {
+      const gx = (i % GC) * CW, gy = Math.floor(i / GC) * CH, f = Buffer.allocUnsafe(CW * CH * 4);
+      for (let y = 0; y < CH; y++) { const so = ((gy + y) * BW + gx) * ch; big.copy(f, y * CW * 4, so, so + CW * 4); }
+      return f;
+    };
+
+    const fg = color === '256' ? (r, g, b) => `${ESC}[38;5;${rgb256(r, g, b)}m` : (r, g, b) => `${ESC}[38;2;${r};${g};${b}m`;
+    const bg = color === '256' ? (r, g, b) => `${ESC}[48;5;${rgb256(r, g, b)}m` : (r, g, b) => `${ESC}[48;2;${r};${g};${b}m`;
+    const RESET = `${ESC}[0m`;
+
+    // ---------------- per-protocol lazy frame builder (build only frames we show) ----------------
+    let renderRows = Math.max(4, Math.round(cols / 6));
+    const cache = new Map();
+    let buildOne;
+
+    if (proto === 'kitty' || proto === 'iterm') {
+      buildOne = async (i) => (await sharp(frameRaw(i), { raw: { width: CW, height: CH, channels: 4 } }).png().toBuffer()).toString('base64');
+    } else if (proto === 'sixel') {
+      const cellWpx = caps.areaW && out.columns ? caps.areaW / out.columns : 8;
+      const Wp = Math.min(1000, Math.max(360, Math.round(cols * cellWpx)));
+      const Hp = Math.round(Wp / 3);
+      const cellHpx = caps.areaH && out.rows ? caps.areaH / out.rows : 16;
+      renderRows = Math.max(4, Math.round(Hp / cellHpx));
+      const sixelPx = async (i) => (await sharp(frameRaw(i), { raw: { width: CW, height: CH, channels: 4 } }).resize(Wp, Hp, { fit: 'fill' }).raw().toBuffer());
+      // global palette from 2 representative frames (colours are stable across the loop)
+      const samp = [...sampleColors(await sixelPx(0), 9), ...sampleColors(await sixelPx((N / 2) | 0), 9)];
+      const palette = buildPalette(samp, 255), mapper = makeMapper(palette);
+      buildOne = async (i) => encodeSixelFrame(await sixelPx(i), Wp, Hp, palette, mapper);
+    } else {
+      const [sc, sr] = cellMode === 'sextant' ? [2, 3] : [1, 2];
+      const R = Math.max(3, Math.round((cols * sc) * CH / CW / sr)); renderRows = R;
+      const W = cols * sc, H = R * sr;
+      const glyph = cellMode === 'sextant' ? sextantChar : (v) => GHALF[v];
+      buildOne = async (i) => {
+        const { data: px } = await sharp(frameRaw(i), { raw: { width: CW, height: CH, channels: 4 } }).resize(W, H, { fit: 'fill', kernel: 'lanczos3' }).sharpen({ sigma: 0.7 }).raw().toBuffer({ resolveWithObject: true });
+        let s = '';
+        for (let cy = 0; cy < R; cy++) {
+          for (let cx = 0; cx < cols; cx++) {
+            const sub = []; let anyT = false, anyO = false;
+            for (let y = 0; y < sr; y++) for (let x = 0; x < sc; x++) { const o = ((cy * sr + y) * W + (cx * sc + x)) * 4, a = px[o + 3]; sub.push({ r: px[o], g: px[o + 1], b: px[o + 2], a }); if (a < 128) anyT = true; else anyO = true; }
+            if (!anyO) { s += RESET + ' '; continue; }
+            const op = sub.filter(p => p.a >= 128), lum = p => 0.299 * p.r + 0.587 * p.g + 0.114 * p.b;
+            let lo = op[0], hi = op[0];
+            for (const p of op) { if (lum(p) < lum(lo)) lo = p; if (lum(p) > lum(hi)) hi = p; }
+            const dist = (p, q) => (p.r - q.r) ** 2 + (p.g - q.g) ** 2 + (p.b - q.b) ** 2;
+            let fr = 0, fG = 0, fb = 0, fn = 0, br = 0, bG = 0, bb = 0, bn = 0, bits = 0;
+            for (let k = 0; k < sub.length; k++) { const p = sub[k]; if (p.a < 128) continue; if (dist(p, hi) <= dist(p, lo)) { bits |= (1 << k); fr += p.r; fG += p.g; fb += p.b; fn++; } else { br += p.r; bG += p.g; bb += p.b; bn++; } }
+            const fc = fn ? [Math.round(fr / fn), Math.round(fG / fn), Math.round(fb / fn)] : null;
+            const bc = bn ? [Math.round(br / bn), Math.round(bG / bn), Math.round(bb / bn)] : null;
+            const full = (1 << sub.length) - 1;
+            if (anyT) s += bits === 0 ? RESET + ' ' : RESET + fg(...(fc || bc)) + glyph(bits);
+            else if (bits === 0) s += bg(...bc) + ' ';
+            else if (bits === full) s += fg(...fc) + glyph(bits);
+            else s += bg(...bc) + fg(...fc) + glyph(bits);
+          }
+          s += RESET; if (cy < R - 1) s += '\r\n';
+        }
+        return s;
+      };
+    }
+    const getFrame = async (i) => { let v = cache.get(i); if (v === undefined) { v = await buildOne(i); cache.set(i, v); } return v; };
+
+    // ---------------- emit / animate (bounded) ----------------
+    const CHUNK = 4096;
+    const kittyFrame = (b64, id) => {
+      if (b64.length <= CHUNK) { out.write(`${ESC}_Gf=100,a=T,q=2,c=${cols},C=1,i=${id};${b64}${ST}`); return; }
+      for (let i = 0; i < b64.length; i += CHUNK) { const piece = b64.slice(i, i + CHUNK), more = i + CHUNK < b64.length ? 1 : 0; out.write(i === 0 ? `${ESC}_Gf=100,a=T,q=2,c=${cols},C=1,i=${id},m=1;${piece}${ST}` : `${ESC}_Gm=${more};${piece}${ST}`); }
+    };
+    const kittyDel = (id) => out.write(`${ESC}_Ga=d,d=i,i=${id},q=2${ST}`);
+
+    await getFrame(0);                    // build first frame before clearing space (hide latency)
+    out.write(ESC + '[?25l');
+    // Restore the cursor if interrupted mid-animation (else Ctrl-C leaves it hidden).
+    onSig = () => { try { out.write(`${ESC}[0m${ESC}[?25h`); } catch { /* noop */ } process.exit(130); };
+    process.once('SIGINT', onSig);
+    if (proto === 'blocks' || proto === 'sixel') { for (let r = 0; r < renderRows; r++) out.write('\n'); out.write(`${ESC}[${renderRows}A`); }
+    else out.write('\n');
+    out.write(ESC + '7');
+
+    let prevId = 0, flip = 1;
+    const start = Date.now();
+    let i = 0;
+    while (Date.now() - start < maxMs) {
+      const frame = await getFrame(i);
+      out.write(SYNC_ON + ESC + '8');
+      if (proto === 'kitty') { const id = flip; kittyFrame(frame, id); if (prevId) kittyDel(prevId); prevId = id; flip = flip === 1 ? 2 : 1; }
+      else if (proto === 'iterm') out.write(`${ESC}]1337;File=inline=1;width=${cols};height=${renderRows};preserveAspectRatio=1:${frame}${BEL}`);
+      else out.write(frame);
+      out.write(SYNC_OFF);
+      await sleep(frameMs);
+      i = (i + 1) % N;
+    }
+    out.write(ESC + '8');                 // settle: leave final frame, move below
+    out.write('\n'.repeat(renderRows + 1));
+    out.write(RESET + ESC + '[?25h');
+    if (onSig) process.removeListener('SIGINT', onSig);   // hand Ctrl-C back to the caller
+    return true;
+  } catch (err) {
+    if (onSig) process.removeListener('SIGINT', onSig);
+    if (env.SS_BANNER_DEBUG) process.stderr.write(`[banner] ${err && err.stack || err}\n`);
+    try { out.write(`${ESC}[0m${ESC}[?25h`); } catch { /* noop */ }
+    return false;
+  }
+}
+
+export default showBanner;

package/core/banner/sixel.js

@@ -0,0 +1,126 @@
+/**
+ * Minimal, dependency-free Sixel encoder for the terminal banner.
+ *
+ * Sixel renders crisp raster images on Windows Terminal (>=1.22), Konsole, xterm,
+ * foot, Contour and much of Linux — terminals that lack the Kitty graphics protocol.
+ *
+ * We build ONE shared palette across all frames (pixel art reuses colours, so a global
+ * palette is both faster and lets frames share colour definitions) and emit each frame
+ * with run-length-encoded sixel bands. Fully-transparent pixels are left unset so the
+ * terminal background shows through (rounded banner corners).
+ */
+
+const TRANSPARENT = -1;
+
+function boxStats(box) {
+  let rMin = 255, rMax = 0, gMin = 255, gMax = 0, bMin = 255, bMax = 0;
+  for (const [r, g, b] of box) {
+    if (r < rMin) rMin = r; if (r > rMax) rMax = r;
+    if (g < gMin) gMin = g; if (g > gMax) gMax = g;
+    if (b < bMin) bMin = b; if (b > bMax) bMax = b;
+  }
+  const dr = rMax - rMin, dg = gMax - gMin, db = bMax - bMin;
+  const range = Math.max(dr, dg, db);
+  const channel = range === dr ? 0 : range === dg ? 1 : 2;
+  return { range, channel };
+}
+function avgColor(box) {
+  let r = 0, g = 0, b = 0;
+  for (const c of box) { r += c[0]; g += c[1]; b += c[2]; }
+  const n = box.length || 1;
+  return [Math.round(r / n), Math.round(g / n), Math.round(b / n)];
+}
+
+/** Median-cut quantisation over a sample of opaque colours. Returns up to maxColors [r,g,b]. */
+export function buildPalette(samples, maxColors = 255) {
+  if (samples.length === 0) return [[0, 0, 0]];
+  let boxes = [samples];
+  while (boxes.length < maxColors) {
+    let bi = -1, best = -1;
+    for (let i = 0; i < boxes.length; i++) {
+      if (boxes[i].length < 2) continue;
+      const { range } = boxStats(boxes[i]);
+      if (range > best) { best = range; bi = i; }
+    }
+    if (bi < 0) break;
+    const box = boxes[bi];
+    const { channel } = boxStats(box);
+    box.sort((a, b) => a[channel] - b[channel]);
+    const mid = box.length >> 1;
+    boxes.splice(bi, 1, box.slice(0, mid), box.slice(mid));
+  }
+  return boxes.map(avgColor);
+}
+
+/** Fast rgb->palette-index mapper with a per-colour cache (pixel art has few unique colours). */
+export function makeMapper(palette) {
+  const cache = new Map();
+  return (r, g, b) => {
+    const key = (r << 16) | (g << 8) | b;
+    const hit = cache.get(key);
+    if (hit !== undefined) return hit;
+    let best = 0, bestD = Infinity;
+    for (let i = 0; i < palette.length; i++) {
+      const p = palette[i];
+      const d = (p[0] - r) ** 2 + (p[1] - g) ** 2 + (p[2] - b) ** 2;
+      if (d < bestD) { bestD = d; best = i; }
+    }
+    cache.set(key, best);
+    return best;
+  };
+}
+
+/** Collect a colour sample from a raw RGBA frame (every `step`-th opaque pixel). */
+export function sampleColors(rgba, step = 7) {
+  const out = [];
+  for (let i = 0; i < rgba.length; i += 4 * step) {
+    if (rgba[i + 3] >= 128) out.push([rgba[i], rgba[i + 1], rgba[i + 2]]);
+  }
+  return out;
+}
+
+/** Encode one RGBA frame to a Sixel string using a shared palette + mapper. */
+export function encodeSixelFrame(rgba, width, height, palette, mapper) {
+  // index buffer: palette index per pixel, or TRANSPARENT
+  const idx = new Int16Array(width * height);
+  for (let p = 0, o = 0; p < idx.length; p++, o += 4) {
+    idx[p] = rgba[o + 3] < 128 ? TRANSPARENT : mapper(rgba[o], rgba[o + 1], rgba[o + 2]);
+  }
+
+  let s = '\x1bP0;1;0q';                 // DCS; P2=1 => 0-bit pixels stay transparent
+  s += `"1;1;${width};${height}`;        // raster attributes (1:1 aspect)
+  for (let i = 0; i < palette.length; i++) {
+    const [r, g, b] = palette[i];
+    s += `#${i};2;${Math.round(r / 255 * 100)};${Math.round(g / 255 * 100)};${Math.round(b / 255 * 100)}`;
+  }
+
+  const used = [];
+  for (let by = 0; by < height; by += 6) {
+    const bandH = Math.min(6, height - by);
+    // which palette indices appear in this band
+    used.length = 0;
+    const seen = new Set();
+    for (let y = by; y < by + bandH; y++) {
+      const row = y * width;
+      for (let x = 0; x < width; x++) { const c = idx[row + x]; if (c !== TRANSPARENT && !seen.has(c)) { seen.add(c); used.push(c); } }
+    }
+    for (let u = 0; u < used.length; u++) {
+      const ci = used[u];
+      if (u > 0) s += '$';               // return to band start, overlay next colour
+      s += `#${ci}`;
+      let runChar = -1, runLen = 0, line = '';
+      for (let x = 0; x < width; x++) {
+        let bits = 0;
+        for (let k = 0; k < bandH; k++) if (idx[(by + k) * width + x] === ci) bits |= (1 << k);
+        const ch = 63 + bits;
+        if (ch === runChar) { runLen++; }
+        else { if (runLen) line += runLen > 3 ? `!${runLen}${String.fromCharCode(runChar)}` : String.fromCharCode(runChar).repeat(runLen); runChar = ch; runLen = 1; }
+      }
+      if (runLen) line += runLen > 3 ? `!${runLen}${String.fromCharCode(runChar)}` : String.fromCharCode(runChar).repeat(runLen);
+      s += line;
+    }
+    s += '-';                            // graphics newline
+  }
+  s += '\x1b\\';                         // ST
+  return s;
+}

package/core/indexing/index-codebase-v21.js

@@ -121,6 +121,11 @@ async function main() {
     setVerboseMode(true);
   }
 
+  // Animated banner (best-effort; interactive TTY only, never in CI / quiet / stdin-fed runs).
+  if (!quiet && !help && !filesFromStdin && process.stdout.isTTY && !process.env.CI && !process.env.NO_BANNER && !process.env.SWEET_SEARCH_NO_BANNER) {
+    try { const { showBanner } = await import('../banner/render-banner.js'); await showBanner(); } catch { /* non-fatal */ }
+  }
+
   // Apply late interaction model overrides before any model code runs.
   // Precedence: --no-late-interaction > --late-interaction-model=… > env
   // var (already honoured by LATE_INTERACTION_CONFIG.model at module load) >

package/core/indexing/indexer-ann.js

@@ -650,7 +650,7 @@ export async function buildHNSWIndex(dbPath, dryRun = false) {
             });
             fsyncFile(sidecarPath);
             fsyncDirectory(path.dirname(checkpointPath));
-            log(`  checkpoint: ${added}/${totalVectors} vectors`, 'dim');
+            if (process.env.DEBUG) log(`  checkpoint: ${added}/${totalVectors} vectors`, 'dim');
           }
           lastCheckpointTime = Date.now();
           vectorsSinceCheckpoint = 0;

package/core/indexing/indexer-utils.js

@@ -109,32 +109,64 @@ export function isVerboseMode() {
   return verboseMode;
 }
 
+// ---------------------------------------------------------------------------
+// Progress rendering — an in-place "sticky" bar that animates as a phase runs.
+//
+// On a TTY (verbose or not) the bar redraws on a single line via carriage return
+// + erase-to-EOL, with smooth 1/8-block fill. While a bar is active, log() pins it:
+// it clears the bar, prints the log line above, then redraws the bar below — so
+// interleaved diagnostics (e.g. the HNSW "checkpoint:" line) never split the bar.
+// Non-TTY (pipes / CI) falls back to throttled newlines so nothing is swallowed.
+// ---------------------------------------------------------------------------
+const BAR_WIDTH = 30;
+const LABEL_COL = 17;           // pad "Label:" to this width so every bar's [ ] aligns
+const SUB_BLOCKS = ['', '▏', '▎', '▍', '▌', '▋', '▊', '▉']; // eighth-block partial fills
+const CLEAR_EOL = '\x1b[K';
+let activeBar = null;           // last-rendered bar string while a phase is in progress (TTY only)
+let lastLoggedPercent = {};
+
+function renderBar(current, total, label) {
+  const ratio = total > 0 ? Math.max(0, Math.min(1, current / total)) : 1;
+  const eighths = Math.round(ratio * BAR_WIDTH * 8);
+  const full = Math.floor(eighths / 8);
+  const partial = SUB_BLOCKS[eighths % 8];
+  const bar = '█'.repeat(full) + partial;
+  const empty = '░'.repeat(Math.max(0, BAR_WIDTH - full - (partial ? 1 : 0)));
+  const head = `${label}:`.padEnd(LABEL_COL);            // right border aligns across phases
+  const pct = (ratio * 100).toFixed(1).padStart(5);
+  return `${colors.cyan}${head}[${bar}${empty}] ${pct}% (${current}/${total})${colors.reset}`;
+}
+
 export function log(message, color = 'reset') {
   if (quietMode) return;
-  console.log(`${colors[color]}${message}${colors.reset}`);
+  const line = `${colors[color]}${message}${colors.reset}`;
+  if (activeBar && process.stdout.isTTY) {
+    // Pin the bar: clear it, print the log line above, redraw the bar below.
+    process.stdout.write(`\r${CLEAR_EOL}${line}\n${activeBar}${CLEAR_EOL}`);
+  } else {
+    console.log(line);
+  }
 }
 
-let lastLoggedPercent = {};
-
 export function logProgress(current, total, label) {
   if (quietMode) return;
-  const percentNum = (current / total) * 100;
-  const percent = percentNum.toFixed(1);
-  const bar = '█'.repeat(Math.floor(current / total * 30));
-  const empty = '░'.repeat(30 - bar.length);
-  // In verbose mode or non-TTY, use newlines so output isn't swallowed by pipes.
-  // Throttle to every ~2% to avoid flooding.
-  if (verboseMode || !process.stdout.isTTY) {
+  if (!process.stdout.isTTY) {
+    // Pipes / CI: throttle to ~2% and emit newlines so output isn't swallowed.
+    const percentNum = total > 0 ? (current / total) * 100 : 100;
     const lastPct = lastLoggedPercent[label] || 0;
-    if (percentNum - lastPct >= 2 || current === total || current <= 1) {
+    if (percentNum - lastPct >= 2 || current >= total || current <= 1) {
       lastLoggedPercent[label] = percentNum;
-      console.log(`${colors.cyan}${label}: [${bar}${empty}] ${percent}% (${current}/${total})${colors.reset}`);
-    }
-  } else {
-    process.stdout.write(`\r${colors.cyan}${label}: [${bar}${empty}] ${percent}% (${current}/${total})${colors.reset}`);
-    if (current === total) {
-      process.stdout.write('\n');
+      console.log(renderBar(current, total, label));
     }
+    return;
+  }
+  // Interactive TTY: animate the bar in place.
+  activeBar = renderBar(current, total, label);
+  process.stdout.write(`\r${activeBar}${CLEAR_EOL}`);
+  if (current >= total) {
+    process.stdout.write('\n');
+    activeBar = null;
+    lastLoggedPercent[label] = 0;
   }
 }
 

package/core/infrastructure/simd-distance.js

@@ -72,12 +72,17 @@ async function initWasm() {
 
       initDone = true;
 
-      if (nativeMaxsim) {
-        console.error('[MaxSim] Tier 1: Native Rust + Rayon (parallel SIMD)');
-      } else if (maxsimExports || wasmExports?.maxsim_f32) {
-        console.error('[MaxSim] Tier 2: WASM SIMD f32x4');
-      } else {
-        console.error('[MaxSim] Tier 3: JS fallback');
+      // Load-time tier diagnostic — gated behind DEBUG so it doesn't precede the
+      // banner / clutter normal output (the active tier is also shown in `init`'s
+      // summary as "MaxSim: …"). Set DEBUG=1 to surface it.
+      if (process.env.DEBUG) {
+        if (nativeMaxsim) {
+          console.error('[MaxSim] Tier 1: Native Rust + Rayon (parallel SIMD)');
+        } else if (maxsimExports || wasmExports?.maxsim_f32) {
+          console.error('[MaxSim] Tier 2: WASM SIMD f32x4');
+        } else {
+          console.error('[MaxSim] Tier 3: JS fallback');
+        }
       }
 
       return true;

package/core/search/context-expander.js

@@ -1677,8 +1677,17 @@ function resolveSubMode(format) {
 // space, and small-N entropy is dominated by the 1/log(n) denominator and
 // stops being a reliable distribution-width signal.
 
+// Preview-tier budget: 3000 (was 4000 until 2026-06-11). The 4-model budget
+// sweep (DeepSeek/MiMo/GPT-5.5-codex/Opus-CC, 12 dev probes, paired vs 4k)
+// found 3k keeps every accuracy/usefulness metric flat-to-up with zero
+// call-compensation, and cuts realized cost −11–15% on the flagship cells.
+// Below 3k, flagship models re-buy the trimmed context with extra calls
+// (Opus calls Δ: 3k −0.08 → 2.8k +0.33 → 2.5k +0.67 → 2k +0.83), erasing
+// the savings — 3k is the floor. SWEET_SEARCH_PREVIEW_BUDGET overrides for
+// experiments; full/xl escalation tiers are unchanged.
+const PREVIEW_TIER_BUDGET = Number(process.env.SWEET_SEARCH_PREVIEW_BUDGET || '') || 3000;
 const BUDGET_TIERS = {
-  preview: { subMode: 'agent_preview', budget: 4000 },
+  preview: { subMode: 'agent_preview', budget: PREVIEW_TIER_BUDGET },
   full:    { subMode: 'agent_full',    budget: 8000 },
   xl:      { subMode: 'agent_full_xl', budget: 12000 },
 };

package/core/search/search-cli.js

@@ -52,7 +52,7 @@ Options:
   --fusion <type>   Legacy: cc or rrf (ignored for hybrid - always uses robust CC fusion)
   --late-interaction Enable late interaction reranking (if index available)
   --late-interaction-model=ID Use specific model (lateon-code or lateon-code-edge)
-  --agent           Agent mode: self-contained code blocks. Auto-picks 4k/8k/12k
+  --agent           Agent mode: self-contained code blocks. Auto-picks 3k/8k/12k
                     tier from score-distribution signals (top-1 dominance,
                     entropy, candidate-pool breadth) — no need to choose a tier.
   --agent-preview   Force the 4k preview tier (rarely needed; --agent auto-picks)

package/core/search/search-pattern-planner.js

@@ -268,7 +268,7 @@ export async function generateRegexMatches(searcher, regex, searchDir, options =
     const literalStart = performance.now();
 
     const sparseForPrefilter = globs.length === 0 ? ensureSparseGramIndex(searcher, options) : null;
-    const prefilterFiles = sparseForPrefilter ? getSparseGramAllFiles(sparseForPrefilter) : null;
+    const prefilterFiles = sparseForPrefilter ? getSparseGramAllFilesWithOverlay(searcher, sparseForPrefilter, options) : null;
 
     if (prefilterFiles && prefilterFiles.length > 0) {
       const combined = new Set();

package/core/search/search-trace.js

@@ -83,7 +83,7 @@ Options:
   --in <file>       Disambiguate symbols by indexed file path
   --query <hint>    Natural-language hint used only for structural ranking
   --depth <n>       Impact depth, 1-4 (default: 3)
-  --budget <n>      Token budget, 1000-16000 (default: adaptive 4k/8k/12k)
+  --budget <n>      Token budget, 1000-16000 (default: adaptive 3k/8k/12k)
   --json            Output structured JSON
   --format <fmt>    plain (no banner) or json
   --no-banner       Suppress the identity line

package/eval/agent-read-workflows/bin/_ss-helpers.mjs

@@ -126,6 +126,9 @@ async function cmdFind(args) {
     process.stderr.write('Usage: ss-find "<query>" --regex "<regex>" [--full|--xl] [-k N]\n');
     process.exit(2);
   }
+  // Budget-sweep experiment hook: lets the bench pin the response token budget
+  // per-process without changing the agent-visible tool surface.
+  const envFindBudget = Number(process.env.SS_SMOKE_FIND_BUDGET || '') || null;
   const effectiveRegex = regex || '';
   const s = await getSweetSearch();
   if (!s.hasLateInteractionIndex) {
@@ -136,6 +139,7 @@ async function cmdFind(args) {
     regex: effectiveRegex || `\\b\\w+\\b`,
     k,
     format,
+    ...(envFindBudget ? { tokenBudget: envFindBudget } : {}),
   });
 
   // Header (visible to agent)
@@ -212,7 +216,7 @@ async function cmdAgentSearch(args) {
   // Main sweet-search auto/CatBoost search with token-budgeted agent packaging.
   //
   // Usage:
-  //   ss-search "<query>"                                  → format=agent (auto-pick 4k/8k/12k)
+  //   ss-search "<query>"                                  → format=agent (auto-pick 3k/8k/12k)
   //   ss-search "<query>" --full                           → force 8k (rarely needed; default auto-picks)
   //   ss-search "<query>" --xl                             → force 12k (rarely needed; default auto-picks)
   //   ss-search "<query>" -k 5                             → top-K results
@@ -240,7 +244,10 @@ async function cmdAgentSearch(args) {
     process.exit(1);
   }
 
-  const response = await queryServer(query, { topK: k, mode, format });
+  // Budget-sweep experiment hook: per-request explicit budget (overrides the
+  // auto-tier on the warm server; flows as the `budget` URL param).
+  const envSearchBudget = Number(process.env.SS_SMOKE_SEARCH_BUDGET || '') || null;
+  const response = await queryServer(query, { topK: k, mode, format, ...(envSearchBudget ? { tokenBudget: envSearchBudget } : {}) });
   if (response?.error) {
     process.stderr.write(`[ss-search] server error: ${response.error}\n`);
     process.exit(1);
@@ -383,7 +390,11 @@ async function cmdSemantic(args) {
     process.stderr.write('Usage: ss-semantic <file> "<question>" [--max-tokens N]\n');
     process.exit(2);
   }
-  const maxTokens = +parseFlag(args.slice(2), '--max-tokens', 800);
+  // Default 600 (was 800) per the 2026-06 budget sweep — scaled with the 3k
+  // preview tier. Env hook overrides the default for sweeps; an explicit
+  // --max-tokens flag from the agent always wins.
+  const maxTokens = +parseFlag(args.slice(2), '--max-tokens',
+    Number(process.env.SS_SMOKE_SEMANTIC_MAXTOKENS || '') || 600);
   const { readSemantic } = await import(path.join(REPO_ROOT, 'core/search/search-read-semantic.js'));
   const r = await readSemantic({
     path: file, query, projectRoot: PROJECT_ROOT,
@@ -423,7 +434,9 @@ async function cmdTrace(args) {
   if (file) opts.filePath = file;
   if (queryHint) opts.queryHint = queryHint;
   if (depth != null) opts.maxDepth = +depth;
+  // Budget-sweep experiment hook: env sets the default; explicit --budget wins.
   if (budget != null) opts.tokenBudget = +budget;
+  else if (Number(process.env.SS_SMOKE_TRACE_BUDGET || '') > 0) opts.tokenBudget = Number(process.env.SS_SMOKE_TRACE_BUDGET);
 
   const response = traceSymbol(symbol, opts);
   if (json) process.stdout.write(JSON.stringify(response, null, 2) + '\n');

package/eval/agent-read-workflows/bin/ss-search

@@ -4,7 +4,7 @@
 # semantic / hybrid / structural) with auto-tier budget by default.
 #
 # Usage:
-#   ss-search "<query>"                    # auto-picks 4k / 8k / 12k from signals
+#   ss-search "<query>"                    # auto-picks 3k / 8k / 12k from signals
 #   ss-search "<query>" --full             # force 8k (rarely needed; default auto-picks)
 #   ss-search "<query>" --xl               # force 12k (rarely needed; default auto-picks)
 #   ss-search "<query>" -k N               # top-K (default 5)

package/mcp/server.js

@@ -167,7 +167,7 @@ server.registerTool('trace', {
     maxDepth: z.number().int().min(1).max(4).default(3).optional()
       .describe('Maximum transitive impact depth (default: 3, capped at 4)'),
     tokenBudget: z.number().int().min(1000).max(16000).optional()
-      .describe('Optional token budget. Omit for adaptive 4k/8k/12k selection.'),
+      .describe('Optional token budget. Omit for adaptive 3k/8k/12k selection.'),
   },
   outputSchema: TraceOutputSchema,
   annotations: {