context-compress 2026.3.21 → 2026.5.0

package/dist/server.bundle.mjs

@@ -2980,7 +2980,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve2.call(this, root, ref);
+      let _sch = resolve5.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a = root.localRefs) === null || _a === void 0 ? void 0 : _a[ref];
         const { schemaId } = this.opts;
@@ -3007,7 +3007,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve2(root, ref) {
+    function resolve5(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -3582,7 +3582,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve2(baseURI, relativeURI, options) {
+    function resolve5(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse3(baseURI, schemelessOptions), parse3(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
@@ -3809,7 +3809,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize,
-      resolve: resolve2,
+      resolve: resolve5,
       resolveComponent,
       equal,
       serialize,
@@ -11061,9 +11061,7 @@ function debug(...args) {
 }
 
 // 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";
+import { join as join4 } from "node:path";
 
 // node_modules/zod/v4/core/core.js
 var NEVER2 = Object.freeze({
@@ -19096,7 +19094,7 @@ var Protocol = class {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
-        await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
+        await new Promise((resolve5) => setTimeout(resolve5, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error2) {
@@ -19113,7 +19111,7 @@ var Protocol = class {
    */
   request(request, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve5, reject) => {
       const earlyReject = (error2) => {
         reject(error2);
       };
@@ -19191,7 +19189,7 @@ var Protocol = class {
           if (!parseResult.success) {
             reject(parseResult.error);
           } else {
-            resolve2(parseResult.data);
+            resolve5(parseResult.data);
           }
         } catch (error2) {
           reject(error2);
@@ -19452,12 +19450,12 @@ var Protocol = class {
       }
     } catch {
     }
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve5, reject) => {
       if (signal.aborted) {
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve2, interval);
+      const timeoutId = setTimeout(resolve5, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -20557,7 +20555,7 @@ var McpServer = class {
     let task = createTaskResult.task;
     const pollInterval = task.pollInterval ?? 5e3;
     while (task.status !== "completed" && task.status !== "failed" && task.status !== "cancelled") {
-      await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
+      await new Promise((resolve5) => setTimeout(resolve5, pollInterval));
       const updatedTask = await extra.taskStore.getTask(taskId);
       if (!updatedTask) {
         throw new McpError(ErrorCode.InternalError, `Task ${taskId} not found during polling`);
@@ -21200,12 +21198,12 @@ var StdioServerTransport = class {
     this.onclose?.();
   }
   send(message) {
-    return new Promise((resolve2) => {
+    return new Promise((resolve5) => {
       const json = serializeMessage(message);
       if (this._stdout.write(json)) {
-        resolve2();
+        resolve5();
       } else {
-        this._stdout.once("drain", resolve2);
+        this._stdout.once("drain", resolve5);
       }
     });
   }
@@ -21217,6 +21215,510 @@ import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join as join2 } from "node:path";
 
+// src/filters.ts
+var DEFAULT_MODE = "balanced";
+function applyCommandFilter(code, stdout, mode = DEFAULT_MODE) {
+  if (mode === "conservative") return { output: stdout, filtered: false };
+  const cmd = code.trim().split(/\s+/)[0];
+  const fullCmd = code.trim();
+  if (cmd === "git") return filterGit(fullCmd, stdout, mode);
+  if (cmd === "npm" || cmd === "yarn" || cmd === "pnpm" || cmd === "bun")
+    return filterPackageManager(fullCmd, stdout, mode);
+  if (fullCmd.includes("test") || fullCmd.includes("jest") || fullCmd.includes("vitest") || fullCmd.includes("pytest") || fullCmd.includes("cargo test")) {
+    return filterTestOutput(stdout);
+  }
+  if (cmd === "cargo" || cmd === "make" || cmd === "gradle")
+    return filterBuildOutput(fullCmd, stdout);
+  if (cmd === "docker" || cmd === "kubectl") return filterContainerOutput(fullCmd, stdout);
+  if (cmd === "ls" || cmd === "find" || cmd === "tree")
+    return filterFileList(fullCmd, stdout, mode);
+  if (cmd === "grep" || cmd === "rg" || cmd === "ripgrep") {
+    if (mode === "aggressive") return filterGrep(stdout);
+  }
+  if (mode === "aggressive") {
+    if (cmd === "df") return filterDf(stdout);
+    if (cmd === "du") return filterDu(stdout);
+    if (cmd === "ps") return filterPs(stdout);
+  }
+  return { output: stdout, filtered: false };
+}
+function filterGit(cmd, stdout, mode = DEFAULT_MODE) {
+  if (/git\s+(push|pull|fetch|clone)/.test(cmd)) {
+    const lines = stdout.split("\n");
+    const filtered = lines.filter(
+      (l) => !l.startsWith("remote: Counting") && !l.startsWith("remote: Compressing") && !l.startsWith("remote: Total") && !l.includes("Unpacking objects:") && !l.includes("Receiving objects:") && !l.includes("Resolving deltas:") && !/^\s*\d+%/.test(l)
+    );
+    return { output: filtered.join("\n"), filtered: true };
+  }
+  if (/git\s+status/.test(cmd)) {
+    return { output: filterGitStatus(stdout, mode), filtered: true };
+  }
+  if (/git\s+log/.test(cmd) && !cmd.includes("--oneline")) {
+    if (mode === "aggressive") {
+      return { output: aggressiveGitLog(stdout), filtered: true };
+    }
+    if (mode === "balanced") {
+      const truncated = balancedGitLog(stdout);
+      if (truncated.length < stdout.length) {
+        return { output: truncated, filtered: true };
+      }
+    }
+  }
+  if (/git\s+diff/.test(cmd) && mode === "aggressive") {
+    if (/--(stat|name-only|name-status|shortstat|numstat)\b/.test(cmd)) {
+      return { output: stdout, filtered: false };
+    }
+    return { output: aggressiveGitDiff(stdout), filtered: true };
+  }
+  return { output: stdout, filtered: false };
+}
+function filterGitStatus(stdout, mode) {
+  const lines = stdout.split("\n");
+  const balanced = lines.filter((l) => !l.startsWith("  (use ") && l.trim() !== "");
+  if (mode !== "aggressive") return balanced.join("\n");
+  const out = [];
+  for (const l of balanced) {
+    if (/^On branch/.test(l)) {
+      out.push(l.replace(/^On branch /, "* "));
+      continue;
+    }
+    if (/^Your branch is/.test(l)) continue;
+    if (/^Changes (to be committed|not staged for commit):/.test(l)) continue;
+    if (/^Untracked files:/.test(l)) {
+      out.push("? Untracked:");
+      continue;
+    }
+    if (/^no changes added to commit/.test(l)) continue;
+    if (/^nothing to commit/.test(l)) {
+      out.push("(clean)");
+      continue;
+    }
+    const m = l.match(/^\s*(modified|new file|deleted|renamed|typechange):\s*(.+)$/);
+    if (m) {
+      const code = { modified: "M", "new file": "A", deleted: "D", renamed: "R", typechange: "T" }[m[1]] ?? "?";
+      out.push(`${code} ${m[2]}`);
+      continue;
+    }
+    out.push(l);
+  }
+  return out.join("\n");
+}
+function aggressiveGitLog(stdout) {
+  const lines = stdout.split("\n");
+  const out = [];
+  let sha = "";
+  let author = "";
+  let date3 = "";
+  let subject = "";
+  let inCommit = false;
+  let blanksAfterDate = 0;
+  const flush = () => {
+    if (!sha) return;
+    const reltime = date3 ? ` (${humanReltime(date3)})` : "";
+    const auth = author ? ` <${author.replace(/\s*<.*?>/, "").trim()}>` : "";
+    out.push(`${sha.slice(0, 7)} ${subject}${reltime}${auth}`);
+  };
+  for (const line of lines) {
+    const m = line.match(/^commit\s+([0-9a-f]{7,40})/);
+    if (m) {
+      flush();
+      sha = m[1];
+      author = "";
+      date3 = "";
+      subject = "";
+      inCommit = true;
+      blanksAfterDate = 0;
+      continue;
+    }
+    if (!inCommit) continue;
+    if (/^Author:\s/.test(line)) {
+      author = line.replace(/^Author:\s+/, "").trim();
+      continue;
+    }
+    if (/^Date:\s/.test(line)) {
+      date3 = line.replace(/^Date:\s+/, "").trim();
+      continue;
+    }
+    if (line.trim() === "") {
+      blanksAfterDate++;
+      continue;
+    }
+    if (!subject && blanksAfterDate >= 1) {
+      subject = line.trim();
+    }
+  }
+  flush();
+  return out.join("\n");
+}
+var BALANCED_GIT_LOG_BODY_LINES = 3;
+function balancedGitLog(stdout) {
+  const lines = stdout.split("\n");
+  const out = [];
+  let bodyKept = 0;
+  let bodyDropped = 0;
+  let subjectSeen = false;
+  let inCommit = false;
+  let inBody = false;
+  let blanksAfterDate = 0;
+  const flushOmitted = () => {
+    if (bodyDropped > 0) {
+      out.push(`    [+${bodyDropped} lines omitted]`);
+      bodyDropped = 0;
+    }
+  };
+  for (const line of lines) {
+    if (/^commit\s+[0-9a-f]{7,40}/.test(line)) {
+      flushOmitted();
+      out.push(line);
+      inCommit = true;
+      inBody = false;
+      subjectSeen = false;
+      bodyKept = 0;
+      blanksAfterDate = 0;
+      continue;
+    }
+    if (!inCommit) {
+      out.push(line);
+      continue;
+    }
+    if (/^(Author|Date|Merge):\s/.test(line)) {
+      out.push(line);
+      continue;
+    }
+    if (line.trim() === "") {
+      out.push(line);
+      blanksAfterDate++;
+      continue;
+    }
+    if (blanksAfterDate >= 1) inBody = true;
+    if (inBody) {
+      if (!subjectSeen) {
+        subjectSeen = true;
+        out.push(line);
+        continue;
+      }
+      if (bodyKept >= BALANCED_GIT_LOG_BODY_LINES) {
+        bodyDropped++;
+        continue;
+      }
+      bodyKept++;
+    }
+    out.push(line);
+  }
+  flushOmitted();
+  return out.join("\n");
+}
+function aggressiveGitDiff(stdout) {
+  const lines = stdout.split("\n");
+  const out = [];
+  let currentFile = "";
+  for (const line of lines) {
+    const fm = line.match(/^diff --git a\/(.+?) b\//);
+    if (fm) {
+      currentFile = fm[1];
+      out.push(`@@ ${currentFile}`);
+      continue;
+    }
+    if (/^---\s|^\+\+\+\s|^index\s|^@@\s/.test(line)) continue;
+    if (line.startsWith("+") || line.startsWith("-")) out.push(line);
+  }
+  return out.join("\n");
+}
+function humanReltime(dateStr) {
+  const d = new Date(dateStr);
+  if (Number.isNaN(d.getTime())) return dateStr;
+  const ms = Date.now() - d.getTime();
+  const hours = Math.round(ms / 36e5);
+  if (hours < 1) return "just now";
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.round(hours / 24);
+  if (days < 30) return `${days}d ago`;
+  const months = Math.round(days / 30);
+  if (months < 12) return `${months}mo ago`;
+  return `${Math.round(months / 12)}y ago`;
+}
+function filterPackageManager(cmd, stdout, mode = DEFAULT_MODE) {
+  if (/\b(install|add|i)\b/.test(cmd)) {
+    const lines = stdout.split("\n");
+    const filtered = lines.filter(
+      (l) => !l.startsWith("npm warn") && !l.includes("packages are looking for funding") && !l.includes("run `npm fund`") && !l.startsWith("npm notice") && !/^[\s│├└─]+$/.test(l) && // tree-drawing characters
+      !/^\s*$/.test(l)
+    );
+    if (mode === "aggressive") {
+      const summaryOnly = filtered.filter(
+        (l) => /^(added|removed|changed|audited)\s+\d+/.test(l) || /vulnerabilit(y|ies)/i.test(l) || /^npm\s+ERR/.test(l)
+      );
+      return { output: summaryOnly.join("\n"), filtered: true };
+    }
+    return { output: filtered.join("\n"), filtered: true };
+  }
+  if (/\btest\b/.test(cmd)) {
+    return filterTestOutput(stdout);
+  }
+  if (mode === "aggressive" && /\b(ls|list|ll)\b/.test(cmd)) {
+    return filterNpmLs(stdout);
+  }
+  return { output: stdout, filtered: false };
+}
+function filterNpmLs(stdout) {
+  const lines = stdout.split("\n");
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const l of lines) {
+    const stripped = l.replace(/^[\s│├└─┬]+/u, "").trimEnd();
+    if (!stripped) continue;
+    if (/\bdeduped\b/.test(stripped)) continue;
+    const cleaned = stripped.replace(/^extraneous\s+/, "").replace(/\s+\bextraneous\b/g, "");
+    if (seen.has(cleaned)) continue;
+    seen.add(cleaned);
+    out.push(cleaned);
+  }
+  return { output: out.join("\n"), filtered: true };
+}
+var FAIL_MARKER_RE = /^\s*[✗✘×]\s/;
+var FAIL_WORD_RE = /\bFAIL\b/;
+var FAILED_RE = /\bfailed?\b/i;
+var ERROR_RE = /\bERROR\b/;
+var SUMMARY_RE = /^\s*(Tests?|Suites?|Test Suites)\s*:|^\s*(pass|fail|skip|pending|todo)\s|\b\d+\s+(passing|failing|pending|skipped)\b|^(ok|not ok)\s|^ℹ\s|^(PASS|FAIL)\s/i;
+function isFailMarker(line) {
+  return FAIL_MARKER_RE.test(line) || FAIL_WORD_RE.test(line) || FAILED_RE.test(line) || ERROR_RE.test(line);
+}
+function isSummaryLine(line) {
+  return SUMMARY_RE.test(line);
+}
+function filterTestOutput(stdout) {
+  const lines = stdout.split("\n");
+  const failures = [];
+  const summary = [];
+  let inFailure = false;
+  let failCount = 0;
+  for (const line of lines) {
+    if (isFailMarker(line)) {
+      inFailure = true;
+      failCount++;
+    }
+    if (inFailure) {
+      failures.push(line);
+      if (line.trim() === "" && failures.length > 3) inFailure = false;
+    }
+    if (isSummaryLine(line)) {
+      summary.push(line);
+    }
+  }
+  if (failCount === 0 && summary.length > 0) {
+    return { output: summary.join("\n"), filtered: true };
+  }
+  if (failures.length > 0) {
+    const rollup = summary.filter((l) => !/^PASS\s/i.test(l));
+    const result = [...failures, "", ...rollup].join("\n");
+    return { output: result, filtered: true };
+  }
+  return { output: stdout, filtered: false };
+}
+function filterBuildOutput(cmd, stdout) {
+  const lines = stdout.split("\n");
+  const filtered = lines.filter(
+    (l) => !l.includes("Downloading") && !l.includes("Downloaded") && !/Compiling\s+\d+\s+of\s+\d+/.test(l) && !/^\s*Compiling\s+[\w-]+\s+v\d/.test(l) && !/^\s*Checking\s+[\w-]+\s+v\d/.test(l) && !l.includes("Blocking waiting for file lock") && !/^\s*$/.test(l)
+  );
+  return { output: filtered.join("\n"), filtered: filtered.length < lines.length };
+}
+function filterContainerOutput(cmd, stdout) {
+  if (/docker\s+build/.test(cmd)) {
+    const lines = stdout.split("\n");
+    const filtered = lines.filter(
+      (l) => !l.startsWith(" ---> ") && !l.startsWith("Sending build context") && !/^\s*$/.test(l)
+    );
+    return { output: filtered.join("\n"), filtered: true };
+  }
+  if (/^kubectl\s+(get|describe)\b/.test(cmd)) {
+    const lines = stdout.split("\n").filter((l) => l.length > 0);
+    if (lines.length <= 30) return { output: stdout, filtered: false };
+    const header = lines[0];
+    const rows = lines.slice(1);
+    const headerCols = header.split(/\s{2,}/);
+    const hasNamespace = headerCols[0]?.toUpperCase() === "NAMESPACE";
+    const statusIdx = headerCols.findIndex((c) => /^STATUS$/i.test(c));
+    const counts = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const cols = row.split(/\s{2,}/);
+      const ns = hasNamespace ? cols[0] : "(default)";
+      const status = statusIdx >= 0 ? cols[statusIdx] : "\u2014";
+      const key = `${ns}	${status}`;
+      counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    const summaryLines = [`${header}`, `(${rows.length} rows summarized by namespace/status)`];
+    for (const [key, n] of [...counts.entries()].sort((a, b) => b[1] - a[1])) {
+      const [ns, status] = key.split("	");
+      summaryLines.push(`  ${ns} \u2014 ${status}: ${n}`);
+    }
+    return { output: summaryLines.join("\n"), filtered: true };
+  }
+  return { output: stdout, filtered: false };
+}
+function filterFileList(cmd, stdout, mode = DEFAULT_MODE) {
+  const isLs = /^ls\b/.test(cmd);
+  const isLong = /-l/.test(cmd);
+  if (mode === "aggressive" && isLs && isLong) {
+    return { output: aggressiveLsLong(stdout), filtered: true };
+  }
+  if (mode === "balanced" && isLs && isLong) {
+    return { output: balancedLsLong(stdout), filtered: true };
+  }
+  const { summarizeAt, minDirs } = mode === "aggressive" ? { summarizeAt: 10, minDirs: 3 } : { summarizeAt: 20, minDirs: 4 };
+  const lines = stdout.split("\n").filter((l) => l.trim() !== "");
+  if (lines.length <= summarizeAt) return { output: stdout, filtered: false };
+  if (cmd.includes("-R") || cmd.startsWith("find")) {
+    const dirs = /* @__PURE__ */ new Map();
+    for (const line of lines) {
+      const parts = line.split("/");
+      const dir = parts.length > 1 ? parts.slice(0, -1).join("/") : ".";
+      dirs.set(dir, (dirs.get(dir) ?? 0) + 1);
+    }
+    if (dirs.size > minDirs) {
+      const summary = Array.from(dirs.entries()).sort((a, b) => b[1] - a[1]).map(([dir, count]) => `  ${dir}/ (${count} files)`).join("\n");
+      return {
+        output: `${lines.length} files found:
+${summary}`,
+        filtered: true
+      };
+    }
+  }
+  return { output: stdout, filtered: false };
+}
+function balancedLsLong(stdout) {
+  const lines = stdout.split("\n");
+  const out = [];
+  for (const line of lines) {
+    if (line.trim() === "") continue;
+    if (/^total\s+\d+/.test(line)) continue;
+    const m = line.match(
+      /^([dlcb-])[rwxst@+\-]{9,}\s+\d+\s+\S+\s+\S+\s+\S+\s+\S+\s+\S+\s+\S+\s+(\.\.?)$/
+    );
+    if (m) continue;
+    out.push(line);
+  }
+  return out.join("\n");
+}
+function aggressiveLsLong(stdout) {
+  const lines = stdout.split("\n");
+  const out = [];
+  let inSection = false;
+  for (const line of lines) {
+    if (/^[^\s]+:$/.test(line.trim())) {
+      out.push(line.trim());
+      inSection = true;
+      continue;
+    }
+    if (/^total\s+\d+/.test(line)) continue;
+    if (line.trim() === "") continue;
+    const m = line.match(
+      /^([dlcb-])[rwxst@+\-]{9,}\s+\d+\s+\S+\s+\S+\s+(\S+)\s+\S+\s+\S+\s+\S+\s+(.+)$/
+    );
+    if (m) {
+      const type = m[1];
+      const sizeStr = m[2];
+      const name = m[3];
+      if (name === "." || name === "..") continue;
+      if (type === "d" && inSection) continue;
+      out.push(name + (type === "d" ? "/" : ` ${formatSize(sizeStr)}`));
+      continue;
+    }
+    out.push(line);
+  }
+  return out.join("\n");
+}
+function formatSize(s) {
+  const n = Number.parseInt(s, 10);
+  if (Number.isNaN(n)) return s;
+  if (n >= 1024 * 1024) return `${(n / 1024 / 1024).toFixed(1)}M`;
+  if (n >= 1024) return `${(n / 1024).toFixed(1)}K`;
+  return `${n}B`;
+}
+function filterGrep(stdout) {
+  const lines = stdout.split("\n").filter((l) => l.length > 0);
+  if (lines.length === 0) return { output: stdout, filtered: false };
+  const byFile = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    const m = line.match(/^([^:]+):(\d+):(.*)$/);
+    if (!m) {
+      const arr2 = byFile.get("(no path)") ?? [];
+      arr2.push(line.length > 100 ? `${line.slice(0, 100)}\u2026` : line);
+      byFile.set("(no path)", arr2);
+      continue;
+    }
+    const [, file, lineNo, content] = m;
+    const truncated = content.length > 100 ? `${content.slice(0, 100)}\u2026` : content;
+    const arr = byFile.get(file) ?? [];
+    arr.push(`  L${lineNo}: ${truncated.trim()}`);
+    byFile.set(file, arr);
+  }
+  const out = [];
+  for (const [file, hits] of byFile) {
+    out.push(`${file} (${hits.length})`);
+    for (const h of hits.slice(0, 8)) out.push(h);
+    if (hits.length > 8) out.push(`  ... +${hits.length - 8} more matches`);
+  }
+  return { output: out.join("\n"), filtered: true };
+}
+function filterDf(stdout) {
+  const lines = stdout.split("\n");
+  if (lines.length === 0) return { output: stdout, filtered: false };
+  const header = lines[0];
+  const out = [header.replace(/\s{2,}/g, " ")];
+  for (const line of lines.slice(1)) {
+    if (!line.trim()) continue;
+    if (/^(tmpfs|devfs|devtmpfs|udev|overlay|map\s|none\s|\/dev\/loop)/.test(line)) continue;
+    out.push(line.replace(/\s{2,}/g, " "));
+  }
+  return { output: out.join("\n"), filtered: true };
+}
+function filterDu(stdout) {
+  const lines = stdout.split("\n").filter((l) => l.trim() !== "");
+  if (lines.length <= 25) return { output: stdout, filtered: false };
+  const parsed = lines.map((l) => {
+    const m = l.match(/^([\d.]+[KMGT]?B?)?\s*(.*)$/);
+    if (!m) return null;
+    const sizeRaw = m[1] ?? "0";
+    const path = m[2];
+    return { sizeRaw, sizeBytes: parseDuSize(sizeRaw), path, line: l };
+  }).filter((x) => x !== null);
+  parsed.sort((a, b) => b.sizeBytes - a.sizeBytes);
+  const top = parsed.slice(0, 20).map((p) => p.line);
+  return {
+    output: `(top 20 of ${parsed.length} entries by size)
+${top.join("\n")}`,
+    filtered: true
+  };
+}
+function parseDuSize(s) {
+  const m = s.match(/^([\d.]+)([KMGT])?B?$/i);
+  if (!m) return 0;
+  const n = Number.parseFloat(m[1]);
+  const unit = (m[2] ?? "").toUpperCase();
+  const factor = unit === "T" ? 1024 ** 4 : unit === "G" ? 1024 ** 3 : unit === "M" ? 1024 ** 2 : unit === "K" ? 1024 : 1;
+  return n * factor;
+}
+function filterPs(stdout) {
+  const lines = stdout.split("\n");
+  if (lines.length <= 2) return { output: stdout, filtered: false };
+  const header = lines[0];
+  const isAux = header.includes("USER") && header.includes("%CPU") && header.includes("%MEM");
+  if (!isAux) return { output: stdout, filtered: false };
+  const out = ["PID  %CPU %MEM CMD"];
+  for (const line of lines.slice(1)) {
+    if (!line.trim()) continue;
+    const parts = line.trim().split(/\s+/);
+    if (parts.length < 11) continue;
+    const pid = parts[1];
+    const cpu = parts[2];
+    const mem = parts[3];
+    const cmd = parts.slice(10).join(" ");
+    if (/^\[.*\]$/.test(cmd)) continue;
+    out.push(`${pid.padEnd(5)} ${cpu.padStart(4)} ${mem.padStart(4)} ${cmd}`);
+  }
+  return { output: out.join("\n"), filtered: true };
+}
+
 // src/utils.ts
 function detectInjectionPatterns(content) {
   const warnings = [];
@@ -21265,6 +21767,11 @@ function formatBytes(bytes) {
 
 // src/executor.ts
 var DEFAULT_TIMEOUT = 3e4;
+var ANSI_RE = /\x1b\[[0-9;]*[a-zA-Z]/;
+var ANSI_RE_G = /\x1b\[[0-9;]*[a-zA-Z]/g;
+function stripAnsi(str) {
+  return str.replace(ANSI_RE_G, "");
+}
 var SAFE_ENV_KEYS = [
   "PATH",
   "HOME",
@@ -21317,6 +21824,20 @@ function killProcessTree(pid) {
     }
   }
 }
+function stripProgressLines(output) {
+  const lines = output.split("\n");
+  const filtered = lines.filter((l) => {
+    const trimmed = l.trim();
+    if (ANSI_RE.test(l) && trimmed.replace(ANSI_RE_G, "").trim() === "") return false;
+    if (/^[\s\[│├└─═━▓░█▒▏▎▍▌▋▊▉\]>=#\-.\d%]+$/.test(trimmed) && trimmed.length > 3) return false;
+    if (/^[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏\-\\|/]\s/.test(trimmed)) return false;
+    if (/(?:downloading|uploading|fetching|resolving)\s+[\d.]+\s*[kmg]?b/i.test(trimmed))
+      return false;
+    if (/\d+\.?\d*\s*[kmg]?b\/s/i.test(trimmed) && /eta|remaining/i.test(trimmed)) return false;
+    return true;
+  });
+  return filtered.join("\n");
+}
 function deduplicateLines(output) {
   const lines = output.split("\n");
   if (lines.length < 3) return output;
@@ -21348,12 +21869,12 @@ function deduplicateLines(output) {
 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 ERROR_RE2 = /^(.*?(?: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);
+    const match = line.match(ERROR_RE2);
     if (match) {
       const prefix = match[1].trim();
       const msg = match[2].trim();
@@ -21505,7 +22026,8 @@ var SubprocessExecutor = class {
         tmpDir,
         timeout,
         maxOutput,
-        plugin.needsShell
+        plugin.needsShell,
+        opts.language === "shell" ? opts.code : void 0
       );
     } finally {
       setTimeout(() => this.cleanupTempDir(tmpDir), 100).unref();
@@ -21532,8 +22054,8 @@ var SubprocessExecutor = class {
     }
     return this.execute({ ...opts, code });
   }
-  spawnAndCapture(cmd, args, cwd, timeout, maxOutput, useShell) {
-    return new Promise((resolve2) => {
+  spawnAndCapture(cmd, args, cwd, timeout, maxOutput, useShell, shellCode) {
+    return new Promise((resolve5) => {
       const hardCap = this.config.hardCapBytes;
       const stdoutChunks = [];
       const stderrChunks = [];
@@ -21573,7 +22095,7 @@ var SubprocessExecutor = class {
         this.activeProcesses.delete(proc);
         if (!resolved) {
           resolved = true;
-          resolve2({
+          resolve5({
             stdout: "",
             stderr: err.message,
             exitCode: 1,
@@ -21597,7 +22119,15 @@ var SubprocessExecutor = class {
           stdout += `
 [output capped at ${formatBytes(hardCap)} \u2014 process killed]`;
         }
+        stdout = stripAnsi(stdout);
+        if (shellCode && stdout) {
+          const filtered = applyCommandFilter(shellCode, stdout);
+          if (filtered.filtered) {
+            stdout = filtered.output;
+          }
+        }
         if (stdout.length > 1e4) {
+          stdout = stripProgressLines(stdout);
           stdout = deduplicateLines(stdout);
           stdout = groupErrorLines(stdout);
         }
@@ -21605,7 +22135,7 @@ var SubprocessExecutor = class {
         if (truncated) {
           stdout = smartTruncate(stdout, maxOutput);
         }
-        resolve2({
+        resolve5({
           stdout,
           stderr,
           exitCode: code,
@@ -21638,65 +22168,6 @@ 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;
-  const [v4Result, v6Result] = await Promise.allSettled([
-    dns.promises.lookup(hostname2, { family: 4 }),
-    dns.promises.lookup(hostname2, { family: 6 })
-  ]);
-  if (v4Result.status === "fulfilled") {
-    if (isPrivateHost(v4Result.value.address)) {
-      throw new Error(`Blocked: ${hostname2} resolved to private IP ${v4Result.value.address}`);
-    }
-    resolvedIp = v4Result.value.address;
-  } else {
-    v4Error = true;
-  }
-  if (v6Result.status === "fulfilled") {
-    if (isPrivateHost(v6Result.value.address)) {
-      throw new Error(`Blocked: ${hostname2} resolved to private IPv6 ${v6Result.value.address}`);
-    }
-    if (!resolvedIp) resolvedIp = v6Result.value.address;
-  } else {
-    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";
@@ -22013,6 +22484,7 @@ function hasBun(runtimes) {
 }
 
 // src/stats.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
 var BAR_WIDTH = 20;
 function asciiBar(ratio, width = BAR_WIDTH) {
   const filled = Math.round(ratio * width);
@@ -22032,6 +22504,10 @@ var SessionTracker = class {
     bytesSandboxed: 0,
     sessionStart: Date.now()
   };
+  cumulativeFile;
+  constructor(cumulativeFile) {
+    this.cumulativeFile = cumulativeFile ?? null;
+  }
   trackCall(toolName, responseBytes) {
     this.stats.calls[toolName] = (this.stats.calls[toolName] ?? 0) + 1;
     this.stats.bytesReturned[toolName] = (this.stats.bytesReturned[toolName] ?? 0) + responseBytes;
@@ -22045,6 +22521,47 @@ var SessionTracker = class {
   getSnapshot() {
     return { ...this.stats };
   }
+  /** Load cumulative stats from disk */
+  loadCumulative() {
+    if (!this.cumulativeFile) return null;
+    try {
+      const data = readFileSync2(this.cumulativeFile, "utf-8");
+      return JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
+  /** Save current session stats to cumulative file */
+  saveCumulative() {
+    if (!this.cumulativeFile) return;
+    const snap = this.stats;
+    const keptOut = snap.bytesIndexed + snap.bytesSandboxed;
+    const totalReturned = Object.values(snap.bytesReturned).reduce((a, b) => a + b, 0);
+    const cumulative = this.loadCumulative() ?? {
+      totalBytesSaved: 0,
+      totalBytesProcessed: 0,
+      totalCalls: 0,
+      totalSessions: 0,
+      firstSeen: (/* @__PURE__ */ new Date()).toISOString(),
+      lastSeen: (/* @__PURE__ */ new Date()).toISOString(),
+      perCommand: {}
+    };
+    cumulative.totalBytesSaved += keptOut;
+    cumulative.totalBytesProcessed += keptOut + totalReturned;
+    cumulative.totalCalls += Object.values(snap.calls).reduce((a, b) => a + b, 0);
+    cumulative.totalSessions += 1;
+    cumulative.lastSeen = (/* @__PURE__ */ new Date()).toISOString();
+    for (const [name, calls] of Object.entries(snap.calls)) {
+      if (!cumulative.perCommand[name]) {
+        cumulative.perCommand[name] = { calls: 0 };
+      }
+      cumulative.perCommand[name].calls += calls;
+    }
+    try {
+      writeFileSync2(this.cumulativeFile, JSON.stringify(cumulative, null, 2));
+    } catch {
+    }
+  }
   formatReport() {
     const snap = this.stats;
     const elapsed = Date.now() - snap.sessionStart;
@@ -22105,6 +22622,18 @@ var SessionTracker = class {
       `
 Context-compress kept ${formatBytes(keptOut)} out of context (${reductionPct}% savings).`
     );
+    const cumulative = this.loadCumulative();
+    if (cumulative) {
+      lines.push("\n## Cumulative Savings (All Sessions)\n");
+      lines.push("| Metric | Value |");
+      lines.push("|--------|-------|");
+      lines.push(`| Sessions tracked | ${cumulative.totalSessions} |`);
+      lines.push(`| Total data processed | ${formatBytes(cumulative.totalBytesProcessed)} |`);
+      lines.push(`| Total kept out of context | ${formatBytes(cumulative.totalBytesSaved)} |`);
+      const cumTokensMid = Math.round(cumulative.totalBytesSaved / 4);
+      lines.push(`| Est. total tokens saved | ~${cumTokensMid.toLocaleString()} |`);
+      lines.push(`| Tracking since | ${cumulative.firstSeen.split("T")[0]} |`);
+    }
     return lines.join("\n");
   }
 };
@@ -22301,6 +22830,9 @@ var ContentStore = class {
   insertChunkStmt;
   vocabCountStmt;
   vocabInsertStmt;
+  // Cache for getDistinctiveTerms — keyed by sourceId, with "_all" for the global query.
+  // Invalidated whenever index() runs, since chunk counts/distributions change.
+  distinctiveTermsCache = /* @__PURE__ */ new Map();
   constructor(options) {
     let path;
     if (typeof options === "string") {
@@ -22393,6 +22925,7 @@ var ContentStore = class {
       return sourceId2;
     });
     const sourceId = tx();
+    this.distinctiveTermsCache.clear();
     return {
       sourceId,
       label,
@@ -22516,10 +23049,16 @@ var ContentStore = class {
    * Get distinctive terms for search hint.
    */
   getDistinctiveTerms(sourceId) {
+    const cacheKey = sourceId ?? "_all";
+    const cached2 = this.distinctiveTermsCache.get(cacheKey);
+    if (cached2) return cached2;
     const totalChunks = this.db.prepare(
       sourceId ? "SELECT COUNT(*) as cnt FROM chunks WHERE source_id = ?" : "SELECT COUNT(*) as cnt FROM chunks"
     ).get(...sourceId ? [sourceId] : []).cnt;
-    if (totalChunks === 0) return [];
+    if (totalChunks === 0) {
+      this.distinctiveTermsCache.set(cacheKey, []);
+      return [];
+    }
     const filter = sourceId ? " WHERE source_id = ?" : "";
     const stmt = this.db.prepare(`SELECT content FROM chunks${filter} LIMIT 500`);
     const rows = sourceId ? stmt.all(sourceId) : stmt.all();
@@ -22544,7 +23083,9 @@ var ContentStore = class {
       scored.push({ word, score });
     }
     scored.sort((a, b) => b.score - a.score);
-    return scored.slice(0, 40).map((s) => s.word);
+    const terms = scored.slice(0, 40).map((s) => s.word);
+    this.distinctiveTermsCache.set(cacheKey, terms);
+    return terms;
   }
   /**
    * List all indexed sources with metadata.
@@ -22690,155 +23231,238 @@ function cleanupStaleDbs() {
   return cleaned;
 }
 
-// src/types.ts
-var ALL_LANGUAGES = [
-  "javascript",
-  "typescript",
-  "python",
-  "shell",
-  "ruby",
-  "go",
-  "rust",
-  "php",
-  "perl",
-  "r",
-  "elixir"
-];
+// src/tools/batch-execute.ts
+function registerBatchExecuteTool(server2, ctx) {
+  const { executor, store, tracker, config: config3, withExecutionLimit } = ctx;
+  server2.tool(
+    "batch_execute",
+    "Execute multiple commands in ONE call, auto-index all output, and search with multiple queries. Returns search results directly \u2014 no follow-up calls needed.\n\nTHIS IS THE PRIMARY TOOL. Use this instead of multiple execute() calls.\n\nOne batch_execute call replaces 30+ execute calls + 10+ search calls.\nProvide all commands to run and all queries to search \u2014 everything happens in one round trip.",
+    {
+      commands: external_exports.array(
+        external_exports.object({
+          label: external_exports.string().describe("Section header for this command's output"),
+          command: external_exports.string().describe("Shell command to execute")
+        })
+      ).describe("Commands to execute as a batch."),
+      queries: external_exports.array(external_exports.string()).describe(
+        "Search queries to extract information from indexed output. Use 5-8 comprehensive queries."
+      ),
+      timeout: external_exports.number().default(6e4).describe("Max execution time in ms (default: 60s)")
+    },
+    async ({ commands, queries, timeout }) => {
+      const commandResults = await limitConcurrency(
+        commands.map((cmd) => async () => {
+          const result = await withExecutionLimit(
+            () => executor.execute({
+              language: "shell",
+              code: cmd.command,
+              timeout
+            })
+          );
+          return { label: cmd.label, result };
+        }),
+        4
+      );
+      let combined = "";
+      const inventory = [];
+      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)";
+          combined += `## ${label}
+
+${output2}
 
-// src/server.ts
-var LANGUAGE_ENUM = ALL_LANGUAGES;
-var projectDir = process.env.CLAUDE_PROJECT_DIR ?? process.cwd();
-function isWithinProject(absPath) {
-  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 {
-    const __dirname = dirname(fileURLToPath(import.meta.url));
-    const pkgPath = join4(__dirname, "..", "package.json");
-    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
-    return pkg.version ?? "1.0.0";
-  } catch {
-    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 createServer(config3) {
-  const version2 = getVersion();
-  debug("Version:", version2);
-  cleanupStaleDbs();
-  const runtimes = await detectRuntimes();
-  const bunDetected = hasBun(runtimes);
-  debug("Runtimes detected:", runtimes.size);
-  const executor = new SubprocessExecutor(runtimes, config3);
-  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();
-  let activeExecutions = 0;
-  const MAX_CONCURRENT_EXECUTIONS = 8;
-  const EXECUTION_LIMIT_ERROR = "Error: too many concurrent executions. Try again shortly.";
-  async function withExecutionLimit(fn) {
-    if (activeExecutions >= MAX_CONCURRENT_EXECUTIONS) {
-      throw new Error(EXECUTION_LIMIT_ERROR);
-    }
-    activeExecutions++;
-    try {
-      return await fn();
-    } finally {
-      activeExecutions--;
-    }
-  }
-  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}":
+          const lineCount = output2.split("\n").length;
+          inventory.push(`- **${label}**: ${lineCount} lines`);
+        } else {
+          combined += `## ${label}
+
+(error: ${settled.reason})
 
 `;
-    for (const hit of searchResults.results) {
-      filtered += `  - **${hit.title}**: ${hit.snippet.slice(0, 200)}
+          inventory.push(`- **${label}**: error`);
+        }
+      }
+      const indexed = store.index(combined, "batch_execute");
+      tracker.trackIndexed(Buffer.byteLength(combined));
+      const searchResults = [];
+      let totalBytes = 0;
+      for (const query of queries) {
+        if (totalBytes > config3.batchMaxBytes) break;
+        let result = store.search(query, { source: "batch_execute", limit: 5 });
+        if (result.results.length === 0) {
+          result = store.search(query, { limit: 5 });
+        }
+        let block = `## ${query}
+
 `;
-    }
-    if (terms.length > 0 && config3.compressionLevel !== "ultra") {
-      filtered += `
-Searchable terms: ${terms.join(", ")}
+        if (result.results.length === 0) {
+          block += "No results found.\n";
+        } else {
+          for (const hit of result.results) {
+            block += `--- [${hit.source}] ---
+### ${hit.title}
+
+${hit.snippet}
+
 `;
+          }
+        }
+        searchResults.push(block);
+        totalBytes += Buffer.byteLength(block);
+      }
+      const terms = store.getDistinctiveTerms(indexed.sourceId);
+      let output = `**Inventory** (${commands.length} commands):
+${inventory.join("\n")}
+
+`;
+      output += searchResults.join("\n---\n\n");
+      if (terms.length > 0) {
+        output += `
+
+Searchable terms: ${terms.join(", ")}`;
+      }
+      tracker.trackCall("batch_execute", Buffer.byteLength(output));
+      return { content: [{ type: "text", text: output }] };
     }
-    filtered += "\nUse search(queries: [...]) to retrieve full content of any section.";
-    return compactLabel(filtered, config3.compressionLevel);
-  }
-  const shutdown = () => {
-    try {
-      executor.shutdown();
-    } catch {
-    }
-    try {
-      store.close();
-    } catch {
-    }
-  };
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
-  process.on("beforeExit", shutdown);
-  process.on("uncaughtException", (err) => {
-    debug("Uncaught exception:", err);
-    shutdown();
-    process.exit(1);
-  });
-  process.on("unhandledRejection", (err) => {
-    debug("Unhandled rejection:", err);
-    shutdown();
-    process.exit(1);
-  });
-  const searchCalls = [];
-  const server2 = new McpServer({
-    name: "context-compress",
-    version: version2
-  });
+  );
+}
+
+// src/tools/discover.ts
+function registerDiscoverTool(server2, ctx) {
+  const { store, tracker, dbFallback } = ctx;
   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 ~5KB. ${bunDetected ? "(Bun detected \u2014 JS/TS runs 3-5x faster) " : ""}Available: ${ALL_LANGUAGES.join(", ")}.
+    "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 searchCalls = 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 (searchCalls > 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 }] };
+    }
+  );
+}
 
-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.`,
+// src/tools/execute-file.ts
+import { resolve as resolve2 } from "node:path";
+
+// src/types.ts
+var ALL_LANGUAGES = [
+  "javascript",
+  "typescript",
+  "python",
+  "shell",
+  "ruby",
+  "go",
+  "rust",
+  "php",
+  "perl",
+  "r",
+  "elixir"
+];
+
+// src/util/path.ts
+import { realpathSync } from "node:fs";
+import { resolve } from "node:path";
+function isWithinProject(absPath, projectDir2) {
+  try {
+    const normalized = realpathSync(resolve(absPath));
+    const realProjectDir = realpathSync(projectDir2);
+    return normalized === realProjectDir || normalized.startsWith(`${realProjectDir}/`);
+  } catch {
+    const normalized = resolve(absPath);
+    const normalizedProject = resolve(projectDir2);
+    return normalized === normalizedProject || normalized.startsWith(`${normalizedProject}/`);
+  }
+}
+
+// src/tools/execute-file.ts
+var LANGUAGE_ENUM = ALL_LANGUAGES;
+function registerExecuteFileTool(server2, ctx) {
+  const { executor, tracker, projectDir: projectDir2, withExecutionLimit, applyIntentFilter } = ctx;
+  server2.tool(
+    "execute_file",
+    "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(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."
-      ),
-      intent: external_exports.string().optional().describe(
-        "What you're looking for in the output. When provided and output is large (>5KB), indexes output into knowledge base and returns section titles + previews \u2014 not full content. Use search(queries: [...]) to retrieve specific sections."
+        "Code to process FILE_CONTENT. Print summary via console.log/print/echo/IO.puts."
       ),
+      intent: external_exports.string().optional().describe("What you're looking for in the output."),
       timeout: external_exports.number().default(3e4).describe("Max execution time in ms")
     },
-    async ({ language, code, intent, timeout }) => {
+    async ({ path: filePath, language, code, intent, timeout }) => {
       const codeBytes = Buffer.byteLength(code);
       if (codeBytes > 1024e3) {
         return {
@@ -22847,18 +23471,35 @@ PREFER THIS OVER BASH for: API calls (gh, curl, aws), test runners (npm test, py
               type: "text",
               text: `Error: code too large (${(codeBytes / 1024).toFixed(0)}KB). Max 1MB.`
             }
-          ]
+          ],
+          isError: true
+        };
+      }
+      const absPath = resolve2(projectDir2, filePath);
+      if (!isWithinProject(absPath, projectDir2)) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error: path "${filePath}" is outside the project directory`
+            }
+          ],
+          isError: true
         };
       }
       let result;
       try {
-        result = await withExecutionLimit(() => executor.execute({ language, code, timeout }));
-      } catch (e) {
-        const msg = e instanceof Error ? e.message : String(e);
-        return { content: [{ type: "text", text: msg }] };
-      }
-      if (result.networkBytes) {
-        tracker.trackSandboxed(result.networkBytes);
+        result = await withExecutionLimit(
+          () => executor.executeFile({
+            language,
+            code,
+            filePath: absPath,
+            timeout
+          })
+        );
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return { content: [{ type: "text", text: msg }], isError: true };
       }
       let output = result.stdout;
       if (result.stderr && result.exitCode !== 0) {
@@ -22868,26 +23509,35 @@ STDERR:
 ${result.stderr}`;
       }
       if (intent) {
-        output = applyIntentFilter(output, intent, `execute:${language}`);
+        output = applyIntentFilter(output, intent, `file:${filePath}`);
       }
       const responseBytes = Buffer.byteLength(output);
-      tracker.trackCall("execute", responseBytes);
+      tracker.trackCall("execute_file", responseBytes);
       return { content: [{ type: "text", text: output }] };
     }
   );
+}
+
+// src/tools/execute.ts
+var LANGUAGE_ENUM2 = ALL_LANGUAGES;
+function registerExecuteTool(server2, ctx) {
+  const { executor, tracker, withExecutionLimit, applyIntentFilter, bunDetected } = ctx;
   server2.tool(
-    "execute_file",
-    "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.",
+    "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 ~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.`,
     {
-      path: external_exports.string().describe("Absolute file path or relative to project root"),
-      language: external_exports.enum(LANGUAGE_ENUM).describe("Runtime language"),
+      language: external_exports.enum(LANGUAGE_ENUM2).describe("Runtime language"),
       code: external_exports.string().describe(
-        "Code to process FILE_CONTENT. Print summary via console.log/print/echo/IO.puts."
+        "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."
+      ),
+      intent: external_exports.string().optional().describe(
+        "What you're looking for in the output. When provided and output is large (>5KB), indexes output into knowledge base and returns section titles + previews \u2014 not full content. Use search(queries: [...]) to retrieve specific sections."
       ),
-      intent: external_exports.string().optional().describe("What you're looking for in the output."),
       timeout: external_exports.number().default(3e4).describe("Max execution time in ms")
     },
-    async ({ path: filePath, language, code, intent, timeout }) => {
+    async ({ language, code, intent, timeout }) => {
       const codeBytes = Buffer.byteLength(code);
       if (codeBytes > 1024e3) {
         return {
@@ -22896,33 +23546,19 @@ ${result.stderr}`;
               type: "text",
               text: `Error: code too large (${(codeBytes / 1024).toFixed(0)}KB). Max 1MB.`
             }
-          ]
-        };
-      }
-      const absPath = resolve(projectDir, filePath);
-      if (!isWithinProject(absPath)) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error: path "${filePath}" is outside the project directory`
-            }
-          ]
+          ],
+          isError: true
         };
       }
       let result;
       try {
-        result = await withExecutionLimit(
-          () => executor.executeFile({
-            language,
-            code,
-            filePath: absPath,
-            timeout
-          })
-        );
+        result = await withExecutionLimit(() => executor.execute({ language, code, timeout }));
       } catch (e) {
         const msg = e instanceof Error ? e.message : String(e);
-        return { content: [{ type: "text", text: msg }] };
+        return { content: [{ type: "text", text: msg }], isError: true };
+      }
+      if (result.networkBytes) {
+        tracker.trackSandboxed(result.networkBytes);
       }
       let output = result.stdout;
       if (result.stderr && result.exitCode !== 0) {
@@ -22932,164 +23568,191 @@ STDERR:
 ${result.stderr}`;
       }
       if (intent) {
-        output = applyIntentFilter(output, intent, `file:${filePath}`);
+        output = applyIntentFilter(output, intent, `execute:${language}`);
       }
       const responseBytes = Buffer.byteLength(output);
-      tracker.trackCall("execute_file", responseBytes);
+      tracker.trackCall("execute", responseBytes);
       return { content: [{ type: "text", text: output }] };
     }
   );
+}
+
+// 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]);
+  const hexMappedMatch = lower.match(/^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/);
+  if (hexMappedMatch) {
+    const g1 = hexMappedMatch[1].padStart(4, "0");
+    const g2 = hexMappedMatch[2].padStart(4, "0");
+    const b1 = Number.parseInt(g1.slice(0, 2), 16);
+    const b2 = Number.parseInt(g1.slice(2, 4), 16);
+    const b3 = Number.parseInt(g2.slice(0, 2), 16);
+    const b4 = Number.parseInt(g2.slice(2, 4), 16);
+    return isPrivateHost(`${b1}.${b2}.${b3}.${b4}`);
+  }
+  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;
+  const [v4Result, v6Result] = await Promise.allSettled([
+    dns.promises.lookup(hostname2, { family: 4 }),
+    dns.promises.lookup(hostname2, { family: 6 })
+  ]);
+  if (v4Result.status === "fulfilled") {
+    if (isPrivateHost(v4Result.value.address)) {
+      throw new Error(`Blocked: ${hostname2} resolved to private IP ${v4Result.value.address}`);
+    }
+    resolvedIp = v4Result.value.address;
+  } else {
+    v4Error = true;
+  }
+  if (v6Result.status === "fulfilled") {
+    if (isPrivateHost(v6Result.value.address)) {
+      throw new Error(`Blocked: ${hostname2} resolved to private IPv6 ${v6Result.value.address}`);
+    }
+    if (!resolvedIp) resolvedIp = v6Result.value.address;
+  } else {
+    v6Error = true;
+  }
+  if (v4Error && v6Error) {
+    throw new Error(`DNS resolution failed for ${hostname2}: unable to verify host safety`);
+  }
+  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);
+}
+
+// Strip unwanted tags
+let md = html
+  .replace(/<script[^>]*>[\\s\\S]*?<\\/script>/gi, "")
+  .replace(/<style[^>]*>[\\s\\S]*?<\\/style>/gi, "")
+  .replace(/<nav[^>]*>[\\s\\S]*?<\\/nav>/gi, "")
+  .replace(/<header[^>]*>[\\s\\S]*?<\\/header>/gi, "")
+  .replace(/<footer[^>]*>[\\s\\S]*?<\\/footer>/gi, "");
+
+// Convert headings
+md = md.replace(/<h1[^>]*>(.*?)<\\/h1>/gi, "# $1\\n");
+md = md.replace(/<h2[^>]*>(.*?)<\\/h2>/gi, "## $1\\n");
+md = md.replace(/<h3[^>]*>(.*?)<\\/h3>/gi, "### $1\\n");
+md = md.replace(/<h4[^>]*>(.*?)<\\/h4>/gi, "#### $1\\n");
+
+// Convert code blocks
+md = md.replace(/<pre[^>]*><code[^>]*>(.*?)<\\/code><\\/pre>/gis, "\`\`\`\\n$1\\n\`\`\`\\n");
+md = md.replace(/<code[^>]*>(.*?)<\\/code>/gi, "\`$1\`");
+
+// Convert links
+md = md.replace(/<a[^>]*href="([^"]*)"[^>]*>(.*?)<\\/a>/gi, "[$2]($1)");
+
+// Convert lists
+md = md.replace(/<li[^>]*>(.*?)<\\/li>/gi, "- $1\\n");
+
+// Convert paragraphs
+md = md.replace(/<p[^>]*>(.*?)<\\/p>/gis, "$1\\n\\n");
+md = md.replace(/<br\\s*\\/?>/gi, "\\n");
+
+// Strip remaining tags
+md = md.replace(/<[^>]+>/g, "");
+
+// Decode entities
+md = md.replace(/&lt;/g, "<")
+  .replace(/&gt;/g, ">")
+  .replace(/&quot;/g, '"')
+  .replace(/&#39;/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();
+
+console.log(md);
+`;
+}
+
+// src/tools/fetch-and-index.ts
+function registerFetchAndIndexTool(server2, ctx) {
+  const { executor, store, tracker, withExecutionLimit } = ctx;
   server2.tool(
-    "index",
-    "Index documentation or knowledge content into a searchable BM25 knowledge base. Chunks markdown by headings (keeping code blocks intact) and stores in ephemeral FTS5 database. The full content does NOT stay in context \u2014 only a brief summary is returned.\n\nWHEN TO USE:\n- Documentation (API docs, framework guides, code examples)\n- README files, migration guides, changelog entries\n- Any content with code examples you may need to reference precisely\n\nAfter indexing, use 'search' to retrieve specific sections on-demand.",
+    "fetch_and_index",
+    "Fetches URL content, converts HTML to markdown, indexes into searchable knowledge base, and returns a ~3KB preview. Full content stays in sandbox \u2014 use search() for deeper lookups.\n\nBetter than WebFetch: preview is immediate, full content is searchable, raw HTML never enters context.",
     {
-      content: external_exports.string().optional().describe("Raw text/markdown to index. Provide this OR path, not both."),
-      path: external_exports.string().optional().describe("File path to read and index (content never enters context)."),
+      url: external_exports.string().describe("The URL to fetch and index"),
       source: external_exports.string().optional().describe("Label for the indexed content")
     },
-    async ({ content, path: filePath, source }) => {
-      let text;
-      let label = source ?? "indexed content";
-      if (filePath) {
-        const absPath = resolve(projectDir, filePath);
-        if (!isWithinProject(absPath)) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error: path "${filePath}" is outside the project directory`
-              }
-            ]
-          };
-        }
-        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);
+    async ({ url, source }) => {
+      try {
+        const parsed = new URL(url);
+        if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
           return {
-            content: [{ type: "text", text: `Error reading "${filePath}": ${msg}` }]
+            content: [{ type: "text", text: "Error: only http/https URLs are allowed" }],
+            isError: true
           };
         }
-      } else if (content) {
-        const contentBytes = Buffer.byteLength(content);
-        if (contentBytes > 50 * 1024 * 1024) {
+        if (isPrivateHost(parsed.hostname)) {
           return {
             content: [
-              {
-                type: "text",
-                text: `Error: content too large (${(contentBytes / 1024 / 1024).toFixed(1)}MB). Max 50MB.`
-              }
-            ]
+              { type: "text", text: "Error: internal/private URLs are not allowed" }
+            ],
+            isError: true
           };
         }
-        text = content;
-      } else {
+      } catch {
         return {
-          content: [{ type: "text", text: "Error: provide either 'content' or 'path'" }]
-        };
-      }
-      const result = store.index(text, label);
-      tracker.trackIndexed(Buffer.byteLength(text));
-      const summary = `Indexed "${label}": ${result.totalChunks} chunks (${result.codeChunks} with code). Use search(queries: [...]) to retrieve sections.`;
-      tracker.trackCall("index", Buffer.byteLength(summary));
-      return { content: [{ type: "text", text: summary }] };
-    }
-  );
-  server2.tool(
-    "search",
-    "Search indexed content. Pass ALL search questions as queries array in ONE call.\n\nTIPS: 2-4 specific terms per query. Use 'source' to scope results.",
-    {
-      queries: external_exports.array(external_exports.string()).describe("Array of search queries. Batch ALL questions in one call."),
-      source: external_exports.string().optional().describe("Filter to a specific indexed source (partial match)."),
-      limit: external_exports.number().default(3).describe("Results per query (default: 3)")
-    },
-    async ({ queries, source, limit }) => {
-      const now = Date.now();
-      searchCalls.push(now);
-      while (searchCalls.length > 0 && searchCalls[0] < now - config3.searchWindowMs) {
-        searchCalls.shift();
-      }
-      const callCount = searchCalls.length;
-      if (callCount > config3.searchBlockAfter) {
-        const msg = "Too many search calls in quick succession. Use batch_execute instead to run commands and search in one call.";
-        tracker.trackCall("search", Buffer.byteLength(msg));
-        return { content: [{ type: "text", text: msg }] };
-      }
-      const effectiveLimit = callCount > config3.searchReduceAfter ? 1 : Math.min(limit, config3.searchLimit);
-      const allResults = [];
-      let totalBytes = 0;
-      for (const query of queries) {
-        if (totalBytes > config3.searchMaxBytes) break;
-        const result = store.search(query, { source, limit: effectiveLimit });
-        let block = `## ${query}
-`;
-        if (result.corrected) {
-          block += `(corrected to: "${result.corrected}")
-`;
-        }
-        if (result.results.length === 0) {
-          block += "No results found.\n";
-        } else {
-          for (const hit of result.results) {
-            block += `
---- [${hit.source}] ---
-### ${hit.title}
-
-${hit.snippet}
-`;
-          }
-        }
-        allResults.push(block);
-        totalBytes += Buffer.byteLength(block);
-      }
-      if (callCount > config3.searchReduceAfter) {
-        allResults.push(
-          `
-\u26A0 Search rate limited (${callCount} calls in ${config3.searchWindowMs / 1e3}s). Results reduced to 1 per query.`
-        );
-      }
-      const output = allResults.join("\n---\n\n");
-      tracker.trackCall("search", Buffer.byteLength(output));
-      return { content: [{ type: "text", text: output }] };
-    }
-  );
-  server2.tool(
-    "fetch_and_index",
-    "Fetches URL content, converts HTML to markdown, indexes into searchable knowledge base, and returns a ~3KB preview. Full content stays in sandbox \u2014 use search() for deeper lookups.\n\nBetter than WebFetch: preview is immediate, full content is searchable, raw HTML never enters context.",
-    {
-      url: external_exports.string().describe("The URL to fetch and index"),
-      source: external_exports.string().optional().describe("Label for the indexed content")
-    },
-    async ({ url, source }) => {
-      try {
-        const parsed = new URL(url);
-        if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-          return {
-            content: [{ type: "text", text: "Error: only http/https URLs are allowed" }]
-          };
-        }
-        if (isPrivateHost(parsed.hostname)) {
-          return {
-            content: [
-              { type: "text", text: "Error: internal/private URLs are not allowed" }
-            ]
-          };
-        }
-      } catch {
-        return {
-          content: [{ type: "text", text: `Error: invalid URL "${url}"` }]
+          content: [{ type: "text", text: `Error: invalid URL "${url}"` }],
+          isError: true
         };
       }
       let resolvedIp = null;
@@ -23103,7 +23766,8 @@ ${hit.snippet}
               type: "text",
               text: `Error: ${err instanceof Error ? err.message : "DNS validation failed"}`
             }
-          ]
+          ],
+          isError: true
         };
       }
       const label = source ?? url;
@@ -23119,12 +23783,12 @@ ${hit.snippet}
         );
       } catch (e) {
         const msg = e instanceof Error ? e.message : String(e);
-        return { content: [{ type: "text", text: msg }] };
+        return { content: [{ type: "text", text: msg }], isError: true };
       }
       if (result.exitCode !== 0 || !result.stdout.trim()) {
         const errMsg = `Failed to fetch ${url}: ${result.stderr || "empty response"}`;
         tracker.trackCall("fetch_and_index", Buffer.byteLength(errMsg));
-        return { content: [{ type: "text", text: errMsg }] };
+        return { content: [{ type: "text", text: errMsg }], isError: true };
       }
       const markdown = result.stdout;
       tracker.trackSandboxed(result.networkBytes ?? 0);
@@ -23154,188 +23818,311 @@ Searchable terms: ${terms.join(", ")}`;
       return { content: [{ type: "text", text: output }] };
     }
   );
+}
+
+// src/tools/index-content.ts
+import { readFileSync as readFileSync3, statSync } from "node:fs";
+import { resolve as resolve3 } from "node:path";
+function registerIndexTool(server2, ctx) {
+  const { store, tracker, projectDir: projectDir2 } = ctx;
   server2.tool(
-    "batch_execute",
-    "Execute multiple commands in ONE call, auto-index all output, and search with multiple queries. Returns search results directly \u2014 no follow-up calls needed.\n\nTHIS IS THE PRIMARY TOOL. Use this instead of multiple execute() calls.\n\nOne batch_execute call replaces 30+ execute calls + 10+ search calls.\nProvide all commands to run and all queries to search \u2014 everything happens in one round trip.",
+    "index",
+    "Index documentation or knowledge content into a searchable BM25 knowledge base. Chunks markdown by headings (keeping code blocks intact) and stores in ephemeral FTS5 database. The full content does NOT stay in context \u2014 only a brief summary is returned.\n\nWHEN TO USE:\n- Documentation (API docs, framework guides, code examples)\n- README files, migration guides, changelog entries\n- Any content with code examples you may need to reference precisely\n\nAfter indexing, use 'search' to retrieve specific sections on-demand.",
     {
-      commands: external_exports.array(
-        external_exports.object({
-          label: external_exports.string().describe("Section header for this command's output"),
-          command: external_exports.string().describe("Shell command to execute")
-        })
-      ).describe("Commands to execute as a batch."),
-      queries: external_exports.array(external_exports.string()).describe(
-        "Search queries to extract information from indexed output. Use 5-8 comprehensive queries."
-      ),
-      timeout: external_exports.number().default(6e4).describe("Max execution time in ms (default: 60s)")
+      content: external_exports.string().optional().describe("Raw text/markdown to index. Provide this OR path, not both."),
+      path: external_exports.string().optional().describe("File path to read and index (content never enters context)."),
+      source: external_exports.string().optional().describe("Label for the indexed content")
     },
-    async ({ commands, queries, timeout }) => {
-      const commandResults = await limitConcurrency(
-        commands.map((cmd) => async () => {
-          const result = await withExecutionLimit(
-            () => executor.execute({
-              language: "shell",
-              code: cmd.command,
-              timeout
-            })
-          );
-          return { label: cmd.label, result };
-        }),
-        4
-      );
-      let combined = "";
-      const inventory = [];
-      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)";
-          combined += `## ${label}
-
-${output2}
-
-`;
-          const lineCount = output2.split("\n").length;
-          inventory.push(`- **${label}**: ${lineCount} lines`);
-        } else {
-          combined += `## ${label}
-
-(error: ${settled.reason})
-
-`;
-          inventory.push(`- **${label}**: error`);
+    async ({ content, path: filePath, source }) => {
+      let text;
+      let label = source ?? "indexed content";
+      if (filePath) {
+        const absPath = resolve3(projectDir2, filePath);
+        if (!isWithinProject(absPath, projectDir2)) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error: path "${filePath}" is outside the project directory`
+              }
+            ],
+            isError: true
+          };
         }
+        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.`
+                }
+              ],
+              isError: true
+            };
+          }
+          text = readFileSync3(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}` }],
+            isError: true
+          };
+        }
+      } 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.`
+              }
+            ],
+            isError: true
+          };
+        }
+        text = content;
+      } else {
+        return {
+          content: [{ type: "text", text: "Error: provide either 'content' or 'path'" }],
+          isError: true
+        };
       }
-      const indexed = store.index(combined, "batch_execute");
-      tracker.trackIndexed(Buffer.byteLength(combined));
-      const searchResults = [];
+      const result = store.index(text, label);
+      tracker.trackIndexed(Buffer.byteLength(text));
+      const summary = `Indexed "${label}": ${result.totalChunks} chunks (${result.codeChunks} with code). Use search(queries: [...]) to retrieve sections.`;
+      tracker.trackCall("index", Buffer.byteLength(summary));
+      return { content: [{ type: "text", text: summary }] };
+    }
+  );
+}
+
+// src/tools/search.ts
+function registerSearchTool(server2, ctx) {
+  const { store, tracker, config: config3 } = ctx;
+  const searchCalls = [];
+  server2.tool(
+    "search",
+    "Search indexed content. Pass ALL search questions as queries array in ONE call.\n\nTIPS: 2-4 specific terms per query. Use 'source' to scope results.",
+    {
+      queries: external_exports.array(external_exports.string()).describe("Array of search queries. Batch ALL questions in one call."),
+      source: external_exports.string().optional().describe("Filter to a specific indexed source (partial match)."),
+      limit: external_exports.number().default(3).describe("Results per query (default: 3)")
+    },
+    async ({ queries, source, limit }) => {
+      const now = Date.now();
+      searchCalls.push(now);
+      while (searchCalls.length > 0 && searchCalls[0] < now - config3.searchWindowMs) {
+        searchCalls.shift();
+      }
+      const callCount = searchCalls.length;
+      if (callCount > config3.searchBlockAfter) {
+        const msg = "Too many search calls in quick succession. Use batch_execute instead to run commands and search in one call.";
+        tracker.trackCall("search", Buffer.byteLength(msg));
+        return { content: [{ type: "text", text: msg }] };
+      }
+      const effectiveLimit = callCount > config3.searchReduceAfter ? 1 : Math.min(limit, config3.searchLimit);
+      const allResults = [];
       let totalBytes = 0;
       for (const query of queries) {
-        if (totalBytes > config3.batchMaxBytes) break;
-        let result = store.search(query, { source: "batch_execute", limit: 5 });
-        if (result.results.length === 0) {
-          result = store.search(query, { limit: 5 });
-        }
+        if (totalBytes > config3.searchMaxBytes) break;
+        const result = store.search(query, { source, limit: effectiveLimit });
         let block = `## ${query}
-
 `;
+        if (result.corrected) {
+          block += `(corrected to: "${result.corrected}")
+`;
+        }
         if (result.results.length === 0) {
           block += "No results found.\n";
         } else {
           for (const hit of result.results) {
-            block += `--- [${hit.source}] ---
+            block += `
+--- [${hit.source}] ---
 ### ${hit.title}
 
 ${hit.snippet}
-
 `;
           }
         }
-        searchResults.push(block);
+        allResults.push(block);
         totalBytes += Buffer.byteLength(block);
       }
-      const terms = store.getDistinctiveTerms(indexed.sourceId);
-      let output = `**Inventory** (${commands.length} commands):
-${inventory.join("\n")}
-
-`;
-      output += searchResults.join("\n---\n\n");
-      if (terms.length > 0) {
-        output += `
-
-Searchable terms: ${terms.join(", ")}`;
+      if (callCount > config3.searchReduceAfter) {
+        allResults.push(
+          `
+\u26A0 Search rate limited (${callCount} calls in ${config3.searchWindowMs / 1e3}s). Results reduced to 1 per query.`
+        );
       }
-      tracker.trackCall("batch_execute", Buffer.byteLength(output));
+      const output = allResults.join("\n---\n\n");
+      tracker.trackCall("search", Buffer.byteLength(output));
       return { content: [{ type: "text", text: output }] };
     }
   );
+}
+
+// src/tools/stats.ts
+function registerStatsTool(server2, ctx) {
+  const { tracker } = ctx;
   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, context savings ratio, and visual charts.",
     {},
     async () => {
+      tracker.saveCumulative();
       const report = tracker.formatReport();
       tracker.trackCall("stats", Buffer.byteLength(report));
       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 }] };
+}
+
+// src/util/label.ts
+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;
+}
+
+// src/util/intent-filter.ts
+function createIntentFilter(deps) {
+  const { config: config3, store, tracker } = deps;
+  return 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);
+  };
+}
+
+// src/util/version.ts
+import { readFileSync as readFileSync4 } from "node:fs";
+import { dirname, resolve as resolve4 } from "node:path";
+import { fileURLToPath } from "node:url";
+var __dirname = dirname(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"));
+    return pkg.version ?? fallback;
+  } catch {
+    return fallback;
+  }
+}
+
+// src/server.ts
+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) {
+  const version2 = getVersion();
+  debug("Version:", version2);
+  cleanupStaleDbs();
+  const runtimes = await detectRuntimes();
+  const bunDetected = hasBun(runtimes);
+  debug("Runtimes detected:", runtimes.size);
+  const executor = new SubprocessExecutor(runtimes, config3);
+  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 cumulativeFile = config3.persistDb ? join4(config3.dbDir ?? join4(projectDir, ".context-compress"), "stats.json") : void 0;
+  const tracker = new SessionTracker(cumulativeFile);
+  let activeExecutions = 0;
+  async function withExecutionLimit(fn) {
+    if (activeExecutions >= MAX_CONCURRENT_EXECUTIONS) {
+      throw new Error(EXECUTION_LIMIT_ERROR);
+    }
+    activeExecutions++;
+    try {
+      return await fn();
+    } finally {
+      activeExecutions--;
+    }
+  }
+  const applyIntentFilter = createIntentFilter({ config: config3, store, tracker });
+  const shutdown = () => {
+    try {
+      tracker.saveCumulative();
+    } catch {
+    }
+    try {
+      executor.shutdown();
+    } catch {
+    }
+    try {
+      store.close();
+    } catch {
+    }
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  process.on("beforeExit", shutdown);
+  process.on("uncaughtException", (err) => {
+    debug("Uncaught exception:", err);
+    shutdown();
+    process.exit(1);
+  });
+  process.on("unhandledRejection", (err) => {
+    debug("Unhandled rejection:", err);
+    shutdown();
+    process.exit(1);
+  });
+  const server2 = new McpServer({
+    name: "context-compress",
+    version: version2
+  });
+  const ctx = {
+    config: config3,
+    store,
+    tracker,
+    executor,
+    projectDir,
+    bunDetected,
+    dbFallback,
+    withExecutionLimit,
+    applyIntentFilter
+  };
+  registerExecuteTool(server2, ctx);
+  registerExecuteFileTool(server2, ctx);
+  registerIndexTool(server2, ctx);
+  registerSearchTool(server2, ctx);
+  registerFetchAndIndexTool(server2, ctx);
+  registerBatchExecuteTool(server2, ctx);
+  registerStatsTool(server2, ctx);
+  registerDiscoverTool(server2, ctx);
   return {
     async start() {
       const transport = new StdioServerTransport();
@@ -23344,79 +24131,6 @@ Searchable terms: ${terms.join(", ")}`;
     }
   };
 }
-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 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);
-}
-
-// Strip unwanted tags
-let md = html
-  .replace(/<script[^>]*>[\\s\\S]*?<\\/script>/gi, "")
-  .replace(/<style[^>]*>[\\s\\S]*?<\\/style>/gi, "")
-  .replace(/<nav[^>]*>[\\s\\S]*?<\\/nav>/gi, "")
-  .replace(/<header[^>]*>[\\s\\S]*?<\\/header>/gi, "")
-  .replace(/<footer[^>]*>[\\s\\S]*?<\\/footer>/gi, "");
-
-// Convert headings
-md = md.replace(/<h1[^>]*>(.*?)<\\/h1>/gi, "# $1\\n");
-md = md.replace(/<h2[^>]*>(.*?)<\\/h2>/gi, "## $1\\n");
-md = md.replace(/<h3[^>]*>(.*?)<\\/h3>/gi, "### $1\\n");
-md = md.replace(/<h4[^>]*>(.*?)<\\/h4>/gi, "#### $1\\n");
-
-// Convert code blocks
-md = md.replace(/<pre[^>]*><code[^>]*>(.*?)<\\/code><\\/pre>/gis, "\`\`\`\\n$1\\n\`\`\`\\n");
-md = md.replace(/<code[^>]*>(.*?)<\\/code>/gi, "\`$1\`");
-
-// Convert links
-md = md.replace(/<a[^>]*href="([^"]*)"[^>]*>(.*?)<\\/a>/gi, "[$2]($1)");
-
-// Convert lists
-md = md.replace(/<li[^>]*>(.*?)<\\/li>/gi, "- $1\\n");
-
-// Convert paragraphs
-md = md.replace(/<p[^>]*>(.*?)<\\/p>/gis, "$1\\n\\n");
-md = md.replace(/<br\\s*\\/?>/gi, "\\n");
-
-// Strip remaining tags
-md = md.replace(/<[^>]+>/g, "");
-
-// Decode entities
-md = md.replace(/&lt;/g, "<")
-  .replace(/&gt;/g, ">")
-  .replace(/&quot;/g, '"')
-  .replace(/&#39;/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();
-
-console.log(md);
-`;
-}
 
 // src/index.ts
 var config2 = loadConfig(process.env.CLAUDE_PROJECT_DIR);