context-compress 2026.5.0 → 2026.7.0

package/dist/server.bundle.mjs

@@ -406,11 +406,11 @@ var require_codegen = __commonJS({
         const rhs = this.rhs === void 0 ? "" : ` = ${this.rhs}`;
         return `${varKind} ${this.name}${rhs};` + _n;
       }
-      optimizeNames(names, constants) {
+      optimizeNames(names, constants2) {
         if (!names[this.name.str])
           return;
         if (this.rhs)
-          this.rhs = optimizeExpr(this.rhs, names, constants);
+          this.rhs = optimizeExpr(this.rhs, names, constants2);
         return this;
       }
       get names() {
@@ -427,10 +427,10 @@ var require_codegen = __commonJS({
       render({ _n }) {
         return `${this.lhs} = ${this.rhs};` + _n;
       }
-      optimizeNames(names, constants) {
+      optimizeNames(names, constants2) {
         if (this.lhs instanceof code_1.Name && !names[this.lhs.str] && !this.sideEffects)
           return;
-        this.rhs = optimizeExpr(this.rhs, names, constants);
+        this.rhs = optimizeExpr(this.rhs, names, constants2);
         return this;
       }
       get names() {
@@ -491,8 +491,8 @@ var require_codegen = __commonJS({
       optimizeNodes() {
         return `${this.code}` ? this : void 0;
       }
-      optimizeNames(names, constants) {
-        this.code = optimizeExpr(this.code, names, constants);
+      optimizeNames(names, constants2) {
+        this.code = optimizeExpr(this.code, names, constants2);
         return this;
       }
       get names() {
@@ -521,12 +521,12 @@ var require_codegen = __commonJS({
         }
         return nodes.length > 0 ? this : void 0;
       }
-      optimizeNames(names, constants) {
+      optimizeNames(names, constants2) {
         const { nodes } = this;
         let i = nodes.length;
         while (i--) {
           const n = nodes[i];
-          if (n.optimizeNames(names, constants))
+          if (n.optimizeNames(names, constants2))
             continue;
           subtractNames(names, n.names);
           nodes.splice(i, 1);
@@ -579,12 +579,12 @@ var require_codegen = __commonJS({
           return void 0;
         return this;
       }
-      optimizeNames(names, constants) {
+      optimizeNames(names, constants2) {
         var _a;
-        this.else = (_a = this.else) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants);
-        if (!(super.optimizeNames(names, constants) || this.else))
+        this.else = (_a = this.else) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants2);
+        if (!(super.optimizeNames(names, constants2) || this.else))
           return;
-        this.condition = optimizeExpr(this.condition, names, constants);
+        this.condition = optimizeExpr(this.condition, names, constants2);
         return this;
       }
       get names() {
@@ -607,10 +607,10 @@ var require_codegen = __commonJS({
       render(opts) {
         return `for(${this.iteration})` + super.render(opts);
       }
-      optimizeNames(names, constants) {
-        if (!super.optimizeNames(names, constants))
+      optimizeNames(names, constants2) {
+        if (!super.optimizeNames(names, constants2))
           return;
-        this.iteration = optimizeExpr(this.iteration, names, constants);
+        this.iteration = optimizeExpr(this.iteration, names, constants2);
         return this;
       }
       get names() {
@@ -646,10 +646,10 @@ var require_codegen = __commonJS({
       render(opts) {
         return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(opts);
       }
-      optimizeNames(names, constants) {
-        if (!super.optimizeNames(names, constants))
+      optimizeNames(names, constants2) {
+        if (!super.optimizeNames(names, constants2))
           return;
-        this.iterable = optimizeExpr(this.iterable, names, constants);
+        this.iterable = optimizeExpr(this.iterable, names, constants2);
         return this;
       }
       get names() {
@@ -691,11 +691,11 @@ var require_codegen = __commonJS({
         (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNodes();
         return this;
       }
-      optimizeNames(names, constants) {
+      optimizeNames(names, constants2) {
         var _a, _b;
-        super.optimizeNames(names, constants);
-        (_a = this.catch) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants);
-        (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNames(names, constants);
+        super.optimizeNames(names, constants2);
+        (_a = this.catch) === null || _a === void 0 ? void 0 : _a.optimizeNames(names, constants2);
+        (_b = this.finally) === null || _b === void 0 ? void 0 : _b.optimizeNames(names, constants2);
         return this;
       }
       get names() {
@@ -996,7 +996,7 @@ var require_codegen = __commonJS({
     function addExprNames(names, from) {
       return from instanceof code_1._CodeOrName ? addNames(names, from.names) : names;
     }
-    function optimizeExpr(expr, names, constants) {
+    function optimizeExpr(expr, names, constants2) {
       if (expr instanceof code_1.Name)
         return replaceName(expr);
       if (!canOptimize(expr))
@@ -1011,14 +1011,14 @@ var require_codegen = __commonJS({
         return items;
       }, []));
       function replaceName(n) {
-        const c = constants[n.str];
+        const c = constants2[n.str];
         if (c === void 0 || names[n.str] !== 1)
           return n;
         delete names[n.str];
         return c;
       }
       function canOptimize(e) {
-        return e instanceof code_1._Code && e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants[c.str] !== void 0);
+        return e instanceof code_1._Code && e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants2[c.str] !== void 0);
       }
     }
     function subtractNames(names, from) {
@@ -10853,6 +10853,7 @@ var DEFAULTS = {
   nudgeOnRead: true,
   nudgeOnGrep: true,
   intentSearchThreshold: 5e3,
+  intentBudgetBytes: 1800,
   maxOutputBytes: 102400,
   hardCapBytes: 100 * 1024 * 1024,
   searchMaxBytes: 40960,
@@ -10872,14 +10873,16 @@ var LEVEL_OVERRIDES = {
     searchMaxBytes: 20480,
     batchMaxBytes: 40960,
     searchLimit: 2,
-    intentSearchThreshold: 3e3
+    intentSearchThreshold: 3e3,
+    intentBudgetBytes: 1e3
   },
   ultra: {
     maxOutputBytes: 25600,
     searchMaxBytes: 10240,
     batchMaxBytes: 20480,
     searchLimit: 1,
-    intentSearchThreshold: 2e3
+    intentSearchThreshold: 2e3,
+    intentBudgetBytes: 500
   }
 };
 var ConfigSchema = external_exports.object({
@@ -10890,6 +10893,7 @@ var ConfigSchema = external_exports.object({
   nudgeOnRead: external_exports.boolean().optional(),
   nudgeOnGrep: external_exports.boolean().optional(),
   intentSearchThreshold: external_exports.number().int().positive().optional(),
+  intentBudgetBytes: external_exports.number().int().positive().optional(),
   maxOutputBytes: external_exports.number().int().positive().optional(),
   hardCapBytes: external_exports.number().int().positive().optional(),
   searchMaxBytes: external_exports.number().int().positive().optional(),
@@ -10965,6 +10969,8 @@ function loadEnvConfig() {
   if (searchBlock !== void 0) partial2.searchBlockAfter = searchBlock;
   const intentThreshold = parseIntEnv("CONTEXT_COMPRESS_INTENT_SEARCH_THRESHOLD");
   if (intentThreshold !== void 0) partial2.intentSearchThreshold = intentThreshold;
+  const intentBudget = parseIntEnv("CONTEXT_COMPRESS_INTENT_BUDGET_BYTES");
+  if (intentBudget !== void 0) partial2.intentBudgetBytes = intentBudget;
   const level = process.env.CONTEXT_COMPRESS_LEVEL;
   if (level === "normal" || level === "compact" || level === "ultra") {
     partial2.compressionLevel = level;
@@ -11008,6 +11014,12 @@ function loadConfig(projectDir2) {
     );
     merged.intentSearchThreshold = 0;
   }
+  if (merged.intentBudgetBytes < 0) {
+    console.error(
+      `[context-compress] Config: intentBudgetBytes clamped from ${merged.intentBudgetBytes} to 0`
+    );
+    merged.intentBudgetBytes = 0;
+  }
   if (merged.searchLimit < 1) {
     console.error(`[context-compress] Config: searchLimit clamped from ${merged.searchLimit} to 1`);
     merged.searchLimit = 1;
@@ -11053,15 +11065,20 @@ function getConfig() {
 }
 
 // src/logger.ts
+var debugOverride = null;
+function configureLogger(debugEnabled) {
+  debugOverride = debugEnabled;
+}
 function debug(...args) {
-  if (getConfig().debug) {
+  const enabled = debugOverride ?? getConfig().debug;
+  if (enabled) {
     process.stderr.write(`[context-compress] ${args.map(String).join(" ")}
 `);
   }
 }
 
 // src/server.ts
-import { join as join4 } from "node:path";
+import { join as join6 } from "node:path";
 
 // node_modules/zod/v4/core/core.js
 var NEVER2 = Object.freeze({
@@ -21719,6 +21736,228 @@ function filterPs(stdout) {
   return { output: out.join("\n"), filtered: true };
 }
 
+// src/format-filter.ts
+var MIN_BYTES_JSON = 1e3;
+var MIN_LINES_LOGS = 30;
+var ARRAY_COLLAPSE_THRESHOLD = 20;
+var ARRAY_KEEP_HEAD = 3;
+var LONG_STRING_LIMIT = 500;
+function detectFormat(text) {
+  const trimmed = text.trim();
+  if (!trimmed) return "plain";
+  if (isWholeJson(trimmed)) return "json";
+  const lines = trimmed.split("\n");
+  if (isNdjson(lines)) return "ndjson";
+  if (isLogs(lines)) return "logs";
+  return "plain";
+}
+function isWholeJson(trimmed) {
+  const wrapped = trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]");
+  return wrapped && tryParse(trimmed);
+}
+function isNdjson(lines) {
+  if (lines.length < 3) return false;
+  let jsonLines = 0;
+  let sampled = 0;
+  for (const line of lines) {
+    const l = line.trim();
+    if (!l) continue;
+    sampled++;
+    if (sampled > 50) break;
+    if ((l.startsWith("{") || l.startsWith("[")) && tryParse(l)) jsonLines++;
+  }
+  return sampled > 0 && jsonLines / sampled >= 0.8;
+}
+function isLogs(lines) {
+  if (lines.length < MIN_LINES_LOGS) return false;
+  const templates = /* @__PURE__ */ new Set();
+  let counted = 0;
+  let logLike = 0;
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    counted++;
+    templates.add(maskVariables(line));
+    if (LOG_LINE.test(line)) logLike++;
+    if (counted > 200) break;
+  }
+  const repetitive = counted >= MIN_LINES_LOGS && templates.size <= counted * 0.5;
+  const structured = counted > 0 && logLike / counted >= 0.5;
+  return repetitive && structured;
+}
+var LOG_LINE = /^\s*(?:\[?\d{4}-\d{2}-\d{2}|\[?\d{2}:\d{2}:\d{2})|\b(?:TRACE|DEBUG|INFO|WARN(?:ING)?|ERROR|FATAL|PANIC)\b/;
+function tryParse(s) {
+  try {
+    JSON.parse(s);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function maskVariables(line) {
+  return line.replace(/\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:[.,]\d+)?(?:Z|[+-]\d{2}:?\d{2})?/g, "<TS>").replace(/\b\d{2}:\d{2}:\d{2}(?:[.,]\d+)?\b/g, "<TIME>").replace(
+    /\b[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\b/g,
+    "<UUID>"
+  ).replace(/\b0x[0-9a-fA-F]+\b/g, "<HEX>").replace(/\b[0-9a-fA-F]{7,}\b/g, "<HASH>").replace(/\b\d{1,3}(?:\.\d{1,3}){3}(?::\d+)?\b/g, "<IP>").replace(/(?:\/[\w.\-]+){2,}/g, "<PATH>").replace(/"[^"]*"/g, '"<STR>"').replace(/'[^']*'/g, "'<STR>'").replace(/\d+/g, "<N>");
+}
+var ERROR_LINE = /\b(error|err|fatal|panic|exception|traceback|warn|warning|failed|failure)\b/i;
+var KEEP_VERBATIM = ERROR_LINE;
+function extractErrorLines(text, max = 5) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const line of text.split("\n")) {
+    const t = line.trim();
+    if (!t || !ERROR_LINE.test(t) || seen.has(t)) continue;
+    seen.add(t);
+    out.push(t);
+    if (out.length >= max) break;
+  }
+  return out;
+}
+function compressLogs(text) {
+  const lines = text.split("\n");
+  const order = [];
+  const groups = /* @__PURE__ */ new Map();
+  const verbatim = [];
+  lines.forEach((line, index) => {
+    if (!line.trim()) return;
+    if (KEEP_VERBATIM.test(line)) {
+      verbatim.push({ index, line });
+      return;
+    }
+    const key = maskVariables(line);
+    const g = groups.get(key);
+    if (g) {
+      g.count++;
+    } else {
+      groups.set(key, { first: line, count: 1 });
+      order.push(key);
+    }
+  });
+  const parts = [];
+  for (const key of order) {
+    const g = groups.get(key);
+    if (!g) continue;
+    if (g.count === 1) {
+      parts.push(g.first);
+    } else {
+      parts.push(`${g.first}
+    \u2026 \xD7${g.count} similar lines (template: ${truncate(key, 120)})`);
+    }
+  }
+  let out = parts.join("\n");
+  if (verbatim.length > 0) {
+    out += `
+
+${verbatim.length} error/warning line(s) preserved verbatim:
+`;
+    out += verbatim.map((v) => v.line).join("\n");
+  }
+  return { output: out, filtered: out.length < text.length, format: "logs" };
+}
+function compressNdjson(text, mode) {
+  const lines = text.split("\n").filter((l) => l.trim());
+  const shapes = /* @__PURE__ */ new Map();
+  const order = [];
+  let parsedAll = true;
+  for (const line of lines) {
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      parsedAll = false;
+      break;
+    }
+    const shape = shapeOf(obj);
+    const s = shapes.get(shape);
+    if (s) {
+      s.count++;
+    } else {
+      shapes.set(shape, { first: line, count: 1 });
+      order.push(shape);
+    }
+  }
+  if (!parsedAll) return { output: text, filtered: false, format: "ndjson" };
+  const parts = [`NDJSON: ${lines.length} records, ${order.length} distinct shape(s).`];
+  for (const shape of order) {
+    const g = shapes.get(shape);
+    if (!g) continue;
+    const keep = mode === "aggressive" ? 1 : ARRAY_KEEP_HEAD;
+    parts.push(`
+shape ${shape} \u2014 ${g.count} record(s). Example:`);
+    parts.push(minifyJson(g.first, mode));
+    if (g.count > keep) parts.push(`\u2026 (${g.count - 1} more of this shape)`);
+  }
+  const out = parts.join("\n");
+  return { output: out, filtered: out.length < text.length, format: "ndjson" };
+}
+function compressJson(text, mode) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return { output: text, filtered: false, format: "json" };
+  }
+  const value = mode === "aggressive" ? summarizeValue(parsed) : parsed;
+  const out = JSON.stringify(value);
+  if (out.length >= text.length) return { output: text, filtered: false, format: "json" };
+  return { output: out, filtered: true, format: "json" };
+}
+function summarizeValue(value) {
+  if (Array.isArray(value)) {
+    const mapped = value.slice(0, ARRAY_COLLAPSE_THRESHOLD).map(summarizeValue);
+    if (value.length > ARRAY_COLLAPSE_THRESHOLD) {
+      mapped.splice(ARRAY_KEEP_HEAD);
+      mapped.push({ "\u2026": `${value.length - ARRAY_KEEP_HEAD} more items (search to retrieve)` });
+    }
+    return mapped;
+  }
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) out[k] = summarizeValue(v);
+    return out;
+  }
+  if (typeof value === "string" && value.length > LONG_STRING_LIMIT) {
+    return `${value.slice(0, LONG_STRING_LIMIT)}\u2026(${value.length} chars)`;
+  }
+  return value;
+}
+function shapeOf(value) {
+  if (Array.isArray(value)) return `[${value.length ? shapeOf(value[0]) : ""}]`;
+  if (value && typeof value === "object") {
+    return `{${Object.keys(value).sort().join(",")}}`;
+  }
+  return typeof value;
+}
+function minifyJson(line, mode) {
+  try {
+    const v = mode === "aggressive" ? summarizeValue(JSON.parse(line)) : JSON.parse(line);
+    return JSON.stringify(v);
+  } catch {
+    return line;
+  }
+}
+function truncate(s, n) {
+  return s.length > n ? `${s.slice(0, n)}\u2026` : s;
+}
+function applyFormatFilter(text, mode) {
+  if (mode === "conservative") return { output: text, filtered: false, format: "plain" };
+  const format = detectFormat(text);
+  switch (format) {
+    case "json":
+      if (Buffer.byteLength(text) < MIN_BYTES_JSON)
+        return { output: text, filtered: false, format };
+      return compressJson(text, mode);
+    case "ndjson":
+      if (Buffer.byteLength(text) < MIN_BYTES_JSON)
+        return { output: text, filtered: false, format };
+      return compressNdjson(text, mode);
+    case "logs":
+      return compressLogs(text);
+    default:
+      return { output: text, filtered: false, format: "plain" };
+  }
+}
+
 // src/utils.ts
 function detectInjectionPatterns(content) {
   const warnings = [];
@@ -21795,8 +22034,9 @@ var SAFE_ENV_KEYS = [
 function buildEnv(config3) {
   const env = {};
   for (const key of SAFE_ENV_KEYS) {
-    if (process.env[key]) {
-      env[key] = process.env[key];
+    const value = process.env[key];
+    if (value) {
+      env[key] = value;
     }
   }
   env.LANG = "en_US.UTF-8";
@@ -21804,8 +22044,9 @@ function buildEnv(config3) {
   env.PYTHONUNBUFFERED = "1";
   env.NO_COLOR = "1";
   for (const key of config3.passthroughEnvVars) {
-    if (process.env[key]) {
-      env[key] = process.env[key];
+    const value = process.env[key];
+    if (value) {
+      env[key] = value;
     }
   }
   return env;
@@ -22030,7 +22271,7 @@ var SubprocessExecutor = class {
         opts.language === "shell" ? opts.code : void 0
       );
     } finally {
-      setTimeout(() => this.cleanupTempDir(tmpDir), 100).unref();
+      this.cleanupTempDir(tmpDir);
     }
   }
   /**
@@ -22120,12 +22361,18 @@ var SubprocessExecutor = class {
 [output capped at ${formatBytes(hardCap)} \u2014 process killed]`;
         }
         stdout = stripAnsi(stdout);
+        let commandFiltered = false;
         if (shellCode && stdout) {
           const filtered = applyCommandFilter(shellCode, stdout);
           if (filtered.filtered) {
             stdout = filtered.output;
+            commandFiltered = true;
           }
         }
+        if (!commandFiltered && stdout) {
+          const fmt = applyFormatFilter(stdout, "balanced");
+          if (fmt.filtered) stdout = fmt.output;
+        }
         if (stdout.length > 1e4) {
           stdout = stripProgressLines(stdout);
           stdout = deduplicateLines(stdout);
@@ -22154,8 +22401,14 @@ var SubprocessExecutor = class {
   cleanupTempDir(dir) {
     try {
       rmSync(dir, { recursive: true, force: true });
-    } catch (e) {
-      debug("Failed to cleanup temp dir:", dir, e);
+    } catch {
+      setTimeout(() => {
+        try {
+          rmSync(dir, { recursive: true, force: true });
+        } catch (e) {
+          debug("Failed to cleanup temp dir:", dir, e);
+        }
+      }, 100).unref();
     }
   }
 };
@@ -22169,8 +22422,8 @@ __cm_main().then(()=>{${epilogue}}).catch(e=>{console.error(e);${epilogue}proces
 }
 
 // src/runtime/index.ts
-import { exec } from "node:child_process";
-import { promisify } from "node:util";
+import { constants, accessSync } from "node:fs";
+import { delimiter, join as join3 } from "node:path";
 
 // src/runtime/languages/elixir.ts
 var elixirPlugin = {
@@ -22436,7 +22689,6 @@ ${code}`;
 };
 
 // src/runtime/index.ts
-var execAsync = promisify(exec);
 var ALL_PLUGINS = [
   javascriptPlugin,
   typescriptPlugin,
@@ -22450,31 +22702,38 @@ var ALL_PLUGINS = [
   rPlugin,
   elixirPlugin
 ];
-async function commandExists(cmd) {
-  const checkCmd = process.platform === "win32" ? `where ${cmd} 2>nul` : `command -v ${cmd} 2>/dev/null`;
+var PATH_DIRS = (process.env.PATH ?? "").split(delimiter).filter(Boolean);
+var WIN_EXTS = (process.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";").filter(Boolean);
+function commandExists(cmd) {
+  if (cmd.includes("/") || cmd.includes("\\")) {
+    return isExecutable(cmd);
+  }
+  const exts = process.platform === "win32" ? WIN_EXTS : [""];
+  for (const dir of PATH_DIRS) {
+    for (const ext of exts) {
+      if (isExecutable(join3(dir, cmd + ext))) return true;
+    }
+  }
+  return false;
+}
+function isExecutable(filePath) {
   try {
-    await execAsync(checkCmd, { timeout: 3e3 });
+    accessSync(filePath, process.platform === "win32" ? constants.F_OK : constants.X_OK);
     return true;
   } catch {
     return false;
   }
 }
-async function detectRuntimes() {
+function detectRuntimes() {
   const map = /* @__PURE__ */ new Map();
-  const tasks = ALL_PLUGINS.map(async (plugin) => {
+  for (const plugin of ALL_PLUGINS) {
     for (const candidate of plugin.runtimeCandidates) {
-      if (await commandExists(candidate)) {
-        return { plugin, runtime: candidate };
+      if (commandExists(candidate)) {
+        map.set(plugin.language, { plugin, runtime: candidate });
+        debug(`Detected ${plugin.language}: ${candidate}`);
+        break;
       }
     }
-    return null;
-  });
-  const results = await Promise.all(tasks);
-  for (const result of results) {
-    if (result) {
-      map.set(result.plugin.language, result);
-      debug(`Detected ${result.plugin.language}: ${result.runtime}`);
-    }
   }
   return map;
 }
@@ -22484,7 +22743,32 @@ function hasBun(runtimes) {
 }
 
 // src/stats.ts
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
+
+// src/util/regret.ts
+import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { dirname, join as join4 } from "node:path";
+var DEFAULT_PATH = join4(homedir2(), ".context-compress", "regret.json");
+function load(path) {
+  if (!existsSync(path)) return {};
+  try {
+    return JSON.parse(readFileSync2(path, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function regretSummary(opts = {}) {
+  const map = load(opts.path ?? DEFAULT_PATH);
+  return Object.entries(map).map(([fingerprint, r]) => ({
+    fingerprint,
+    observations: r.observations,
+    regrets: r.regrets,
+    regretRate: r.observations > 0 ? r.regrets / r.observations : 0
+  })).filter((r) => r.regrets > 0).sort((a, b) => b.regretRate - a.regretRate);
+}
+
+// src/stats.ts
 var BAR_WIDTH = 20;
 function asciiBar(ratio, width = BAR_WIDTH) {
   const filled = Math.round(ratio * width);
@@ -22519,13 +22803,17 @@ var SessionTracker = class {
     this.stats.bytesSandboxed += bytes;
   }
   getSnapshot() {
-    return { ...this.stats };
+    return {
+      ...this.stats,
+      calls: { ...this.stats.calls },
+      bytesReturned: { ...this.stats.bytesReturned }
+    };
   }
   /** Load cumulative stats from disk */
   loadCumulative() {
     if (!this.cumulativeFile) return null;
     try {
-      const data = readFileSync2(this.cumulativeFile, "utf-8");
+      const data = readFileSync3(this.cumulativeFile, "utf-8");
       return JSON.parse(data);
     } catch {
       return null;
@@ -22558,7 +22846,7 @@ var SessionTracker = class {
       cumulative.perCommand[name].calls += calls;
     }
     try {
-      writeFileSync2(this.cumulativeFile, JSON.stringify(cumulative, null, 2));
+      writeFileSync3(this.cumulativeFile, JSON.stringify(cumulative, null, 2));
     } catch {
     }
   }
@@ -22634,14 +22922,25 @@ Context-compress kept ${formatBytes(keptOut)} out of context (${reductionPct}% s
       lines.push(`| Est. total tokens saved | ~${cumTokensMid.toLocaleString()} |`);
       lines.push(`| Tracking since | ${cumulative.firstSeen.split("T")[0]} |`);
     }
+    const regrets = regretSummary();
+    if (regrets.length > 0) {
+      lines.push("\n## Auto-Mode Self-Tuning (regret-adjusted)\n");
+      lines.push("| Command | Re-runs / Obs | Regret |");
+      lines.push("|---------|---------------|--------|");
+      for (const r of regrets.slice(0, 10)) {
+        lines.push(
+          `| \`${r.fingerprint}\` | ${r.regrets}/${r.observations} | ${(r.regretRate * 100).toFixed(0)}% |`
+        );
+      }
+    }
     return lines.join("\n");
   }
 };
 
 // src/store.ts
-import { mkdirSync as mkdirSync2, readdirSync, unlinkSync } from "node:fs";
+import { mkdirSync as mkdirSync3, readdirSync, unlinkSync } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join3 } from "node:path";
+import { join as join5 } from "node:path";
 import Database from "better-sqlite3";
 
 // src/snippet.ts
@@ -22825,6 +23124,7 @@ function levenshtein(a, b, maxDist) {
 var ContentStore = class {
   db;
   hasTrigramTable = false;
+  closed = false;
   // Cached prepared statements (initialized in initSchema, always available after constructor)
   insertSourceStmt;
   insertChunkStmt;
@@ -22838,12 +23138,12 @@ var ContentStore = class {
     if (typeof options === "string") {
       path = options;
     } else if (options?.persistDb || options?.dbDir) {
-      const dir = options.dbDir ?? join3(process.env.CLAUDE_PROJECT_DIR ?? process.cwd(), ".context-compress");
-      mkdirSync2(dir, { recursive: true });
-      path = join3(dir, "store.db");
+      const dir = options.dbDir ?? join5(process.env.CLAUDE_PROJECT_DIR ?? process.cwd(), ".context-compress");
+      mkdirSync3(dir, { recursive: true });
+      path = join5(dir, "store.db");
       debug("Using persistent DB at", path);
     } else {
-      path = (typeof options === "object" ? options?.dbPath : void 0) ?? join3(tmpdir2(), `context-compress-${process.pid}.db`);
+      path = (typeof options === "object" ? options?.dbPath : void 0) ?? join5(tmpdir2(), `context-compress-${process.pid}.db`);
     }
     this.db = new Database(path);
     this.db.pragma("journal_mode = WAL");
@@ -22894,9 +23194,20 @@ var ContentStore = class {
 				tokenize='trigram'
 			);
 		`);
-    this.db.exec(
-      "INSERT INTO chunks_trigram (title, content, source_id, content_type) SELECT title, content, source_id, content_type FROM chunks"
+    const BATCH = 5e3;
+    const backfill = this.db.prepare(
+      "INSERT INTO chunks_trigram (title, content, source_id, content_type) SELECT title, content, source_id, content_type FROM chunks WHERE rowid > ? ORDER BY rowid LIMIT ?"
+    );
+    const windowMaxStmt = this.db.prepare(
+      "SELECT MAX(rowid) AS maxRowid FROM (SELECT rowid FROM chunks WHERE rowid > ? ORDER BY rowid LIMIT ?)"
     );
+    let lastRowid = 0;
+    for (; ; ) {
+      const window = windowMaxStmt.get(lastRowid, BATCH);
+      if (window.maxRowid == null) break;
+      backfill.run(lastRowid, BATCH);
+      lastRowid = window.maxRowid;
+    }
     this.hasTrigramTable = true;
   }
   /**
@@ -23117,6 +23428,8 @@ var ContentStore = class {
     };
   }
   close() {
+    if (this.closed) return;
+    this.closed = true;
     this.db.close();
   }
 };
@@ -23214,7 +23527,7 @@ function cleanupStaleDbs() {
       try {
         process.kill(pid, 0);
       } catch {
-        const basePath = join3(dir, file);
+        const basePath = join5(dir, file);
         for (const suffix of ["", "-wal", "-shm"]) {
           try {
             unlinkSync(basePath + suffix);
@@ -23263,20 +23576,28 @@ function registerBatchExecuteTool(server2, ctx) {
         }),
         4
       );
+      const COMBINED_CAP = config3.batchMaxBytes;
+      const PER_COMMAND_CAP = Math.max(64e3, Math.floor(COMBINED_CAP / 4));
       let combined = "";
       const inventory = [];
+      let truncatedCommands = 0;
       for (let i = 0; i < commandResults.length; i++) {
         const settled = commandResults[i];
         const label = commands[i].label;
         if (settled.status === "fulfilled") {
           const { result } = settled.value;
-          const output2 = result.stdout || "(no output)";
+          let output2 = result.stdout || "(no output)";
+          const lineCount = output2.split("\n").length;
+          if (Buffer.byteLength(output2) > PER_COMMAND_CAP) {
+            output2 = `${output2.slice(0, PER_COMMAND_CAP)}
+\u2026(output truncated)`;
+            truncatedCommands++;
+          }
           combined += `## ${label}
 
 ${output2}
 
 `;
-          const lineCount = output2.split("\n").length;
           inventory.push(`- **${label}**: ${lineCount} lines`);
         } else {
           combined += `## ${label}
@@ -23286,6 +23607,11 @@ ${output2}
 `;
           inventory.push(`- **${label}**: error`);
         }
+        if (Buffer.byteLength(combined) >= COMBINED_CAP) {
+          combined += "\n\u2026(remaining command output omitted: combined size limit reached)\n";
+          truncatedCommands += commandResults.length - i - 1;
+          break;
+        }
       }
       const indexed = store.index(combined, "batch_execute");
       tracker.trackIndexed(Buffer.byteLength(combined));
@@ -23320,6 +23646,11 @@ ${hit.snippet}
 ${inventory.join("\n")}
 
 `;
+      if (truncatedCommands > 0) {
+        output += `_Note: ${truncatedCommands} command output(s) truncated to stay within size limits; use search() to retrieve indexed content._
+
+`;
+      }
       output += searchResults.join("\n---\n\n");
       if (terms.length > 0) {
         output += `
@@ -23646,33 +23977,9 @@ async function resolveAndValidate(url) {
   return { url, resolvedIp };
 }
 
-// src/util/fetch-code.ts
-function buildFetchCode(url, resolvedIp) {
-  let fetchSetup;
-  if (resolvedIp) {
-    const pinnedUrl = new URL(url);
-    const originalHost = pinnedUrl.host;
-    const hostnameValue = resolvedIp.includes(":") && !resolvedIp.startsWith("[") ? `[${resolvedIp}]` : resolvedIp;
-    pinnedUrl.hostname = hostnameValue;
-    fetchSetup = `
-const url = ${JSON.stringify(pinnedUrl.toString())};
-const resp = await fetch(url, { headers: { 'Host': ${JSON.stringify(originalHost)} }, redirect: 'error' });`;
-  } else {
-    fetchSetup = `
-const url = ${JSON.stringify(url)};
-const resp = await fetch(url, { redirect: 'error' });`;
-  }
-  return `${fetchSetup}
-if (!resp.ok) { console.error("HTTP " + resp.status); process.exit(1); }
-const cl = resp.headers.get('content-length');
-if (cl && parseInt(cl, 10) > 10 * 1024 * 1024) {
-    console.error("Response too large: " + cl + " bytes"); process.exit(1);
-}
-const html = await resp.text();
-if (html.length > 10 * 1024 * 1024) {
-    console.error("Response body too large: " + html.length + " chars"); process.exit(1);
-}
-
+// src/util/html-to-markdown.ts
+function htmlToMarkdownSnippet() {
+  return `
 // Strip unwanted tags
 let md = html
   .replace(/<script[^>]*>[\\s\\S]*?<\\/script>/gi, "")
@@ -23704,7 +24011,7 @@ md = md.replace(/<br\\s*\\/?>/gi, "\\n");
 // Strip remaining tags
 md = md.replace(/<[^>]+>/g, "");
 
-// Decode entities
+// Decode entities (&amp; LAST so we don't double-decode)
 md = md.replace(/&lt;/g, "<")
   .replace(/&gt;/g, ">")
   .replace(/&quot;/g, '"')
@@ -23722,6 +24029,35 @@ console.log(md);
 `;
 }
 
+// src/util/fetch-code.ts
+function buildFetchCode(url, resolvedIp) {
+  let fetchSetup;
+  if (resolvedIp) {
+    const pinnedUrl = new URL(url);
+    const originalHost = pinnedUrl.host;
+    const hostnameValue = resolvedIp.includes(":") && !resolvedIp.startsWith("[") ? `[${resolvedIp}]` : resolvedIp;
+    pinnedUrl.hostname = hostnameValue;
+    fetchSetup = `
+const url = ${JSON.stringify(pinnedUrl.toString())};
+const resp = await fetch(url, { headers: { 'Host': ${JSON.stringify(originalHost)} }, redirect: 'error' });`;
+  } else {
+    fetchSetup = `
+const url = ${JSON.stringify(url)};
+const resp = await fetch(url, { redirect: 'error' });`;
+  }
+  return `${fetchSetup}
+if (!resp.ok) { console.error("HTTP " + resp.status); process.exit(1); }
+const cl = resp.headers.get('content-length');
+if (cl && parseInt(cl, 10) > 10 * 1024 * 1024) {
+    console.error("Response too large: " + cl + " bytes"); process.exit(1);
+}
+const html = await resp.text();
+if (html.length > 10 * 1024 * 1024) {
+    console.error("Response body too large: " + html.length + " chars"); process.exit(1);
+}
+${htmlToMarkdownSnippet()}`;
+}
+
 // src/tools/fetch-and-index.ts
 function registerFetchAndIndexTool(server2, ctx) {
   const { executor, store, tracker, withExecutionLimit } = ctx;
@@ -23821,7 +24157,7 @@ Searchable terms: ${terms.join(", ")}`;
 }
 
 // src/tools/index-content.ts
-import { readFileSync as readFileSync3, statSync } from "node:fs";
+import { readFileSync as readFileSync4, statSync } from "node:fs";
 import { resolve as resolve3 } from "node:path";
 function registerIndexTool(server2, ctx) {
   const { store, tracker, projectDir: projectDir2 } = ctx;
@@ -23862,7 +24198,7 @@ function registerIndexTool(server2, ctx) {
               isError: true
             };
           }
-          text = readFileSync3(absPath, "utf-8");
+          text = readFileSync4(absPath, "utf-8");
           label = source ?? filePath;
         } catch (e) {
           const msg = e instanceof Error ? e.message : String(e);
@@ -23995,22 +24331,31 @@ function compactLabel(normal, level) {
 }
 
 // src/util/intent-filter.ts
+var INTENT_SEARCH_LIMIT = 6;
+var PER_HIT_CAP = 700;
+var PER_HIT_FLOOR = 120;
 function createIntentFilter(deps) {
   const { config: config3, store, tracker } = deps;
   return function applyIntentFilter(output, intent, sourceLabel) {
-    if (Buffer.byteLength(output) <= config3.intentSearchThreshold) return output;
+    const outputBytes = Buffer.byteLength(output);
+    if (outputBytes <= config3.intentSearchThreshold) return output;
     const indexed = store.index(output, sourceLabel);
-    tracker.trackIndexed(Buffer.byteLength(output));
-    const searchResults = store.search(intent, { limit: 3 });
+    tracker.trackIndexed(outputBytes);
+    const searchResults = store.search(intent, { limit: INTENT_SEARCH_LIMIT });
     const terms = store.getDistinctiveTerms(indexed.sourceId);
+    const errorLines = extractErrorLines(output);
     let filtered = `Indexed ${indexed.totalChunks} sections from ${sourceLabel}.
 `;
     filtered += `${searchResults.results.length} sections matched "${intent}":
 
 `;
-    for (const hit of searchResults.results) {
-      filtered += `  - **${hit.title}**: ${hit.snippet.slice(0, 200)}
+    filtered += renderHits(searchResults.results, config3.intentBudgetBytes);
+    if (errorLines.length > 0) {
+      filtered += `
+\u26A0 ${errorLines.length} error/warning line(s) in output:
 `;
+      filtered += errorLines.map((l) => `  ${l}`).join("\n");
+      filtered += "\n";
     }
     if (terms.length > 0 && config3.compressionLevel !== "ultra") {
       filtered += `
@@ -24021,16 +24366,39 @@ Searchable terms: ${terms.join(", ")}
     return compactLabel(filtered, config3.compressionLevel);
   };
 }
+function renderHits(hits, budget) {
+  if (hits.length === 0) return "  (no matching sections \u2014 try search() with different terms)\n";
+  const lines = [];
+  let remaining = budget;
+  for (let i = 0; i < hits.length; i++) {
+    const hit = hits[i];
+    const hitsLeft = hits.length - i;
+    const share = Math.min(PER_HIT_CAP, Math.floor(remaining / hitsLeft));
+    if (share < PER_HIT_FLOOR) {
+      lines.push(`  - **${hit.title}** (search to view)`);
+      continue;
+    }
+    const snippet = clip(hit.snippet.trim(), share);
+    remaining -= Buffer.byteLength(snippet);
+    lines.push(`  - **${hit.title}**: ${snippet}`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+function clip(s, max) {
+  if (Buffer.byteLength(s) <= max) return s;
+  return `${s.slice(0, Math.max(0, max - 1))}\u2026`;
+}
 
 // src/util/version.ts
-import { readFileSync as readFileSync4 } from "node:fs";
-import { dirname, resolve as resolve4 } from "node:path";
+import { readFileSync as readFileSync5 } from "node:fs";
+import { dirname as dirname2, resolve as resolve4 } from "node:path";
 import { fileURLToPath } from "node:url";
-var __dirname = dirname(fileURLToPath(import.meta.url));
+var __dirname = dirname2(fileURLToPath(import.meta.url));
 function getVersion(fallback = "1.0.0") {
   try {
     const pkgPath = resolve4(__dirname, "..", "..", "package.json");
-    const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
     return pkg.version ?? fallback;
   } catch {
     return fallback;
@@ -24042,10 +24410,11 @@ var projectDir = process.env.CLAUDE_PROJECT_DIR ?? process.cwd();
 var MAX_CONCURRENT_EXECUTIONS = 8;
 var EXECUTION_LIMIT_ERROR = "Error: too many concurrent executions. Try again shortly.";
 async function createServer(config3) {
+  configureLogger(config3.debug);
   const version2 = getVersion();
   debug("Version:", version2);
   cleanupStaleDbs();
-  const runtimes = await detectRuntimes();
+  const runtimes = detectRuntimes();
   const bunDetected = hasBun(runtimes);
   debug("Runtimes detected:", runtimes.size);
   const executor = new SubprocessExecutor(runtimes, config3);
@@ -24058,7 +24427,7 @@ async function createServer(config3) {
     store = new ContentStore(":memory:");
     dbFallback = true;
   }
-  const cumulativeFile = config3.persistDb ? join4(config3.dbDir ?? join4(projectDir, ".context-compress"), "stats.json") : void 0;
+  const cumulativeFile = config3.persistDb ? join6(config3.dbDir ?? join6(projectDir, ".context-compress"), "stats.json") : void 0;
   const tracker = new SessionTracker(cumulativeFile);
   let activeExecutions = 0;
   async function withExecutionLimit(fn) {