context-compress 2026.3.3 → 2026.3.20

package/dist/server.bundle.mjs

@@ -6800,85 +6800,8 @@ var require_dist = __commonJS({
 
 // src/config.ts
 import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
 import { join } from "node:path";
-var DEFAULTS = {
-  passthroughEnvVars: [],
-  debug: false,
-  blockCurl: true,
-  blockWebFetch: true,
-  nudgeOnRead: true,
-  nudgeOnGrep: true,
-  intentSearchThreshold: 5e3,
-  maxOutputBytes: 102400,
-  hardCapBytes: 100 * 1024 * 1024,
-  searchMaxBytes: 40960,
-  batchMaxBytes: 81920,
-  searchLimit: 3,
-  searchWindowMs: 6e4,
-  searchReduceAfter: 3,
-  searchBlockAfter: 8
-};
-function loadFileConfig(projectDir2) {
-  const paths = [
-    projectDir2 && join(projectDir2, ".context-compress.json"),
-    join(process.env.HOME ?? "~", ".context-compress.json")
-  ].filter(Boolean);
-  for (const p of paths) {
-    try {
-      const raw = readFileSync(p, "utf-8");
-      return JSON.parse(raw);
-    } catch {
-    }
-  }
-  return {};
-}
-function loadEnvConfig() {
-  const partial2 = {};
-  if (process.env.CONTEXT_COMPRESS_DEBUG === "1") {
-    partial2.debug = true;
-  }
-  if (process.env.CONTEXT_COMPRESS_PASSTHROUGH_ENV) {
-    partial2.passthroughEnvVars = process.env.CONTEXT_COMPRESS_PASSTHROUGH_ENV.split(",").map((s) => s.trim()).filter(Boolean);
-  }
-  if (process.env.CONTEXT_COMPRESS_BLOCK_CURL !== void 0) {
-    partial2.blockCurl = process.env.CONTEXT_COMPRESS_BLOCK_CURL !== "0";
-  }
-  if (process.env.CONTEXT_COMPRESS_BLOCK_WEBFETCH !== void 0) {
-    partial2.blockWebFetch = process.env.CONTEXT_COMPRESS_BLOCK_WEBFETCH !== "0";
-  }
-  if (process.env.CONTEXT_COMPRESS_NUDGE_READ !== void 0) {
-    partial2.nudgeOnRead = process.env.CONTEXT_COMPRESS_NUDGE_READ !== "0";
-  }
-  if (process.env.CONTEXT_COMPRESS_NUDGE_GREP !== void 0) {
-    partial2.nudgeOnGrep = process.env.CONTEXT_COMPRESS_NUDGE_GREP !== "0";
-  }
-  return partial2;
-}
-var _config = null;
-function loadConfig(projectDir2) {
-  if (_config) return _config;
-  const fileConfig = loadFileConfig(projectDir2);
-  const envConfig = loadEnvConfig();
-  _config = { ...DEFAULTS, ...fileConfig, ...envConfig };
-  return _config;
-}
-function getConfig() {
-  if (!_config) return loadConfig();
-  return _config;
-}
-
-// src/logger.ts
-function debug(...args) {
-  if (getConfig().debug) {
-    process.stderr.write(`[context-compress] ${args.map(String).join(" ")}
-`);
-  }
-}
-
-// src/server.ts
-import { readFileSync as readFileSync2 } from "node:fs";
-import { dirname, join as join4, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
 
 // node_modules/zod/v3/external.js
 var external_exports = {};
@@ -10921,6 +10844,227 @@ var coerce = {
 };
 var NEVER = INVALID;
 
+// src/config.ts
+var DEFAULTS = {
+  passthroughEnvVars: [],
+  debug: false,
+  blockCurl: true,
+  blockWebFetch: true,
+  nudgeOnRead: true,
+  nudgeOnGrep: true,
+  intentSearchThreshold: 5e3,
+  maxOutputBytes: 102400,
+  hardCapBytes: 100 * 1024 * 1024,
+  searchMaxBytes: 40960,
+  batchMaxBytes: 81920,
+  searchLimit: 3,
+  searchWindowMs: 6e4,
+  searchReduceAfter: 3,
+  searchBlockAfter: 8,
+  compressionLevel: "normal",
+  persistDb: false,
+  dbDir: null
+};
+var LEVEL_OVERRIDES = {
+  normal: {},
+  compact: {
+    maxOutputBytes: 51200,
+    searchMaxBytes: 20480,
+    batchMaxBytes: 40960,
+    searchLimit: 2,
+    intentSearchThreshold: 3e3
+  },
+  ultra: {
+    maxOutputBytes: 25600,
+    searchMaxBytes: 10240,
+    batchMaxBytes: 20480,
+    searchLimit: 1,
+    intentSearchThreshold: 2e3
+  }
+};
+var ConfigSchema = external_exports.object({
+  passthroughEnvVars: external_exports.array(external_exports.string()).optional(),
+  debug: external_exports.boolean().optional(),
+  blockCurl: external_exports.boolean().optional(),
+  blockWebFetch: external_exports.boolean().optional(),
+  nudgeOnRead: external_exports.boolean().optional(),
+  nudgeOnGrep: external_exports.boolean().optional(),
+  intentSearchThreshold: 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(),
+  batchMaxBytes: external_exports.number().int().positive().optional(),
+  searchLimit: external_exports.number().int().positive().optional(),
+  searchWindowMs: external_exports.number().int().positive().optional(),
+  searchReduceAfter: external_exports.number().int().nonnegative().optional(),
+  searchBlockAfter: external_exports.number().int().positive().optional(),
+  compressionLevel: external_exports.enum(["normal", "compact", "ultra"]).optional(),
+  persistDb: external_exports.boolean().optional(),
+  dbDir: external_exports.string().nullable().optional()
+});
+function parseIntEnv(key) {
+  const val = process.env[key];
+  if (val === void 0) return void 0;
+  const n = Number.parseInt(val, 10);
+  return Number.isNaN(n) ? void 0 : n;
+}
+function loadFileConfig(projectDir2) {
+  const paths = [
+    projectDir2 && join(projectDir2, ".context-compress.json"),
+    join(homedir(), ".context-compress.json")
+  ].filter(Boolean);
+  for (const p of paths) {
+    try {
+      const raw = readFileSync(p, "utf-8");
+      const parsed = JSON.parse(raw);
+      const result = ConfigSchema.safeParse(parsed);
+      if (result.success) {
+        return result.data;
+      }
+      return {};
+    } catch {
+    }
+  }
+  return {};
+}
+function loadEnvConfig() {
+  const partial2 = {};
+  if (process.env.CONTEXT_COMPRESS_DEBUG === "1") {
+    partial2.debug = true;
+  }
+  if (process.env.CONTEXT_COMPRESS_PASSTHROUGH_ENV) {
+    partial2.passthroughEnvVars = process.env.CONTEXT_COMPRESS_PASSTHROUGH_ENV.split(",").map((s) => s.trim()).filter(Boolean);
+  }
+  if (process.env.CONTEXT_COMPRESS_BLOCK_CURL !== void 0) {
+    partial2.blockCurl = process.env.CONTEXT_COMPRESS_BLOCK_CURL !== "0";
+  }
+  if (process.env.CONTEXT_COMPRESS_BLOCK_WEBFETCH !== void 0) {
+    partial2.blockWebFetch = process.env.CONTEXT_COMPRESS_BLOCK_WEBFETCH !== "0";
+  }
+  if (process.env.CONTEXT_COMPRESS_NUDGE_READ !== void 0) {
+    partial2.nudgeOnRead = process.env.CONTEXT_COMPRESS_NUDGE_READ !== "0";
+  }
+  if (process.env.CONTEXT_COMPRESS_NUDGE_GREP !== void 0) {
+    partial2.nudgeOnGrep = process.env.CONTEXT_COMPRESS_NUDGE_GREP !== "0";
+  }
+  const maxOutput = parseIntEnv("CONTEXT_COMPRESS_MAX_OUTPUT_BYTES");
+  if (maxOutput !== void 0) partial2.maxOutputBytes = maxOutput;
+  const hardCap = parseIntEnv("CONTEXT_COMPRESS_HARD_CAP_BYTES");
+  if (hardCap !== void 0) partial2.hardCapBytes = hardCap;
+  const searchMax = parseIntEnv("CONTEXT_COMPRESS_SEARCH_MAX_BYTES");
+  if (searchMax !== void 0) partial2.searchMaxBytes = searchMax;
+  const batchMax = parseIntEnv("CONTEXT_COMPRESS_BATCH_MAX_BYTES");
+  if (batchMax !== void 0) partial2.batchMaxBytes = batchMax;
+  const searchLimit = parseIntEnv("CONTEXT_COMPRESS_SEARCH_LIMIT");
+  if (searchLimit !== void 0) partial2.searchLimit = searchLimit;
+  const searchWindow = parseIntEnv("CONTEXT_COMPRESS_SEARCH_WINDOW_MS");
+  if (searchWindow !== void 0) partial2.searchWindowMs = searchWindow;
+  const searchReduce = parseIntEnv("CONTEXT_COMPRESS_SEARCH_REDUCE_AFTER");
+  if (searchReduce !== void 0) partial2.searchReduceAfter = searchReduce;
+  const searchBlock = parseIntEnv("CONTEXT_COMPRESS_SEARCH_BLOCK_AFTER");
+  if (searchBlock !== void 0) partial2.searchBlockAfter = searchBlock;
+  const intentThreshold = parseIntEnv("CONTEXT_COMPRESS_INTENT_SEARCH_THRESHOLD");
+  if (intentThreshold !== void 0) partial2.intentSearchThreshold = intentThreshold;
+  const level = process.env.CONTEXT_COMPRESS_LEVEL;
+  if (level === "normal" || level === "compact" || level === "ultra") {
+    partial2.compressionLevel = level;
+  }
+  if (process.env.CONTEXT_COMPRESS_PERSIST_DB === "1") {
+    partial2.persistDb = true;
+  }
+  if (process.env.CONTEXT_COMPRESS_DB_DIR) {
+    partial2.dbDir = process.env.CONTEXT_COMPRESS_DB_DIR;
+  }
+  return partial2;
+}
+var _config = null;
+function loadConfig(projectDir2) {
+  if (_config) return _config;
+  const fileConfig = loadFileConfig(projectDir2);
+  const envConfig = loadEnvConfig();
+  const merged = { ...DEFAULTS, ...fileConfig, ...envConfig };
+  const levelOverrides = LEVEL_OVERRIDES[merged.compressionLevel];
+  for (const [key, value] of Object.entries(levelOverrides)) {
+    const k = key;
+    if (!(k in fileConfig) && !(k in envConfig)) {
+      merged[k] = value;
+    }
+  }
+  if (merged.maxOutputBytes < 1024) {
+    console.error(
+      `[context-compress] Config: maxOutputBytes clamped from ${merged.maxOutputBytes} to 1024`
+    );
+    merged.maxOutputBytes = 1024;
+  }
+  if (merged.hardCapBytes < merged.maxOutputBytes) {
+    console.error(
+      `[context-compress] Config: hardCapBytes clamped from ${merged.hardCapBytes} to ${merged.maxOutputBytes}`
+    );
+    merged.hardCapBytes = merged.maxOutputBytes;
+  }
+  if (merged.intentSearchThreshold < 0) {
+    console.error(
+      `[context-compress] Config: intentSearchThreshold clamped from ${merged.intentSearchThreshold} to 0`
+    );
+    merged.intentSearchThreshold = 0;
+  }
+  if (merged.searchLimit < 1) {
+    console.error(`[context-compress] Config: searchLimit clamped from ${merged.searchLimit} to 1`);
+    merged.searchLimit = 1;
+  }
+  if (merged.searchWindowMs < 1e3) {
+    console.error(
+      `[context-compress] Config: searchWindowMs clamped from ${merged.searchWindowMs} to 1000`
+    );
+    merged.searchWindowMs = 1e3;
+  }
+  if (merged.searchReduceAfter < 1) {
+    console.error(
+      `[context-compress] Config: searchReduceAfter clamped from ${merged.searchReduceAfter} to 1`
+    );
+    merged.searchReduceAfter = 1;
+  }
+  if (merged.searchBlockAfter < merged.searchReduceAfter + 1) {
+    const minVal = merged.searchReduceAfter + 1;
+    console.error(
+      `[context-compress] Config: searchBlockAfter clamped from ${merged.searchBlockAfter} to ${minVal}`
+    );
+    merged.searchBlockAfter = minVal;
+  }
+  if (merged.searchMaxBytes < 1024) {
+    console.error(
+      `[context-compress] Config: searchMaxBytes clamped from ${merged.searchMaxBytes} to 1024`
+    );
+    merged.searchMaxBytes = 1024;
+  }
+  if (merged.batchMaxBytes < 1024) {
+    console.error(
+      `[context-compress] Config: batchMaxBytes clamped from ${merged.batchMaxBytes} to 1024`
+    );
+    merged.batchMaxBytes = 1024;
+  }
+  if (merged.dbDir) merged.persistDb = true;
+  _config = merged;
+  return _config;
+}
+function getConfig() {
+  if (!_config) return loadConfig();
+  return _config;
+}
+
+// src/logger.ts
+function debug(...args) {
+  if (getConfig().debug) {
+    process.stderr.write(`[context-compress] ${args.map(String).join(" ")}
+`);
+  }
+}
+
+// src/server.ts
+import { readFileSync as readFileSync2, realpathSync, statSync } from "node:fs";
+import { dirname, join as join4, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
 // node_modules/zod/v4/core/core.js
 var NEVER2 = Object.freeze({
   status: "aborted"
@@ -21073,7 +21217,6 @@ import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join as join2 } from "node:path";
 var DEFAULT_TIMEOUT = 3e4;
-var DEFAULT_HARD_CAP = 100 * 1024 * 1024;
 var SAFE_ENV_KEYS = [
   "PATH",
   "HOME",
@@ -21126,6 +21269,86 @@ function killProcessTree(pid) {
     }
   }
 }
+function deduplicateLines(output) {
+  const lines = output.split("\n");
+  if (lines.length < 3) return output;
+  const result = [];
+  let prevLine = lines[0];
+  let count = 1;
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i] === prevLine && prevLine.trim().length > 0) {
+      count++;
+    } else {
+      if (count > 2) {
+        result.push(prevLine);
+        result.push(`  ... (\xD7${count} identical lines)`);
+      } else {
+        for (let j = 0; j < count; j++) result.push(prevLine);
+      }
+      prevLine = lines[i];
+      count = 1;
+    }
+  }
+  if (count > 2) {
+    result.push(prevLine);
+    result.push(`  ... (\xD7${count} identical lines)`);
+  } else {
+    for (let j = 0; j < count; j++) result.push(prevLine);
+  }
+  return result.join("\n");
+}
+function groupErrorLines(output) {
+  const lines = output.split("\n");
+  if (lines.length < 5) return output;
+  const ERROR_RE = /^(.*?(?:error|warning|Error|Warning|ERR|WARN)[:\s])\s*(.+?)(?:\s+(?:at|in|on)\s+(?:line\s+)?(\d+))?$/i;
+  const errorGroups = /* @__PURE__ */ new Map();
+  const resultLines = [];
+  let groupedCount = 0;
+  for (const line of lines) {
+    const match = line.match(ERROR_RE);
+    if (match) {
+      const prefix = match[1].trim();
+      const msg = match[2].trim();
+      const key = `${prefix}|${msg}`;
+      const existing = errorGroups.get(key);
+      if (existing) {
+        existing.count++;
+        if (match[3]) existing.locations.push(match[3]);
+        groupedCount++;
+        continue;
+      }
+      errorGroups.set(key, {
+        message: `${prefix} ${msg}`,
+        locations: match[3] ? [match[3]] : [],
+        count: 1
+      });
+      groupedCount++;
+      continue;
+    }
+    resultLines.push(line);
+  }
+  if (groupedCount < 4 || errorGroups.size === groupedCount) return output;
+  const grouped = [];
+  for (const [, group] of errorGroups) {
+    if (group.count === 1) {
+      grouped.push(
+        group.message + (group.locations.length ? ` at line ${group.locations[0]}` : "")
+      );
+    } else {
+      let line = `${group.message} (\xD7${group.count})`;
+      if (group.locations.length > 0) {
+        line += ` [lines: ${group.locations.join(", ")}]`;
+      }
+      grouped.push(line);
+    }
+  }
+  if (grouped.length > 0) {
+    resultLines.push("");
+    resultLines.push(`\u2500\u2500 Grouped errors/warnings (${groupedCount} \u2192 ${errorGroups.size}) \u2500\u2500`);
+    resultLines.push(...grouped);
+  }
+  return resultLines.join("\n");
+}
 function smartTruncate(output, maxBytes) {
   if (Buffer.byteLength(output) <= maxBytes) return output;
   const lines = output.split("\n");
@@ -21231,7 +21454,7 @@ var SubprocessExecutor = class {
         plugin.needsShell
       );
     } finally {
-      setTimeout(() => this.cleanupTempDir(tmpDir), 100);
+      setTimeout(() => this.cleanupTempDir(tmpDir), 100).unref();
     }
   }
   /**
@@ -21317,6 +21540,8 @@ var SubprocessExecutor = class {
           stdout += `
 [output capped at ${formatBytes(hardCap)} \u2014 process killed]`;
         }
+        stdout = deduplicateLines(stdout);
+        stdout = groupErrorLines(stdout);
         const truncated = Buffer.byteLength(stdout) > maxOutput;
         if (truncated) {
           stdout = smartTruncate(stdout, maxOutput);
@@ -21354,6 +21579,65 @@ async function __cm_main(){${code}}
 __cm_main().then(()=>{${epilogue}}).catch(e=>{console.error(e);${epilogue}process.exit(1)});`;
 }
 
+// src/network.ts
+import dns from "node:dns";
+function isPrivateHost(hostname2) {
+  const h = hostname2.startsWith("[") && hostname2.endsWith("]") ? hostname2.slice(1, -1) : hostname2;
+  const lower = h.toLowerCase();
+  if (lower === "localhost" || lower === "0.0.0.0") return true;
+  if (/^0\./.test(h)) return true;
+  if (/^127\./.test(h)) return true;
+  if (/^10\./.test(h)) return true;
+  if (/^172\.(1[6-9]|2\d|3[01])\./.test(h)) return true;
+  if (/^192\.168\./.test(h)) return true;
+  if (/^169\.254\./.test(h)) return true;
+  if (/^100\.(6[4-9]|[7-9]\d|1[01]\d|12[0-7])\./.test(h)) return true;
+  if (lower === "::1") return true;
+  if (lower === "::" || lower === "0:0:0:0:0:0:0:0") return true;
+  const mappedMatch = lower.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/);
+  if (mappedMatch) return isPrivateHost(mappedMatch[1]);
+  if (/^fe[89ab]/i.test(h)) return true;
+  if (/^f[cd]/i.test(h)) return true;
+  return false;
+}
+async function resolveAndValidate(url) {
+  const parsed = new URL(url);
+  const hostname2 = parsed.hostname;
+  if (/^\d+\.\d+\.\d+\.\d+$/.test(hostname2) || hostname2.includes(":")) {
+    if (isPrivateHost(hostname2)) {
+      throw new Error(`Blocked: resolved IP ${hostname2} is a private/internal address`);
+    }
+    return { url, resolvedIp: null };
+  }
+  let resolvedIp = null;
+  let v4Error = false;
+  let v6Error = false;
+  try {
+    const { address } = await dns.promises.lookup(hostname2, { family: 4 });
+    if (isPrivateHost(address)) {
+      throw new Error(`Blocked: ${hostname2} resolved to private IP ${address}`);
+    }
+    resolvedIp = address;
+  } catch (err) {
+    if (err instanceof Error && err.message.startsWith("Blocked:")) throw err;
+    v4Error = true;
+  }
+  try {
+    const { address } = await dns.promises.lookup(hostname2, { family: 6 });
+    if (isPrivateHost(address)) {
+      throw new Error(`Blocked: ${hostname2} resolved to private IPv6 ${address}`);
+    }
+    if (!resolvedIp) resolvedIp = address;
+  } catch (err) {
+    if (err instanceof Error && err.message.startsWith("Blocked:")) throw err;
+    v6Error = true;
+  }
+  if (v4Error && v6Error) {
+    throw new Error(`DNS resolution failed for ${hostname2}: unable to verify host safety`);
+  }
+  return { url, resolvedIp };
+}
+
 // src/runtime/index.ts
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
@@ -21385,8 +21669,8 @@ var goPlugin = {
     return [runtime, "run", filePath];
   },
   preprocessCode(code) {
-    if (!code.includes("package ")) {
-      const hasImport = code.includes("import ");
+    if (!/^package\s/m.test(code)) {
+      const hasImport = /^import\s/m.test(code);
       if (hasImport) {
         return `package main
 
@@ -21405,7 +21689,7 @@ _ = fmt.Sprintf("")
   },
   wrapWithFileContent(code, filePath) {
     const escaped = JSON.stringify(filePath);
-    const hasPackage = code.includes("package ");
+    const hasPackage = /^package\s/m.test(code);
     if (hasPackage) {
       return code.replace(
         /(package\s+\w+\n)/,
@@ -21446,8 +21730,9 @@ var javascriptPlugin = {
   },
   wrapWithFileContent(code, filePath) {
     const escaped = JSON.stringify(filePath);
-    return `const FILE_CONTENT_PATH = ${escaped};
-const FILE_CONTENT = require("fs").readFileSync(FILE_CONTENT_PATH, "utf-8");
+    return `const {readFileSync: __cm_readFileSync} = await import("node:fs");
+const FILE_CONTENT_PATH = ${escaped};
+const FILE_CONTENT = __cm_readFileSync(FILE_CONTENT_PATH, "utf-8");
 ${code}`;
   }
 };
@@ -21519,7 +21804,7 @@ ${code}`;
 // src/runtime/languages/r.ts
 var rPlugin = {
   language: "r",
-  runtimeCandidates: ["Rscript", "r"],
+  runtimeCandidates: ["Rscript", "R"],
   fileExtension: ".R",
   buildCommand(runtime, filePath) {
     return [runtime, filePath];
@@ -21562,7 +21847,7 @@ var rustPlugin = {
     return [runtime, srcPath, "-o", binPath];
   },
   preprocessCode(code) {
-    if (!code.includes("fn main")) {
+    if (!/^fn\s+main\s*\(/m.test(code)) {
       return `fn main() {
 ${code}
 }`;
@@ -21575,7 +21860,7 @@ ${code}
 let file_content_path = ${escaped};
 let file_content = fs::read_to_string(file_content_path).unwrap();
 `;
-    if (code.includes("fn main")) {
+    if (/^fn\s+main\s*\(/m.test(code)) {
       return code.replace(/fn main\s*\(\s*\)\s*\{/, `fn main() {
 ${preamble}`);
     }
@@ -21611,8 +21896,9 @@ var typescriptPlugin = {
   },
   wrapWithFileContent(code, filePath) {
     const escaped = JSON.stringify(filePath);
-    return `const FILE_CONTENT_PATH = ${escaped};
-const FILE_CONTENT = require("fs").readFileSync(FILE_CONTENT_PATH, "utf-8");
+    return `const {readFileSync: __cm_readFileSync} = await import("node:fs");
+const FILE_CONTENT_PATH = ${escaped};
+const FILE_CONTENT = __cm_readFileSync(FILE_CONTENT_PATH, "utf-8");
 ${code}`;
   },
   // tsx and ts-node may be .cmd shims on Windows
@@ -21668,6 +21954,17 @@ function hasBun(runtimes) {
 }
 
 // src/stats.ts
+var BAR_WIDTH = 20;
+function asciiBar(ratio, width = BAR_WIDTH) {
+  const filled = Math.round(ratio * width);
+  const empty = width - filled;
+  return `[${"\u2588".repeat(filled)}${"\u2591".repeat(empty)}] ${(ratio * 100).toFixed(0)}%`;
+}
+function tokenCost(tokens) {
+  const sonnetCost = tokens / 1e6 * 3;
+  if (sonnetCost < 0.01) return "<$0.01";
+  return `~$${sonnetCost.toFixed(2)} (Sonnet)`;
+}
 var SessionTracker = class {
   stats = {
     calls: {},
@@ -21698,9 +21995,14 @@ var SessionTracker = class {
     const totalReturned = Object.values(snap.bytesReturned).reduce((a, b) => a + b, 0);
     const keptOut = snap.bytesIndexed + snap.bytesSandboxed;
     const totalProcessed = keptOut + totalReturned;
-    const savingsRatio = totalReturned > 0 ? totalProcessed / totalReturned : 1;
+    const savingsRatio = totalReturned > 0 ? totalProcessed / totalReturned : keptOut > 0 ? Number.POSITIVE_INFINITY : 1;
     const reductionPct = totalProcessed > 0 ? ((1 - totalReturned / totalProcessed) * 100).toFixed(1) : "0.0";
-    const estTokens = Math.round(totalReturned / 4);
+    const estTokensLo = Math.round(totalReturned / 5);
+    const estTokensHi = Math.round(totalReturned / 3);
+    const estTokensAvoidedLo = Math.round(keptOut / 5);
+    const estTokensAvoidedHi = Math.round(keptOut / 3);
+    const estTokensMid = Math.round(totalReturned / 4);
+    const estTokensAvoidedMid = Math.round(keptOut / 4);
     const lines = [];
     lines.push("## Session Statistics\n");
     lines.push("| Metric | Value |");
@@ -21710,18 +22012,33 @@ var SessionTracker = class {
     lines.push(`| Total data processed | ${formatBytes(totalProcessed)} |`);
     lines.push(`| Kept in sandbox | ${formatBytes(keptOut)} |`);
     lines.push(`| Context consumed | ${formatBytes(totalReturned)} |`);
-    lines.push(`| Est. tokens | ~${estTokens.toLocaleString()} |`);
     lines.push(
-      `| **Savings ratio** | **${savingsRatio.toFixed(1)}x** (${reductionPct}% reduction) |`
+      `| Est. tokens used | ~${estTokensLo.toLocaleString()}-${estTokensHi.toLocaleString()} tokens (${tokenCost(estTokensMid)}) |`
+    );
+    lines.push(
+      `| Est. tokens saved | ~${estTokensAvoidedLo.toLocaleString()}-${estTokensAvoidedHi.toLocaleString()} tokens (${tokenCost(estTokensAvoidedMid)}) |`
     );
+    const savingsLabel = Number.isFinite(savingsRatio) ? `${savingsRatio.toFixed(1)}x` : "\u221E";
+    lines.push(`| **Savings ratio** | **${savingsLabel}** (${reductionPct}% reduction) |`);
+    if (totalProcessed > 0) {
+      const savingsBar = asciiBar(keptOut / totalProcessed);
+      lines.push(`
+**Context savings:** ${savingsBar}`);
+      lines.push(
+        `  Sandbox: ${formatBytes(keptOut)} kept out | Context: ${formatBytes(totalReturned)} entered`
+      );
+    }
     if (totalCalls > 0) {
       lines.push("\n## Per-Tool Breakdown\n");
-      lines.push("| Tool | Calls | Context bytes | Est. tokens |");
-      lines.push("|------|-------|--------------|-------------|");
+      const maxBytes = Math.max(...Object.values(snap.bytesReturned));
       for (const [name, calls] of Object.entries(snap.calls)) {
         const bytes = snap.bytesReturned[name] ?? 0;
+        const tokLo = Math.round(bytes / 5);
+        const tokHi = Math.round(bytes / 3);
+        const barRatio = maxBytes > 0 ? bytes / maxBytes : 0;
+        const bar = "\u2588".repeat(Math.max(1, Math.round(barRatio * 15)));
         lines.push(
-          `| ${name} | ${calls} | ${formatBytes(bytes)} | ~${Math.round(bytes / 4).toLocaleString()} |`
+          `  ${name.padEnd(16)} ${String(calls).padStart(3)} calls  ${bar} ${formatBytes(bytes)} (~${tokLo.toLocaleString()}-${tokHi.toLocaleString()} tok)`
         );
       }
     }
@@ -21734,7 +22051,7 @@ Context-compress kept ${formatBytes(keptOut)} out of context (${reductionPct}% s
 };
 
 // src/store.ts
-import { readdirSync, unlinkSync } from "node:fs";
+import { mkdirSync as mkdirSync2, readdirSync, unlinkSync } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
 import { join as join3 } from "node:path";
 import Database from "better-sqlite3";
@@ -21825,20 +22142,15 @@ var STOPWORDS = /* @__PURE__ */ new Set([
   "how",
   "its",
   "may",
-  "new",
   "now",
   "old",
   "see",
   "way",
   "who",
   "did",
-  "get",
-  "got",
-  "let",
   "say",
   "she",
   "too",
-  "use",
   "will",
   "with",
   "this",
@@ -21852,7 +22164,6 @@ var STOPWORDS = /* @__PURE__ */ new Set([
   "them",
   "than",
   "each",
-  "make",
   "like",
   "just",
   "over",
@@ -21892,21 +22203,7 @@ var STOPWORDS = /* @__PURE__ */ new Set([
   "where",
   "here",
   "were",
-  "much",
-  "update",
-  "updates",
-  "updated",
-  "deps",
-  "dev",
-  "tests",
-  "test",
-  "add",
-  "added",
-  "fix",
-  "fixed",
-  "run",
-  "running",
-  "using"
+  "much"
 ]);
 var HEADING_RE = /^(#{1,4})\s+(.+)$/;
 var SEPARATOR_RE = /^[-_*]{3,}\s*$/;
@@ -21917,7 +22214,7 @@ var WORD_SPLIT_RE = /[^\p{L}\p{N}_-]+/u;
 function sanitizeQuery(raw) {
   const q = raw.replace(FTS_SPECIAL_RE, " ").replace(FTS_OPERATORS_RE, " ").trim();
   const words = q.split(/\s+/).filter((w) => w.length >= 2).map((w) => `"${w}"`);
-  return words.length > 0 ? words.join(" OR ") : '""';
+  return words.length > 0 ? words.join(" OR ") : "";
 }
 function levenshtein(a, b) {
   if (a.length === 0) return b.length;
@@ -21937,8 +22234,23 @@ function levenshtein(a, b) {
 var ContentStore = class {
   db;
   hasTrigramTable = false;
-  constructor(dbPath) {
-    const path = dbPath ?? join3(tmpdir2(), `context-compress-${process.pid}.db`);
+  // Cached prepared statements (initialized in initSchema, always available after constructor)
+  insertSourceStmt;
+  insertChunkStmt;
+  vocabCountStmt;
+  vocabInsertStmt;
+  constructor(options) {
+    let path;
+    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");
+      debug("Using persistent DB at", path);
+    } else {
+      path = (typeof options === "object" ? options?.dbPath : void 0) ?? join3(tmpdir2(), `context-compress-${process.pid}.db`);
+    }
     this.db = new Database(path);
     this.db.pragma("journal_mode = WAL");
     this.db.pragma("synchronous = NORMAL");
@@ -21966,6 +22278,14 @@ var ContentStore = class {
 				word TEXT PRIMARY KEY
 			);
 		`);
+    this.insertSourceStmt = this.db.prepare(
+      "INSERT INTO sources (label, chunk_count, code_chunk_count) VALUES (?, ?, ?)"
+    );
+    this.insertChunkStmt = this.db.prepare(
+      "INSERT INTO chunks (title, content, source_id, content_type) VALUES (?, ?, ?, ?)"
+    );
+    this.vocabCountStmt = this.db.prepare("SELECT COUNT(*) as cnt FROM vocabulary");
+    this.vocabInsertStmt = this.db.prepare("INSERT OR IGNORE INTO vocabulary (word) VALUES (?)");
   }
   /** Lazily create trigram table only when porter search returns 0 results */
   ensureTrigramTable() {
@@ -21991,12 +22311,8 @@ var ContentStore = class {
   index(content, label) {
     const isMarkdown = HEADING_RE.test(content) || content.includes("```") || content.includes("---");
     const chunks = isMarkdown ? chunkMarkdown(content) : chunkPlainText(content);
-    const insertSource = this.db.prepare(
-      "INSERT INTO sources (label, chunk_count, code_chunk_count) VALUES (?, ?, ?)"
-    );
-    const insertChunk = this.db.prepare(
-      "INSERT INTO chunks (title, content, source_id, content_type) VALUES (?, ?, ?, ?)"
-    );
+    const insertSource = this.insertSourceStmt;
+    const insertChunk = this.insertChunkStmt;
     const insertTrigram = this.hasTrigramTable ? this.db.prepare(
       "INSERT INTO chunks_trigram (title, content, source_id, content_type) VALUES (?, ?, ?, ?)"
     ) : null;
@@ -22028,6 +22344,9 @@ var ContentStore = class {
   search(query, options) {
     const limit = options?.limit ?? 3;
     const sanitized = sanitizeQuery(query);
+    if (!sanitized) {
+      return { query, results: [] };
+    }
     let hits = this.porterSearch(sanitized, options?.source, limit);
     if (hits.length > 0) {
       return { query, results: hits };
@@ -22040,29 +22359,31 @@ var ContentStore = class {
     const corrected = this.fuzzyCorrect(query);
     if (corrected && corrected !== query) {
       const correctedSanitized = sanitizeQuery(corrected);
-      hits = this.porterSearch(correctedSanitized, options?.source, limit);
-      if (hits.length > 0) {
-        return { query, results: hits, corrected };
+      if (correctedSanitized) {
+        hits = this.porterSearch(correctedSanitized, options?.source, limit);
+        if (hits.length > 0) {
+          return { query, results: hits, corrected };
+        }
       }
     }
     return { query, results: [] };
   }
-  porterSearch(sanitized, source, limit) {
+  ftsSearch(table, sanitized, source, limit) {
     const sourceFilter = source ? "AND sources.label LIKE '%' || ? || '%'" : "";
     const params = [sanitized];
     if (source) params.push(source);
     params.push(limit);
     const sql = `
 			SELECT
-				chunks.title,
-				chunks.content,
-				chunks.content_type,
+				${table}.title,
+				${table}.content,
+				${table}.content_type,
 				sources.label,
-				bm25(chunks, 2.0, 1.0) AS rank,
-				highlight(chunks, 1, char(2), char(3)) AS highlighted
-			FROM chunks
-			JOIN sources ON sources.id = chunks.source_id
-			WHERE chunks MATCH ? ${sourceFilter}
+				bm25(${table}, 2.0, 1.0) AS rank,
+				highlight(${table}, 1, char(2), char(3)) AS highlighted
+			FROM ${table}
+			JOIN sources ON sources.id = ${table}.source_id
+			WHERE ${table} MATCH ? ${sourceFilter}
 			ORDER BY rank
 			LIMIT ?
 		`;
@@ -22075,41 +22396,15 @@ var ContentStore = class {
         score: Math.abs(row.rank)
       }));
     } catch (e) {
-      debug("Porter search error:", e);
+      debug(`FTS search error (${table}):`, e);
       return [];
     }
   }
+  porterSearch(sanitized, source, limit) {
+    return this.ftsSearch("chunks", sanitized, source, limit);
+  }
   trigramSearch(sanitized, source, limit) {
-    const sourceFilter = source ? "AND sources.label LIKE '%' || ? || '%'" : "";
-    const params = [sanitized];
-    if (source) params.push(source);
-    params.push(limit);
-    const sql = `
-			SELECT
-				chunks_trigram.title,
-				chunks_trigram.content,
-				chunks_trigram.content_type,
-				sources.label,
-				bm25(chunks_trigram, 2.0, 1.0) AS rank,
-				highlight(chunks_trigram, 1, char(2), char(3)) AS highlighted
-			FROM chunks_trigram
-			JOIN sources ON sources.id = chunks_trigram.source_id
-			WHERE chunks_trigram MATCH ? ${sourceFilter}
-			ORDER BY rank
-			LIMIT ?
-		`;
-    try {
-      const rows = this.db.prepare(sql).all(...params);
-      return rows.map((row) => ({
-        title: row.title,
-        snippet: extractSnippet(row.highlighted),
-        source: row.label,
-        score: Math.abs(row.rank)
-      }));
-    } catch (e) {
-      debug("Trigram search error:", e);
-      return [];
-    }
+    return this.ftsSearch("chunks_trigram", sanitized, source, limit);
   }
   /**
    * Fuzzy correction using vocabulary + Levenshtein distance.
@@ -22123,7 +22418,7 @@ var ContentStore = class {
       const maxDist = word.length <= 4 ? 1 : word.length <= 12 ? 2 : 3;
       const minLen = word.length - maxDist;
       const maxLen = word.length + maxDist;
-      const candidates = this.db.prepare("SELECT word FROM vocabulary WHERE length(word) BETWEEN ? AND ?").all(minLen, maxLen);
+      const candidates = this.db.prepare("SELECT word FROM vocabulary WHERE length(word) BETWEEN ? AND ? LIMIT 500").all(minLen, maxLen);
       let bestWord = word;
       let bestDist = maxDist + 1;
       for (const { word: candidate } of candidates) {
@@ -22142,11 +22437,11 @@ var ContentStore = class {
    * Update vocabulary table from content (bounded to MAX_VOCABULARY).
    */
   updateVocabulary(content) {
-    const currentCount = this.db.prepare("SELECT COUNT(*) as cnt FROM vocabulary").get().cnt;
+    const currentCount = this.vocabCountStmt.get().cnt;
     if (currentCount >= MAX_VOCABULARY) return;
     const words = content.split(WORD_SPLIT_RE).filter((w) => w.length >= 3 && !STOPWORDS.has(w.toLowerCase()));
     const unique = new Set(words.map((w) => w.toLowerCase()));
-    const insert = this.db.prepare("INSERT OR IGNORE INTO vocabulary (word) VALUES (?)");
+    const insert = this.vocabInsertStmt;
     let added = 0;
     for (const word of unique) {
       if (currentCount + added >= MAX_VOCABULARY) break;
@@ -22163,7 +22458,7 @@ var ContentStore = class {
     ).get(...sourceId ? [sourceId] : []).cnt;
     if (totalChunks === 0) return [];
     const filter = sourceId ? " WHERE source_id = ?" : "";
-    const stmt = this.db.prepare(`SELECT content FROM chunks${filter}`);
+    const stmt = this.db.prepare(`SELECT content FROM chunks${filter} LIMIT 500`);
     const rows = sourceId ? stmt.all(sourceId) : stmt.all();
     const docFreq = /* @__PURE__ */ new Map();
     for (const row of rows) {
@@ -22188,6 +22483,21 @@ var ContentStore = class {
     scored.sort((a, b) => b.score - a.score);
     return scored.slice(0, 40).map((s) => s.word);
   }
+  /**
+   * List all indexed sources with metadata.
+   */
+  listSources() {
+    const rows = this.db.prepare(
+      "SELECT id, label, chunk_count, code_chunk_count, indexed_at FROM sources ORDER BY indexed_at DESC"
+    ).all();
+    return rows.map((row) => ({
+      id: row.id,
+      label: row.label,
+      chunkCount: row.chunk_count,
+      codeChunks: row.code_chunk_count,
+      indexedAt: row.indexed_at
+    }));
+  }
   /**
    * Get store statistics.
    */
@@ -22251,6 +22561,10 @@ function chunkMarkdown(content) {
     }
     currentLines.push(line);
   }
+  if (inFence) {
+    debug("Warning: unclosed code fence detected during markdown chunking");
+    hasCode = true;
+  }
   flush();
   return chunks;
 }
@@ -22264,7 +22578,7 @@ function chunkPlainText(content, linesPerChunk = 20, overlap = 2) {
       return {
         title: trimmed.split("\n")[0].slice(0, 80),
         content: trimmed,
-        hasCode: FENCE_RE.test(trimmed)
+        hasCode: /`{3,}/.test(trimmed)
       };
     }).filter(Boolean);
   }
@@ -22313,8 +22627,8 @@ function cleanupStaleDbs() {
   return cleaned;
 }
 
-// src/server.ts
-var LANGUAGES = [
+// src/types.ts
+var ALL_LANGUAGES = [
   "javascript",
   "typescript",
   "python",
@@ -22327,10 +22641,19 @@ var LANGUAGES = [
   "r",
   "elixir"
 ];
+
+// src/server.ts
+var LANGUAGE_ENUM = ALL_LANGUAGES;
 var projectDir = process.env.CLAUDE_PROJECT_DIR ?? process.cwd();
 function isWithinProject(absPath) {
-  const normalized = resolve(absPath);
-  return normalized === projectDir || normalized.startsWith(`${projectDir}/`);
+  try {
+    const normalized = realpathSync(resolve(absPath));
+    const realProjectDir = realpathSync(projectDir);
+    return normalized === realProjectDir || normalized.startsWith(`${realProjectDir}/`);
+  } catch {
+    const normalized = resolve(absPath);
+    return normalized === projectDir || normalized.startsWith(`${projectDir}/`);
+  }
 }
 function getVersion() {
   try {
@@ -22342,6 +22665,57 @@ function getVersion() {
     return "1.0.0";
   }
 }
+function compactLabel(normal, level) {
+  if (level === "ultra") {
+    return normal.replace(/\*\*/g, "").replace(/Use search\(queries: \[\.\.\.]\) to retrieve.*$/gm, "\u2192 search() for more").replace(/Searchable terms: .+$/gm, "");
+  }
+  if (level === "compact") {
+    return normal.replace(
+      /Use search\(queries: \[\.\.\.]\) to retrieve full content of any section\./,
+      "\u2192 search() for details"
+    );
+  }
+  return normal;
+}
+async function limitConcurrency(tasks, limit) {
+  const results = new Array(tasks.length);
+  let nextIndex = 0;
+  async function runNext() {
+    while (nextIndex < tasks.length) {
+      const index = nextIndex++;
+      try {
+        const value = await tasks[index]();
+        results[index] = { status: "fulfilled", value };
+      } catch (reason) {
+        results[index] = { status: "rejected", reason };
+      }
+    }
+  }
+  const workers = Array.from({ length: Math.min(limit, tasks.length) }, () => runNext());
+  await Promise.all(workers);
+  return results;
+}
+function detectInjectionPatterns(content) {
+  const warnings = [];
+  const patterns = [
+    { re: /ignore\s+(all\s+)?previous\s+instructions/i, label: "instruction override" },
+    { re: /you\s+are\s+now\s+/i, label: "role reassignment" },
+    {
+      re: /(?:^|\n)\s*system\s*:\s*(?:you are|you're|as an? )/im,
+      label: "system prompt injection"
+    },
+    { re: /\[INST\]|\[\/INST\]|<\|im_start\|>|<\|im_end\|>/i, label: "chat template injection" },
+    { re: /\n\n(?:Human|Assistant):/m, label: "chat delimiter injection" },
+    { re: /reveal\s+(your|the)\s+(system|secret|confidential)/i, label: "data exfiltration" },
+    { re: /act\s+as\s+(if\s+you\s+are|a)\s+/i, label: "role manipulation" }
+  ];
+  for (const { re, label } of patterns) {
+    if (re.test(content)) {
+      warnings.push(label);
+    }
+  }
+  return warnings;
+}
 async function createServer(config3) {
   const version2 = getVersion();
   debug("Version:", version2);
@@ -22350,8 +22724,48 @@ async function createServer(config3) {
   const bunDetected = hasBun(runtimes);
   debug("Runtimes detected:", runtimes.size);
   const executor = new SubprocessExecutor(runtimes, config3);
-  const store = new ContentStore();
+  let store;
+  let dbFallback = false;
+  try {
+    store = new ContentStore({ persistDb: config3.persistDb, dbDir: config3.dbDir });
+  } catch (e) {
+    debug("Failed to create DB, falling back to in-memory:", e);
+    store = new ContentStore(":memory:");
+    dbFallback = true;
+  }
   const tracker = new SessionTracker();
+  function applyIntentFilter(output, intent, sourceLabel) {
+    if (Buffer.byteLength(output) <= config3.intentSearchThreshold) return output;
+    const indexed = store.index(output, sourceLabel);
+    tracker.trackIndexed(Buffer.byteLength(output));
+    const searchResults = store.search(intent, { limit: 3 });
+    const terms = store.getDistinctiveTerms(indexed.sourceId);
+    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)}
+`;
+    }
+    if (terms.length > 0 && config3.compressionLevel !== "ultra") {
+      filtered += `
+Searchable terms: ${terms.join(", ")}
+`;
+    }
+    filtered += "\nUse search(queries: [...]) to retrieve full content of any section.";
+    return compactLabel(filtered, config3.compressionLevel);
+  }
+  const shutdown = () => {
+    try {
+      store.close();
+    } catch {
+    }
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  process.on("beforeExit", shutdown);
   const searchCalls = [];
   const server2 = new McpServer({
     name: "context-compress",
@@ -22359,11 +22773,11 @@ async function createServer(config3) {
   });
   server2.tool(
     "execute",
-    `Execute code in a sandboxed subprocess. Only stdout enters context \u2014 raw data stays in the subprocess. Use instead of bash/cat when output would exceed 20 lines. ${bunDetected ? "(Bun detected \u2014 JS/TS runs 3-5x faster) " : ""}Available: ${LANGUAGES.join(", ")}.
+    `Execute code in a sandboxed subprocess. Only stdout enters context \u2014 raw data stays in the subprocess. Use instead of bash/cat when output would exceed ~5KB. ${bunDetected ? "(Bun detected \u2014 JS/TS runs 3-5x faster) " : ""}Available: ${ALL_LANGUAGES.join(", ")}.
 
 PREFER THIS OVER BASH for: API calls (gh, curl, aws), test runners (npm test, pytest), git queries (git log, git diff), data processing, and ANY CLI command that may produce large output. Bash should only be used for file mutations, git writes, and navigation.`,
     {
-      language: external_exports.enum(LANGUAGES).describe("Runtime language"),
+      language: external_exports.enum(LANGUAGE_ENUM).describe("Runtime language"),
       code: external_exports.string().describe(
         "Source code to execute. Use console.log (JS/TS), print (Python/Ruby/Perl/R), echo (Shell), echo (PHP), fmt.Println (Go), or IO.puts (Elixir) to output a summary to context."
       ),
@@ -22384,27 +22798,8 @@ PREFER THIS OVER BASH for: API calls (gh, curl, aws), test runners (npm test, py
 STDERR:
 ${result.stderr}`;
       }
-      if (intent && Buffer.byteLength(output) > config3.intentSearchThreshold) {
-        const indexed = store.index(output, `execute:${language}`);
-        tracker.trackIndexed(Buffer.byteLength(output));
-        const searchResults = store.search(intent, { limit: 3 });
-        const terms = store.getDistinctiveTerms(indexed.sourceId);
-        let filtered = `Indexed ${indexed.totalChunks} sections from execute output.
-`;
-        filtered += `${searchResults.results.length} sections matched "${intent}":
-
-`;
-        for (const hit of searchResults.results) {
-          filtered += `  - **${hit.title}**: ${hit.snippet.slice(0, 200)}
-`;
-        }
-        if (terms.length > 0) {
-          filtered += `
-Searchable terms: ${terms.join(", ")}
-`;
-        }
-        filtered += "\nUse search(queries: [...]) to retrieve full content of any section.";
-        output = filtered;
+      if (intent) {
+        output = applyIntentFilter(output, intent, `execute:${language}`);
       }
       const responseBytes = Buffer.byteLength(output);
       tracker.trackCall("execute", responseBytes);
@@ -22416,7 +22811,7 @@ Searchable terms: ${terms.join(", ")}
     "Read a file and process it without loading contents into context. The file is read into a FILE_CONTENT variable inside the sandbox. Only your printed summary enters context.\n\nPREFER THIS OVER Read/cat for: log files, data files (CSV, JSON, XML), large source files for analysis, and any file where you need to extract specific information rather than read the entire content.",
     {
       path: external_exports.string().describe("Absolute file path or relative to project root"),
-      language: external_exports.enum(LANGUAGES).describe("Runtime language"),
+      language: external_exports.enum(LANGUAGE_ENUM).describe("Runtime language"),
       code: external_exports.string().describe(
         "Code to process FILE_CONTENT. Print summary via console.log/print/echo/IO.puts."
       ),
@@ -22448,27 +22843,8 @@ Searchable terms: ${terms.join(", ")}
 STDERR:
 ${result.stderr}`;
       }
-      if (intent && Buffer.byteLength(output) > config3.intentSearchThreshold) {
-        const indexed = store.index(output, `file:${filePath}`);
-        tracker.trackIndexed(Buffer.byteLength(output));
-        const searchResults = store.search(intent, { limit: 3 });
-        const terms = store.getDistinctiveTerms(indexed.sourceId);
-        let filtered = `Indexed ${indexed.totalChunks} sections from "${filePath}" into knowledge base.
-`;
-        filtered += `${searchResults.results.length} sections matched "${intent}":
-
-`;
-        for (const hit of searchResults.results) {
-          filtered += `  - **${hit.title}**: ${hit.snippet.slice(0, 200)}
-`;
-        }
-        if (terms.length > 0) {
-          filtered += `
-Searchable terms: ${terms.join(", ")}
-`;
-        }
-        filtered += "\nUse search(queries: [...]) to retrieve full content of any section.";
-        output = filtered;
+      if (intent) {
+        output = applyIntentFilter(output, intent, `file:${filePath}`);
       }
       const responseBytes = Buffer.byteLength(output);
       tracker.trackCall("execute_file", responseBytes);
@@ -22498,9 +22874,38 @@ Searchable terms: ${terms.join(", ")}
             ]
           };
         }
-        text = readFileSync2(absPath, "utf-8");
-        label = source ?? filePath;
+        try {
+          const fileStat = statSync(absPath);
+          if (fileStat.size > 50 * 1024 * 1024) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Error: file "${filePath}" is too large (${(fileStat.size / 1024 / 1024).toFixed(1)}MB). Max 50MB.`
+                }
+              ]
+            };
+          }
+          text = readFileSync2(absPath, "utf-8");
+          label = source ?? filePath;
+        } catch (e) {
+          const msg = e instanceof Error ? e.message : String(e);
+          return {
+            content: [{ type: "text", text: `Error reading "${filePath}": ${msg}` }]
+          };
+        }
       } else if (content) {
+        const contentBytes = Buffer.byteLength(content);
+        if (contentBytes > 50 * 1024 * 1024) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error: content too large (${(contentBytes / 1024 / 1024).toFixed(1)}MB). Max 50MB.`
+              }
+            ]
+          };
+        }
         text = content;
       } else {
         return {
@@ -22587,8 +22992,7 @@ ${hit.snippet}
             content: [{ type: "text", text: "Error: only http/https URLs are allowed" }]
           };
         }
-        const hostname2 = parsed.hostname;
-        if (hostname2 === "localhost" || hostname2 === "127.0.0.1" || hostname2 === "::1" || hostname2 === "0.0.0.0" || hostname2.startsWith("10.") || hostname2.startsWith("172.16.") || hostname2.startsWith("192.168.") || hostname2.startsWith("169.254.")) {
+        if (isPrivateHost(parsed.hostname)) {
           return {
             content: [
               { type: "text", text: "Error: internal/private URLs are not allowed" }
@@ -22600,8 +23004,22 @@ ${hit.snippet}
           content: [{ type: "text", text: `Error: invalid URL "${url}"` }]
         };
       }
+      let resolvedIp = null;
+      try {
+        const validated = await resolveAndValidate(url);
+        resolvedIp = validated.resolvedIp;
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: ${err instanceof Error ? err.message : "DNS validation failed"}`
+            }
+          ]
+        };
+      }
       const label = source ?? url;
-      const fetchCode = buildFetchCode(url);
+      const fetchCode = buildFetchCode(url, resolvedIp);
       const result = await executor.execute({
         language: "javascript",
         code: fetchCode,
@@ -22614,6 +23032,7 @@ ${hit.snippet}
       }
       const markdown = result.stdout;
       tracker.trackSandboxed(result.networkBytes ?? 0);
+      const injectionWarnings = detectInjectionPatterns(markdown);
       const indexed = store.index(markdown, label);
       tracker.trackIndexed(Buffer.byteLength(markdown));
       const preview = markdown.slice(0, 3072);
@@ -22630,6 +23049,11 @@ ${preview}`;
 Searchable terms: ${terms.join(", ")}`;
       }
       output += "\n\nUse search(queries: [...]) to retrieve full content of any section.";
+      if (injectionWarnings.length > 0) {
+        output += `
+
+\u26A0 Content safety notice: detected patterns (${injectionWarnings.join(", ")}). Review indexed content before relying on it.`;
+      }
       tracker.trackCall("fetch_and_index", Buffer.byteLength(output));
       return { content: [{ type: "text", text: output }] };
     }
@@ -22650,15 +23074,16 @@ Searchable terms: ${terms.join(", ")}`;
       timeout: external_exports.number().default(6e4).describe("Max execution time in ms (default: 60s)")
     },
     async ({ commands, queries, timeout }) => {
-      const commandResults = await Promise.allSettled(
-        commands.map(async (cmd) => {
+      const commandResults = await limitConcurrency(
+        commands.map((cmd) => async () => {
           const result = await executor.execute({
             language: "shell",
             code: cmd.command,
             timeout
           });
           return { label: cmd.label, result };
-        })
+        }),
+        4
       );
       let combined = "";
       const inventory = [];
@@ -22729,7 +23154,7 @@ Searchable terms: ${terms.join(", ")}`;
   );
   server2.tool(
     "stats",
-    "Returns context consumption statistics for the current session. Shows total bytes returned to context, breakdown by tool, call counts, estimated token usage, and context savings ratio.",
+    "Returns context consumption statistics for the current session. Shows total bytes returned to context, breakdown by tool, call counts, estimated token usage, context savings ratio, and visual charts.",
     {},
     async () => {
       const report = tracker.formatReport();
@@ -22737,6 +23162,82 @@ Searchable terms: ${terms.join(", ")}`;
       return { content: [{ type: "text", text: report }] };
     }
   );
+  server2.tool(
+    "discover",
+    "Shows what's in the knowledge base and suggests optimization opportunities. Lists all indexed sources, chunk counts, searchable terms, and recommends next actions. Use this to understand what data is available for search.",
+    {},
+    async () => {
+      const storeStats = store.getStats();
+      const snap = tracker.getSnapshot();
+      const lines = [];
+      lines.push("## Knowledge Base Discovery\n");
+      if (storeStats.totalSources === 0) {
+        lines.push("No content indexed yet. Use these tools to build the knowledge base:\n");
+        lines.push("- `batch_execute` \u2014 run commands and auto-index output");
+        lines.push("- `execute` with `intent` \u2014 auto-indexes large output");
+        lines.push("- `index` \u2014 index documentation or files");
+        lines.push("- `fetch_and_index` \u2014 fetch and index web pages");
+      } else {
+        lines.push("| Metric | Value |");
+        lines.push("|--------|-------|");
+        lines.push(`| Indexed sources | ${storeStats.totalSources} |`);
+        lines.push(`| Total chunks | ${storeStats.totalChunks} |`);
+        lines.push(`| Vocabulary size | ${storeStats.vocabularySize} |`);
+        lines.push(
+          `| Trigram index | ${storeStats.hasTrigramTable ? "active" : "lazy (not yet needed)"} |`
+        );
+        const sources = store.listSources();
+        if (sources.length > 0) {
+          lines.push("\n### Indexed Sources\n");
+          for (const src of sources) {
+            lines.push(
+              `- **${src.label}** \u2014 ${src.chunkCount} chunks${src.codeChunks > 0 ? ` (${src.codeChunks} with code)` : ""}`
+            );
+          }
+        }
+        const terms = store.getDistinctiveTerms();
+        if (terms.length > 0) {
+          lines.push("\n### Top Searchable Terms\n");
+          lines.push(terms.slice(0, 20).join(", "));
+        }
+      }
+      lines.push("\n### Optimization Suggestions\n");
+      const totalCalls = Object.values(snap.calls).reduce((a, b) => a + b, 0);
+      if (totalCalls === 0) {
+        lines.push("- Start by using `batch_execute` to run multiple commands at once");
+      } else {
+        const searchCalls2 = snap.calls.search ?? 0;
+        const executeCalls = snap.calls.execute ?? 0;
+        const batchCalls = snap.calls.batch_execute ?? 0;
+        if (executeCalls > 3 && batchCalls === 0) {
+          lines.push(
+            "- **Use batch_execute** \u2014 you've made multiple execute calls that could be batched into one"
+          );
+        }
+        if (searchCalls2 > 5) {
+          lines.push("- **Batch your searches** \u2014 pass multiple queries in a single search() call");
+        }
+        if (storeStats.totalChunks > 50) {
+          lines.push(
+            "- **Use source filtering** \u2014 scope searches with `source` parameter for faster, targeted results"
+          );
+        }
+        if (storeStats.totalSources === 0 && totalCalls > 2) {
+          lines.push(
+            "- **Index more content** \u2014 use `intent` parameter in execute calls to auto-index large output"
+          );
+        }
+      }
+      if (dbFallback) {
+        lines.push(
+          "\n\u26A0 **Warning:** Persistent DB creation failed \u2014 using in-memory storage. Indexed data will not survive restarts."
+        );
+      }
+      const output = lines.join("\n");
+      tracker.trackCall("discover", Buffer.byteLength(output));
+      return { content: [{ type: "text", text: output }] };
+    }
+  );
   return {
     async start() {
       const transport = new StdioServerTransport();
@@ -22745,11 +23246,21 @@ Searchable terms: ${terms.join(", ")}`;
     }
   };
 }
-function buildFetchCode(url) {
-  const escaped = JSON.stringify(url);
-  return `
-const url = ${escaped};
-const resp = await fetch(url);
+function buildFetchCode(url, resolvedIp) {
+  let fetchSetup;
+  if (resolvedIp) {
+    const pinnedUrl = new URL(url);
+    const originalHost = pinnedUrl.host;
+    pinnedUrl.hostname = resolvedIp;
+    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 html = await resp.text();
 
@@ -22785,12 +23296,15 @@ md = md.replace(/<br\\s*\\/?>/gi, "\\n");
 md = md.replace(/<[^>]+>/g, "");
 
 // Decode entities
-md = md.replace(/&amp;/g, "&")
-  .replace(/&lt;/g, "<")
+md = md.replace(/&lt;/g, "<")
   .replace(/&gt;/g, ">")
   .replace(/&quot;/g, '"')
   .replace(/&#39;/g, "'")
-  .replace(/&nbsp;/g, " ");
+  .replace(/&apos;/g, "'")
+  .replace(/&nbsp;/g, " ")
+  .replace(/&#(\\d+);/g, (_, n) => { const c = parseInt(n, 10); return c > 0 && c <= 0x10FFFF ? String.fromCodePoint(c) : ''; })
+  .replace(/&#x([0-9a-fA-F]+);/g, (_, h) => { const c = parseInt(h, 16); return c > 0 && c <= 0x10FFFF ? String.fromCodePoint(c) : ''; })
+  .replace(/&amp;/g, "&");
 
 // Clean whitespace
 md = md.replace(/\\n{3,}/g, "\\n\\n").trim();