token-goat 2.9.4 → 2.9.5

package/dist/{token-goat-chunk-3ZR4NLB3.mjs → token-goat-chunk-ZOKNDG6V.mjs}

@@ -12,7 +12,7 @@ init_define_import_meta_env();
 import { createRequire } from "node:module";
 function resolveVersion() {
   if (true) {
-    return "2.9.4";
+    return "2.9.5";
   }
   const require2 = createRequire(import.meta.url);
   const pkg = require2("../package.json");
@@ -2273,8 +2273,16 @@ var CONFIG_DEFAULTS = {
     // existing users -- see the reread_deny/reread_deny_min_bytes fix's commit message.
     reread_deny_min_bytes: 51200,
     stable_doc_compacts: true,
-    // Off until measured. This one rewrites what the model reads on a FIRST look at a source file, where -- unlike every re-read mechanism beside it -- the reader has no prior copy to notice an omission against. Its restore rate and edit-error delta cannot be observed until it has run, so the honest default is the one that changes nothing.
-    fold_code_bodies: false,
+    // On. It has now run. The gate that finds the spans answered only from the index, and the index carried the shipping parser stamp on 46 of 17,952 files, so the lever was very nearly dead in practice: a disk parse of the delivered file is now the fallback, worth +3.0 points of withheld bytes on shell reads with no index at all. The cost side is the one this comment used to call unobservable, and it is observable: joining folds to later reads of the folded symbol scores 62.3% recovery, but the same window measured backwards scores 55.8% and a shuffled pairing scores 24.3%, so the excess attributable to the fold is 6.6 points rather than 62. Unlike every re-read mechanism beside it this rewrites a FIRST look, where the reader has no prior copy to notice an omission against, which is why the notice names the symbol and the command that returns it verbatim.
+    fold_code_bodies: true,
+    // On, and separate from the body fold above because the two do not carry the same risk. A body fold needs symbol spans from the index, so it can cut at the wrong line when the index is stale, and it hides the implementation an agent came to read. A comment fold reads the block boundaries off the delivered text itself, so it cannot be stale and works on the first read of a file the indexer has never seen, which is exactly the surface nothing else here reaches. It keeps the opening two lines of a block of 12 or more, so the summary sentence a reader navigates by survives and only the elaboration is replaced, and it alters the text of no line it keeps, its notice naming the absolute range removed so the recall is exact. Measured across this project's own 259 source files it removes 8.07% of the delivered bytes over 420 folds in 170 files. The nearest published measurement is stronger and cruder: removing docstrings outright cost 3 points of resolution rate on SWE-bench Verified for 22% of the tokens (arXiv:2606.01326), and keeping the opening summary is the gentler trade on that curve.
+    fold_comment_blocks: true,
+    // On. It has now run: measured over 2,032 real document reads it removes 43.4% of the pool and 57.4% of the reads it touches, keeping every heading, table, block quote and fenced line, and replacing only the tail of a paragraph whose opening sentence is already a complete one. The recall it needs is a ranged Read of the single line named in the notice, which costs one call and is printed at the point of the cut rather than left for the reader to work out. The project-config lock below stays regardless of this default: a repository still cannot set this key, so the choice to fold is the reader's environment and never the code being read.
+    fold_prose_paragraphs: true,
+    // On. Fires on an untargeted (no offset/limit) Read of a markdown document at least 8,000 bytes with at least 6 headings, replacing the delivered body with a heading tree plus the document preamble when that replacement is meaningfully smaller. Built from the delivered text itself, never the index, so it works on a document the indexer has never seen. Measured over 5,104 real session transcripts (13,870 Read deliveries, 130,249,204 bytes): untargeted markdown reads with >=6 headings at this 8,000-byte floor withhold 41.03% of all Read bytes, within 1.8 points of the best floor tried (2,000 B) while firing far less often on small documents where the interruption is least worth it.
+    outline_large_documents: true,
+    // On. The source-code sibling of outline_large_documents directly above, and gated the same way: an untargeted (no offset/limit) Read of a tree-sitter language at least 12,000 bytes with at least 8 symbols is replaced by its structural skeleton, the preamble plus one declaration line per symbol, with each withheld run named and pointed at the command that returns it. Symbols come from tree-sitter over the delivered text, never the index and never the regex extractors, so a partial symbol list turns the fold off rather than shipping a skeleton missing declarations nothing signals. Measured over 5,104 real session transcripts (130,325,670 delivered Read bytes): 558 reads clear this floor, and the fold withholds 11,241,796 B, 8.63% of all Read bytes.
+    skeleton_large_sources: true,
     truncated_read_min_lines: 200,
     protect_recent_reads: 4,
     warn_unbalanced_shell_quoting: true,
@@ -2611,6 +2619,14 @@ var PROJECT_LOCKED_SECTIONS = [
 var PROJECT_LOCKED_KEYS = [
   // A repository must not be able to decide how much of its own source an agent gets to see. Turning this on folds function bodies out of every Read of this project's files, so a checked-in `.token-goat.toml` setting it true would shrink what a reviewing agent is shown of the very code it came to review -- and the fold is silent about intent, so it reads as normal output. The user's own global config and TOKEN_GOAT_FOLD_CODE_BODIES still set it freely; only the project-supplied layer is refused.
   "hints.fold_code_bodies",
+  // Same reasoning as the body fold above, on the comments rather than the code: a checked-in project file must not be able to fold a repository's own explanatory comments out of what a reviewing agent is shown, which is precisely where an intent that disagrees with the code would be written down. The user's global config and TOKEN_GOAT_FOLD_COMMENT_BLOCKS still set it freely.
+  "hints.fold_comment_blocks",
+  // Same reasoning one document over: a repository must not be able to fold its own README or changelog out of what a reviewing agent is shown. The user's global config and TOKEN_GOAT_FOLD_PROSE_PARAGRAPHS still set it freely.
+  "hints.fold_prose_paragraphs",
+  // Same reasoning again: a repository must not be able to hide its own documentation's structure from a reviewing agent by disabling the heading-tree replacement, nor -- more to the point here -- by leaving it on to shrink what a reviewing agent sees of a doc the repo itself ships. The user's global config and TOKEN_GOAT_OUTLINE_LARGE_DOCUMENTS still set it freely.
+  "hints.outline_large_documents",
+  // Same reasoning one file type over: a repository must not be able to decide, from its own checked-in config, how much of its source a reviewing agent is shown -- neither by turning the skeleton off to bury a declaration in a wall of bodies, nor by leaving it on to withhold the bodies themselves. The user's global config and TOKEN_GOAT_SKELETON_LARGE_SOURCES still set it freely.
+  "hints.skeleton_large_sources",
   "image_shrink.max_image_pixels",
   "indexing.cross_project_symbols",
   "worker.blocked_roots"
@@ -3024,6 +3040,10 @@ function _buildConfig(raw, projectRaw = {}) {
   hi.reread_deny_min_bytes = validatedIntWithLegacySentinel(hi_raw["reread_deny_min_bytes"], hi.reread_deny_min_bytes, 2048, ...boundsOf("hints.reread_deny_min_bytes"));
   hi.stable_doc_compacts = validatedBool(hi_raw["stable_doc_compacts"], hi.stable_doc_compacts);
   hi.fold_code_bodies = validatedBool(hi_raw["fold_code_bodies"], hi.fold_code_bodies);
+  hi.fold_comment_blocks = validatedBool(hi_raw["fold_comment_blocks"], hi.fold_comment_blocks);
+  hi.fold_prose_paragraphs = validatedBool(hi_raw["fold_prose_paragraphs"], hi.fold_prose_paragraphs);
+  hi.outline_large_documents = validatedBool(hi_raw["outline_large_documents"], hi.outline_large_documents);
+  hi.skeleton_large_sources = validatedBool(hi_raw["skeleton_large_sources"], hi.skeleton_large_sources);
   hi.truncated_read_min_lines = validatedInt(hi_raw["truncated_read_min_lines"], hi.truncated_read_min_lines, ...boundsOf("hints.truncated_read_min_lines"));
   hi.protect_recent_reads = validatedInt(hi_raw["protect_recent_reads"], hi.protect_recent_reads, ...boundsOf("hints.protect_recent_reads"));
   hi.warn_unbalanced_shell_quoting = validatedBool(hi_raw["warn_unbalanced_shell_quoting"], hi.warn_unbalanced_shell_quoting);
@@ -3053,6 +3073,10 @@ function _buildConfig(raw, projectRaw = {}) {
   hi.git_hint_max_ms = envInt("TOKEN_GOAT_GIT_HINT_MAX_MS", hi.git_hint_max_ms, ...boundsOf("hints.git_hint_max_ms"));
   hi.stable_doc_compacts = envBool("TOKEN_GOAT_STABLE_DOC_COMPACTS", hi.stable_doc_compacts);
   hi.fold_code_bodies = envBool("TOKEN_GOAT_FOLD_CODE_BODIES", hi.fold_code_bodies);
+  hi.fold_comment_blocks = envBool("TOKEN_GOAT_FOLD_COMMENT_BLOCKS", hi.fold_comment_blocks);
+  hi.fold_prose_paragraphs = envBool("TOKEN_GOAT_FOLD_PROSE_PARAGRAPHS", hi.fold_prose_paragraphs);
+  hi.outline_large_documents = envBool("TOKEN_GOAT_OUTLINE_LARGE_DOCUMENTS", hi.outline_large_documents);
+  hi.skeleton_large_sources = envBool("TOKEN_GOAT_SKELETON_LARGE_SOURCES", hi.skeleton_large_sources);
   hi.context_threshold_advisory = envBool("TOKEN_GOAT_CONTEXT_THRESHOLD_ADVISORY", hi.context_threshold_advisory);
   hi.pre_skill_advisory = envBool("TOKEN_GOAT_PRE_SKILL_ADVISORY", hi.pre_skill_advisory);
   hi.quiet_hours = envStr("TOKEN_GOAT_QUIET_HOURS", hi.quiet_hours);
@@ -3221,6 +3245,10 @@ var CONFIG_KEY_ENV_OVERRIDES = {
   "hints.git_hint_max_ms": ["TOKEN_GOAT_GIT_HINT_MAX_MS"],
   "hints.stable_doc_compacts": ["TOKEN_GOAT_STABLE_DOC_COMPACTS"],
   "hints.fold_code_bodies": ["TOKEN_GOAT_FOLD_CODE_BODIES"],
+  "hints.fold_comment_blocks": ["TOKEN_GOAT_FOLD_COMMENT_BLOCKS"],
+  "hints.fold_prose_paragraphs": ["TOKEN_GOAT_FOLD_PROSE_PARAGRAPHS"],
+  "hints.outline_large_documents": ["TOKEN_GOAT_OUTLINE_LARGE_DOCUMENTS"],
+  "hints.skeleton_large_sources": ["TOKEN_GOAT_SKELETON_LARGE_SOURCES"],
   "hints.context_threshold_advisory": ["TOKEN_GOAT_CONTEXT_THRESHOLD_ADVISORY"],
   "hints.pre_skill_advisory": ["TOKEN_GOAT_PRE_SKILL_ADVISORY"],
   "hints.quiet_hours": ["TOKEN_GOAT_QUIET_HOURS"],
@@ -3360,6 +3388,10 @@ function saveConfig(config) {
       reread_deny_min_bytes: config.hints.reread_deny_min_bytes,
       stable_doc_compacts: config.hints.stable_doc_compacts,
       fold_code_bodies: config.hints.fold_code_bodies,
+      fold_comment_blocks: config.hints.fold_comment_blocks,
+      fold_prose_paragraphs: config.hints.fold_prose_paragraphs,
+      outline_large_documents: config.hints.outline_large_documents,
+      skeleton_large_sources: config.hints.skeleton_large_sources,
       truncated_read_min_lines: config.hints.truncated_read_min_lines,
       protect_recent_reads: config.hints.protect_recent_reads,
       prompt_triggers: config.hints.prompt_triggers,
@@ -4293,7 +4325,7 @@ function makeLineSymbol(filePath, name, kind, line, sig, parent, lines, style) {
     parent: parent ?? ""
   };
 }
-function makeSymbolEmitter(symbols, sections, seen, filePath, maxSymbols = 500, maxHeadingLen = 120) {
+function makeSymbolEmitter(symbols, sections, seen, filePath, maxSymbols = 1e4, maxHeadingLen = 120) {
   return function emit(name, kind, line) {
     if (!name || name.length > maxHeadingLen) return;
     if (symbols.length >= maxSymbols) return;
@@ -5996,7 +6028,8 @@ var _KIND_GROUPS = [
     members: /* @__PURE__ */ new Set([
       "skill_load",
       "skill_oversized_first_load",
-      "skill_compact_inlined"
+      "skill_compact_inlined",
+      "skill_heading_tree_inlined"
     ])
   },
   // SOURCE_CONTENT: real rewrites of tool output that remove real bytes (agent report compaction, Grep fold, browser tab dedup, bash/content compression and the handoff pair). The by-source table has shown a 'content' row since the source was added, but the by-kind table had no member set for it, so every one of these kinds printed under 'Other'. The taskoutput: prefix branch in _kindGroupLabel routes here too.
@@ -6011,6 +6044,8 @@ var _KIND_GROUPS = [
       "grep:fold",
       "read:served_elide",
       "read:body_fold",
+      "read:markdown_outline",
+      "read:source_skeleton",
       "handoff_create",
       "handoff_resolve",
       "plan_echo_collapse"
@@ -6326,6 +6361,10 @@ function renderStats(stats, opts) {
 
 // src/stats.ts
 var HARNESS_UNRECORDED = "unrecorded (pre-2.8.1)";
+var PRICING_VERSION_UNRECORDED = "unrecorded (pre-tg_version column)";
+function hasMixedPricingEras(summary) {
+  return Object.keys(summary.by_pricing_version).length > 1;
+}
 var SOURCE_IMAGE = "image";
 var SOURCE_HINT = "hint";
 var SOURCE_READ = "read";
@@ -6431,6 +6470,8 @@ var KIND_TO_SOURCE = {
   skill_oversized_first_load: SOURCE_SKILL,
   // Cold first load of an oversized skill where preSkillHandler inlined the compact slice in its reply instead of pointing at `skill-body --compact`. Unlike its skill_oversized_first_load sibling (event-only, 0 bytes -- the pointer deny saves nothing by itself, the follow-up command does) this one records real savings: the full body never landed, the slice did, so bytesSaved is body minus slice.
   skill_compact_inlined: SOURCE_SKILL,
+  // Cold first load of an oversized skill with no compact marker at all, where preSkillHandler inlined a heading tree in its reply instead of letting the whole body fall through. Same shape as skill_compact_inlined: real savings, bytesSaved is body minus the rendered tree.
+  skill_heading_tree_inlined: SOURCE_SKILL,
   secret_redacted: SOURCE_OTHER,
   // Fail-soft diagnostic counters from hooks_edit.ts: they record that a side task threw, never a byte saving, so "other" is the right home. Listed explicitly rather than left to kindToSource()'s fallback so the registration guard can tell a deliberate placement from an unregistered kind.
   dirty_queue_append_failed: SOURCE_OTHER,
@@ -6458,6 +6499,10 @@ var KIND_TO_SOURCE = {
   "read:served_elide": SOURCE_CONTENT,
   // Same bucket and same reasoning as read:served_elide directly above: a rewrite of a Read that did happen, with real bytes removed, not an advisory about whether to read at all.
   "read:body_fold": SOURCE_CONTENT,
+  // Same bucket and same reasoning as read:body_fold directly above: a coarser sibling rewrite of a large untargeted markdown Read (hooks_read.ts foldMarkdownOutline) that replaces the body with a heading tree plus preamble, with real bytes removed, not an advisory about whether to read at all.
+  "read:markdown_outline": SOURCE_CONTENT,
+  // Same bucket and same reasoning as read:markdown_outline directly above, on source instead of prose: the structural-skeleton replacement of a large untargeted source Read (hooks_read.ts foldSourceSkeleton), with real bytes removed, not an advisory about whether to read at all.
+  "read:source_skeleton": SOURCE_CONTENT,
   content_retrieve: SOURCE_CONTENT,
   handoff_create: SOURCE_CONTENT,
   handoff_resolve: SOURCE_CONTENT
@@ -6741,12 +6786,21 @@ function summarize(windowDays = 30, testDb, homeDir) {
   const byKind = {};
   const byDay = {};
   const byHarness = {};
+  const byPricingVersion = {};
   let totalEvents = 0;
   let totalBytes = 0;
   let totalTokens = 0;
   const db = testDb ?? getGlobalDb(homeDir);
   const hasHarness = statsHasHarnessColumn(db);
-  const cols = hasHarness ? "ts, kind, bytes_saved, tokens_saved, harness" : "ts, kind, bytes_saved, tokens_saved";
+  const hasVersion = statsHasVersionColumn(db);
+  const cols = [
+    "ts",
+    "kind",
+    "bytes_saved",
+    "tokens_saved",
+    ...hasHarness ? ["harness"] : [],
+    ...hasVersion ? ["tg_version"] : []
+  ].join(", ");
   const query = sinceTs !== null ? `SELECT ${cols} FROM stats WHERE ts >= ? ORDER BY ts DESC` : `SELECT ${cols} FROM stats ORDER BY ts DESC`;
   const stmt = db.prepare(query);
   const rows = sinceTs !== null ? stmt.all(sinceTs) : stmt.all();
@@ -6780,6 +6834,11 @@ function summarize(windowDays = 30, testDb, homeDir) {
       byHarness[harness] = zeroBucket();
     }
     incBucket(byHarness[harness], bytesSaved, tokensSaved);
+    const pricingVersion = row.tg_version || PRICING_VERSION_UNRECORDED;
+    if (!byPricingVersion[pricingVersion]) {
+      byPricingVersion[pricingVersion] = zeroBucket();
+    }
+    incBucket(byPricingVersion[pricingVersion], bytesSaved, tokensSaved);
   }
   const bySourceDict = {};
   for (const [kind, bucket] of Object.entries(byKind)) {
@@ -6817,6 +6876,7 @@ function summarize(windowDays = 30, testDb, homeDir) {
     by_project: byProjectList,
     by_source: bySourceDict,
     by_harness: byHarness,
+    by_pricing_version: byPricingVersion,
     counts,
     by_command: Object.entries(byCommandDict).map(([command, bucket]) => ({ ...bucket, command })).filter((r) => r.events > 0),
     window_days: windowDays
@@ -6828,6 +6888,15 @@ function _totalsLines(summary) {
     `Total events:   ${summary.total_events}`,
     `Bytes saved:    ${fmtBytes(summary.total_bytes_saved)}`,
     `Tokens saved:   ${summary.total_tokens_saved}`,
+    // Disclosure, not a correction: `total_tokens_saved` above sums rows written under whichever
+    // pricing formula was live when each was recorded, and `tg_version` cannot be read back into
+    // "which formula" for a row from before this disclosure existed (PRICING_VERSION_UNRECORDED is
+    // the overwhelming majority of all-time rows). Excluding those rows from the headline would
+    // discard nearly the whole figure rather than fix it, so the honest move is to keep the sum and
+    // say plainly that it spans more than one era, not to quietly present a mixed total as single-formula.
+    ...hasMixedPricingEras(summary) ? [
+      `Pricing note:   totals mix ${countNoun(Object.keys(summary.by_pricing_version).length, "tg_version era")} (${countNoun(summary.by_pricing_version[PRICING_VERSION_UNRECORDED]?.events ?? 0, "row")} unrecorded); see 'token-goat stats --json' -> by_pricing_version for the breakdown`
+    ] : [],
     // Printed on its own line, below the token total and never inside it, because it counts
     // placeholders rather than tokens. Omitted entirely when nothing was redacted, so the line is
     // information rather than a permanent zero. See COUNT_ONLY_KINDS.
@@ -7268,7 +7337,7 @@ function emitRewrite(updatedOutput, detail, savings, redaction = "count-here") {
   }
   if (savings !== void 0) {
     const bytesSaved = savings.originalBytes - Buffer.byteLength(updatedOutput, "utf-8");
-    if (bytesSaved > 0) recordStat(savings.kind, bytesSaved, savedTokensFromBytes(bytesSaved));
+    if (bytesSaved > 0) recordStat(savings.kind, bytesSaved, savedTokensFromBytes(bytesSaved), void 0, savings.detail);
   }
   return { hookType: "rewriteOutput", updatedOutput };
 }
@@ -9769,11 +9838,46 @@ var DEFAULT_MAX_BYTES = 64 * 1024;
 var MAX_INSPECT_BYTES = 2 * 1024 * 1024;
 var DEFAULT_MAX_INPUT_BYTES = 500 * 1024;
 var FALLBACK_MAX_LINE_CHARS = 400;
+var LONG_LINE_MAX_CHARS = 1e3;
+var ELIDED_MARKER_RE = /… \[\d+ chars elided\]/;
 function getMaxInputBytes() {
   const raw = process.env["TOKEN_GOAT_FILTER_MAX_BYTES"];
   const v = raw ? Number.parseInt(raw, 10) : 0;
   return Number.isFinite(v) && v > 0 ? v : DEFAULT_MAX_INPUT_BYTES;
 }
+function utf8SafeEnd(buf, n) {
+  if (n >= buf.length) return buf.length;
+  let end = n;
+  while (end > 0 && (buf[end] & 192) === 128) end--;
+  return end;
+}
+function clampKeepingEnds(text, maxBytes) {
+  const buf = Buffer.from(text, "utf8");
+  if (buf.length <= maxBytes) return null;
+  const lines = text.split("\n");
+  const budget = maxBytes - Buffer.byteLength(`... [${lines.length} more lines elided by token-goat]
+`, "utf8");
+  const half = Math.floor(budget / 2);
+  let headEnd = 0;
+  for (let used = 0; headEnd < lines.length; headEnd++) {
+    const n = Buffer.byteLength(lines[headEnd], "utf8") + 1;
+    if (used + n > half) break;
+    used += n;
+  }
+  let tailStart = lines.length;
+  for (let used = 0; tailStart > headEnd; tailStart--) {
+    const n = Buffer.byteLength(lines[tailStart - 1], "utf8") + 1;
+    if (used + n > half) break;
+    used += n;
+  }
+  if (headEnd === 0 && tailStart === lines.length) return buf.subarray(0, utf8SafeEnd(buf, maxBytes)).toString("utf8");
+  const elided = tailStart - headEnd;
+  return [
+    ...lines.slice(0, headEnd),
+    `... [${elided} more line${elided === 1 ? "" : "s"} elided by token-goat]`,
+    ...lines.slice(tailStart)
+  ].join("\n");
+}
 function compressionMarker(filter, pct) {
   return `
 [token-goat: ${filter} filter -${Math.round(pct)}%; disable via TOKEN_GOAT_BASH_COMPRESS]`;
@@ -9785,6 +9889,7 @@ ${stderr.replace(/\s+$/, "")}`;
   return stdout.trim() ? stdout.replace(/\s+$/, "") : stderr.replace(/\s+$/, "");
 }
 var ERROR_SIGNAL_RE = /error:|Error:|ERROR|FAILED|failed|fatal:|Traceback|exception:|Exception:|AssertionError|assert |panic:/i;
+var TABLE_ROW_ANOMALY_RE = /\b(?:CrashLoopBackOff|ImagePullBackOff|ErrImagePull|CreateContainerError|CreateContainerConfigError|InvalidImageName|RunContainerError|OOMKilled|Evicted|Terminating|ContainerCreating|PodInitializing|NotReady|SchedulingDisabled|Unschedulable|Pending|Failed|Error|Unknown|Unhealthy|DEGRADED|UNAVAILABLE|STOPPED|STOPPING|TERMINATED|TERMINATING|FAILED|ROLLBACK_COMPLETE|ROLLBACK_FAILED|CREATE_FAILED|UPDATE_FAILED|DELETE_FAILED)\b/;
 var TIMESTAMP_PREFIX_RE = /^\[?\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:\.\d+)?Z?\]?\s*|^\d{2}:\d{2}:\d{2}(?:\.\d+)?\s+/;
 var REDIRECT_TOKEN_RE = /^(\d*)(>>?|<<?).*$|^&>$|^>&.*$/;
 function maskQuotedSpans(cmd) {
@@ -9947,18 +10052,28 @@ function truncateMiddleSmart(lines, maxLines, opts = {}) {
   const total = lines.length;
   const effHead = Math.min(headKeep, Math.floor(total / 4));
   const effTail = Math.min(tailKeep, Math.floor(total / 4));
+  const chosenErrors = errorIndices.length <= maxErrorLines ? errorIndices : [
+    ...errorIndices.slice(0, Math.ceil(maxErrorLines / 2)),
+    ...errorIndices.slice(errorIndices.length - Math.floor(maxErrorLines / 2))
+  ];
+  const budgetForMiddle = Math.max(0, maxLines - effHead - effTail);
+  const half = Math.ceil(chosenErrors.length / 2);
+  const front = chosenErrors.slice(0, half);
+  const back = chosenErrors.slice(half).reverse();
+  const visitOrder = [];
+  for (let k = 0; k < Math.max(front.length, back.length); k++) {
+    if (k < front.length) visitOrder.push(front[k]);
+    if (k < back.length) visitOrder.push(back[k]);
+  }
   const middle = /* @__PURE__ */ new Set();
-  for (let k = 0; k < errorIndices.length && k < maxErrorLines; k++) {
-    const ei = errorIndices[k];
+  outer: for (const ei of visitOrder) {
     for (let ci = Math.max(0, ei - errorContext); ci < Math.min(total, ei + errorContext + 1); ci++) {
+      if (ci < effHead || ci >= total - effTail) continue;
+      if (middle.size >= budgetForMiddle) break outer;
       middle.add(ci);
     }
   }
-  for (let i = 0; i < effHead; i++) middle.delete(i);
-  for (let i = total - effTail; i < total; i++) middle.delete(i);
-  const budgetForMiddle = Math.max(0, maxLines - effHead - effTail);
-  let sortedMiddle = Array.from(middle).sort((a, b) => a - b);
-  if (sortedMiddle.length > budgetForMiddle) sortedMiddle = sortedMiddle.slice(0, budgetForMiddle);
+  const sortedMiddle = Array.from(middle).sort((a, b) => a - b);
   const result = [];
   const appendSection = (indices) => {
     for (let pos = 0; pos < indices.length; pos++) {
@@ -9989,23 +10104,19 @@ function truncateMiddleSmart(lines, maxLines, opts = {}) {
 function capBytes(text, maxBytes) {
   const encoded = Buffer.from(text, "utf8");
   if (encoded.length <= maxBytes) return text;
-  const marker = `
-... [${encoded.length - maxBytes} bytes elided by token-goat]`;
-  const budget = maxBytes - Buffer.byteLength(marker, "utf8");
-  if (budget <= 0) return marker.trim();
-  let slice = encoded.subarray(0, budget);
-  const nl = slice.lastIndexOf(10);
-  if (nl > budget / 2) slice = slice.subarray(0, nl);
-  while (slice.length > 0 && (encoded[slice.length] & 192) === 128) {
-    slice = slice.subarray(0, slice.length - 1);
-  }
-  return slice.toString("utf8") + marker;
+  const widestMarker = `
+... [${encoded.length} bytes elided by token-goat]`;
+  const budget = maxBytes - Buffer.byteLength(widestMarker, "utf8");
+  if (budget <= 0) return widestMarker.trim();
+  const kept = clampKeepingEnds(text, budget) ?? text;
+  return `${kept}
+... [${encoded.length - Buffer.byteLength(kept, "utf8")} bytes elided by token-goat]`;
 }
 function capTokens(text, maxTokens) {
   const clean = stripAnsiCodes(text);
   if (clean.length / 3.5 <= maxTokens) return text;
   const maxBytes = Math.floor(maxTokens * 3.5);
-  let truncated = capBytes(clean, maxBytes);
+  let truncated = clampKeepingEnds(clean, maxBytes) ?? clean;
   if (!truncated.includes("[token-goat: output capped at")) {
     truncated = truncated.replace(BYTES_ELIDED_MARKER_RE, "");
     truncated += `
@@ -10025,9 +10136,19 @@ function truncateTableRows(text, maxRows, hint) {
   const lines = text.split("\n");
   const nonEmpty = lines.filter((l) => l.trim());
   if (nonEmpty.length <= maxRows + 1) return text;
-  const elided = nonEmpty.length - maxRows - 1;
-  return `${nonEmpty.slice(0, maxRows + 1).join("\n")}
-[token-goat: ${elided} more rows; ${hint}]`;
+  const header = nonEmpty[0];
+  const rows = nonEmpty.slice(1);
+  const wanted = /* @__PURE__ */ new Set();
+  for (let i = 0; i < rows.length && wanted.size < maxRows; i++) {
+    if (TABLE_ROW_ANOMALY_RE.test(rows[i])) wanted.add(i);
+  }
+  const anomalies = wanted.size;
+  for (let i = 0; i < rows.length && wanted.size < maxRows; i++) wanted.add(i);
+  const kept = [...wanted].sort((a, b) => a - b);
+  const elided = rows.length - kept.length;
+  const note = anomalies ? `[token-goat: ${elided} more rows; ${anomalies} row(s) kept for a not-ready status, the rest from the top; ${hint}]` : `[token-goat: ${elided} more rows; ${hint}]`;
+  return `${[header, ...kept.map((i) => rows[i])].join("\n")}
+${note}`;
 }
 function trimRepeatedPrefix(lines, pattern, keep) {
   const out = [];
@@ -10315,6 +10436,7 @@ function shlexSplit(cmd) {
 function capLongLines(lines, maxChars = FALLBACK_MAX_LINE_CHARS) {
   return lines.map((line) => {
     if (line.length <= maxChars) return line;
+    if (ELIDED_MARKER_RE.test(line)) return line;
     let cut = maxChars;
     const high = line.charCodeAt(cut - 1);
     const low = line.charCodeAt(cut);
@@ -10511,7 +10633,7 @@ function isRewriteWorthwhile({
   return bytesSaved - noticeBytes >= minNetSavingsBytes;
 }
 function compressedTokensSaved(bytesSaved) {
-  return bytesSaved <= 0 ? 0 : Math.max(1, Math.floor(bytesSaved / 3) + 1);
+  return bytesSaved <= 0 ? 0 : Math.max(1, savedTokensFromBytes(bytesSaved));
 }
 var CompressedOutput = class {
   constructor(text, originalBytes, compressedBytes, filterName, exitCode = 0, notes = []) {
@@ -10532,7 +10654,7 @@ var CompressedOutput = class {
   get bytesSaved() {
     return Math.max(0, this.originalBytes - this.compressedBytes);
   }
-  /** Estimated token savings (`n // 3 + 1`, matching `estimateTokens`). */
+  /** Estimated token savings, matching `compressedTokensSaved` (bytes/4, the codebase-wide pricing constant). */
   get tokensSaved() {
     return compressedTokensSaved(this.bytesSaved);
   }
@@ -10643,19 +10765,19 @@ var ToolFilter = class {
    * Filters that handle errors structurally (pytest, cargo) override this
    * directly and leave `errorPassthrough` false.
    */
-  compress(stdout, stderr, exitCode, argv) {
+  compress(stdout, stderr, exitCode, argv, ctx = {}) {
     if (this.errorPassthrough) {
       const err = preserveStderrOnError(stdout, stderr, exitCode);
       if (err !== null) return err;
     }
-    return this.compressBody(stdout, stderr, exitCode, argv);
+    return this.compressBody(stdout, stderr, exitCode, argv, ctx);
   }
   /**
    * Inner compression logic, called after the error-passthrough guard.
    * Default is a passthrough that joins the two streams — useful when the only
    * compression is the ANSI / progress strip `apply` already performed.
    */
-  compressBody(stdout, stderr, _exitCode, _argv) {
+  compressBody(stdout, stderr, _exitCode, _argv, _ctx = {}) {
     if (stderr && stdout) return `${stdout.replace(/\s+$/, "")}
 ---
 ${stderr.replace(/\s+$/, "")}`;
@@ -10677,14 +10799,16 @@ ${stderr.replace(/\s+$/, "")}`;
     const notes = [];
     const soBytes = Buffer.from(so, "utf8");
     const seBytes = Buffer.from(se, "utf8");
-    if (soBytes.length > maxInput) {
-      so = soBytes.subarray(0, maxInput).toString("utf8");
-      notes.push(`input truncated at ${Math.floor(maxInput / 1024)}KB (TOKEN_GOAT_FILTER_MAX_BYTES)`);
+    const soClamped = clampKeepingEnds(so, maxInput);
+    const seClamped = clampKeepingEnds(se, maxInput);
+    if (soClamped !== null) {
+      so = soClamped;
+      notes.push(`input over ${Math.floor(maxInput / 1024)}KB: kept both ends (TOKEN_GOAT_FILTER_MAX_BYTES)`);
     }
-    if (seBytes.length > maxInput) {
-      se = seBytes.subarray(0, maxInput).toString("utf8");
-      if (!notes.some((n) => n.includes("input truncated"))) {
-        notes.push(`stderr truncated at ${Math.floor(maxInput / 1024)}KB (TOKEN_GOAT_FILTER_MAX_BYTES)`);
+    if (seClamped !== null) {
+      se = seClamped;
+      if (!notes.some((n) => n.includes("kept both ends"))) {
+        notes.push(`stderr over ${Math.floor(maxInput / 1024)}KB: kept both ends (TOKEN_GOAT_FILTER_MAX_BYTES)`);
       }
     }
     const originalBytes = soBytes.length + seBytes.length;
@@ -10706,7 +10830,7 @@ ${stderr.replace(/\s+$/, "")}`;
         notes.push(`input exceeded inspect budget (${Math.floor(MAX_INSPECT_BYTES / 1024)} KiB); fell back to truncation`);
         body = fallbackTruncate(normOut, normErr, maxLines);
       } else {
-        body = this.compress(normOut, normErr, exitCode, argv);
+        body = this.compress(normOut, normErr, exitCode, argv, { inputTruncated: soClamped !== null || seClamped !== null });
       }
     } catch (exc) {
       const kind = exc instanceof Error ? exc.constructor.name : "Error";
@@ -10715,6 +10839,7 @@ ${stderr.replace(/\s+$/, "")}`;
       const fbErr = this.postNormalise(normalise(se, { skipProgress }));
       body = fallbackTruncate(fbOut, fbErr, maxLines);
     }
+    body = capLongLines(body.split("\n"), LONG_LINE_MAX_CHARS).join("\n");
     const lines = body.split("\n");
     if (lines.length > maxLines) body = truncateMiddleSmart(lines, maxLines).join("\n");
     body = capBytes(body, maxBytes);
@@ -15395,7 +15520,7 @@ var GrepFilter = class extends ToolFilter {
     }
     return false;
   }
-  compress(stdout, stderr, _exitCode, argv) {
+  compress(stdout, stderr, _exitCode, argv, ctx = {}) {
     const text = this.combineOutput(stdout, stderr);
     const lines = text.split("\n");
     const nonEmpty = lines.filter((l) => l.trim());
@@ -15422,7 +15547,7 @@ var GrepFilter = class extends ToolFilter {
     }
     const totalMatches = [...fileCounts.values()].reduce((a, b) => a + b, 0) + unattributed;
     const numFiles = fileCounts.size;
-    const outLines = [`grep: ${totalMatches} matches across ${numFiles} file(s)`];
+    const outLines = ctx.inputTruncated ? [`grep: at least ${totalMatches} matches across ${numFiles} file(s) (counted over a truncated input; per-file counts below are lower bounds)`] : [`grep: ${totalMatches} matches across ${numFiles} file(s)`];
     const sorted = [...fileCounts.entries()].sort((a, b) => b[1] - a[1]);
     const shown = sorted.slice(0, _GREP_MAX_FILE_LINES);
     for (const [fname, count] of shown) {
@@ -15505,8 +15630,11 @@ var RgFilter = class _RgFilter extends ToolFilter {
     const kept = groups.filter((_, i) => topIdx.has(i));
     const suppressed = groups.length - kept.length;
     const joined = kept.join("\n" + _RgFilter._SEP + "\n");
+    const lastKept = scored[Math.min(_RG_TOP_GROUPS, scored.length) - 1]?.score;
+    const firstDropped = scored[_RG_TOP_GROUPS]?.score;
+    const tied = firstDropped !== void 0 && firstDropped === lastKept;
     return joined + `
-[token-goat: ${suppressed} more match groups suppressed \u2014 rerun with -l for filenames only]`;
+[token-goat: ${suppressed} more match groups suppressed${tied ? ", tied on match count with the ones kept and separated only by filename order" : ", each with fewer matches than those kept"}: rerun with -l for filenames only]`;
   }
   // Same per-line clip GrepFilter applies: every branch below can return match lines verbatim, so the cap is applied once here rather than at each of the five return sites.
   compress(stdout, stderr, exitCode, argv) {
@@ -16017,6 +16145,12 @@ var RsyncFilter = class extends ToolFilter {
 var _DIFF_FILE_HEADER_RE = /^(?:diff\s|---\s)/;
 var _DIFF_HUNK_RE = /^@@ /;
 var _DIFF_MAX_FULL_FILES = 20;
+var _DIFF_MAX_STAT_EXTRA_LINES = 40;
+function _isDiffBodyLine(line) {
+  if (line === "") return true;
+  const c = line[0] ?? "";
+  return c === " " || c === "+" || c === "-" || c === "@" || c === "\\";
+}
 function _isDiffAdd(line) {
   return line.startsWith("+") && !line.startsWith("+++");
 }
@@ -16126,12 +16260,33 @@ var DiffFilter = class extends ToolFilter {
       const statLines = [
         `[token-goat: large diff (${realFiles.length} files); stat-only view]`
       ];
-      for (const blockStr of realFiles) {
+      let extrasKept = 0;
+      let extrasDropped = 0;
+      const emitExtras = (candidates) => {
+        const foreign = candidates.filter((l) => l.trim() !== "" && !_isDiffBodyLine(l));
+        for (const line of capLongLines(foreign)) {
+          if (extrasKept >= _DIFF_MAX_STAT_EXTRA_LINES) {
+            extrasDropped++;
+            continue;
+          }
+          extrasKept++;
+          statLines.push(line);
+        }
+      };
+      for (const blockStr of rawBlocks) {
         const blockLines = blockStr.split("\n");
-        const header = blockLines[0];
+        const header = blockLines[0] ?? "";
+        if (!_DIFF_FILE_HEADER_RE.test(header)) {
+          emitExtras(blockLines);
+          continue;
+        }
         const adds = blockLines.filter(_isDiffAdd).length;
         const dels = blockLines.filter(_isDiffRemove).length;
         statLines.push(`${header}  +${adds} -${dels}`);
+        emitExtras(blockLines.slice(1));
+      }
+      if (extrasDropped > 0) {
+        statLines.push(`[token-goat: ${extrasDropped} more non-diff line${extrasDropped === 1 ? "" : "s"} omitted]`);
       }
       return statLines.join("\n");
     }
@@ -18148,7 +18303,7 @@ var Sqlite3Filter = class _Sqlite3Filter extends ToolFilter {
   binaries = /* @__PURE__ */ new Set(["sqlite3"]);
   static ROW_THRESHOLD = 20;
   static KEEP_ROWS = 5;
-  compress(stdout, stderr, _exitCode, _argv) {
+  compress(stdout, stderr, _exitCode, _argv, ctx = {}) {
     const merged = this.combineOutput(stdout, stderr);
     const lines = merged.split("\n");
     const nonEmpty = lines.filter((ln) => ln.trim());
@@ -18167,7 +18322,9 @@ var Sqlite3Filter = class _Sqlite3Filter extends ToolFilter {
     const nonEmptyBody = bodyLines.filter((ln) => ln.trim());
     if (nonEmptyBody.length > _Sqlite3Filter.ROW_THRESHOLD) {
       kept.push(...nonEmptyBody.slice(0, _Sqlite3Filter.KEEP_ROWS));
-      kept.push(`[token-goat: ${nonEmptyBody.length} rows (showing first ${_Sqlite3Filter.KEEP_ROWS})]`);
+      kept.push(
+        ctx.inputTruncated === true ? `[token-goat: at least ${nonEmptyBody.length} rows (counted over a truncated input; showing first ${_Sqlite3Filter.KEEP_ROWS})]` : `[token-goat: ${nonEmptyBody.length} rows (showing first ${_Sqlite3Filter.KEEP_ROWS})]`
+      );
     } else {
       kept.push(...bodyLines);
     }
@@ -19509,7 +19666,7 @@ var KubectlFilter = class extends ToolFilter {
     } else if (subcommand === "diff") {
       const diffLines = text.split("\n");
       if (diffLines.length > 50) {
-        text = headTailCompress(diffLines, 50, 0, "diff lines");
+        text = headTailCompress(diffLines, 35, 15, "diff lines");
       }
     }
     if (stderr.trim()) {
@@ -19925,8 +20082,14 @@ function _capPatchLinesInBlock(block, maxLines) {
   const headerLines = lines.slice(0, diffStart);
   let diffLines = lines.slice(diffStart);
   if (diffLines.length > maxLines) {
+    const tailKeep = Math.min(10, Math.floor(maxLines / 3));
+    const headKeep = maxLines - tailKeep;
     const elided = diffLines.length - maxLines;
-    diffLines = [...diffLines.slice(0, maxLines), `--- patch: ${elided} lines omitted by token-goat ---`];
+    diffLines = [
+      ...diffLines.slice(0, headKeep),
+      `--- patch: ${elided} lines omitted by token-goat ---`,
+      ...diffLines.slice(diffLines.length - tailKeep)
+    ];
   }
   return [...headerLines, ...diffLines].join("\n");
 }
@@ -19971,7 +20134,7 @@ function _compressGitLogStat(stdout, stderr) {
   const MAX_STAT_FILES = 20;
   return _compressGitLogCapped(stdout, stderr, (block) => _capStatLinesInBlock(block, MAX_STAT_FILES));
 }
-function _compressGitLogEnhanced(stdout, stderr, argv) {
+function _compressGitLogEnhanced(stdout, stderr, argv, inputTruncated = false) {
   const flags = new Set(argv);
   let isOneline = flags.has("--oneline") || flags.has("--format=oneline") || flags.has("--pretty=oneline") || argv.some((a) => a.startsWith("--format=%h") || a.startsWith("--pretty=%h"));
   if (!isOneline) {
@@ -19995,7 +20158,8 @@ function _compressGitLogEnhanced(stdout, stderr, argv) {
     let keptLines;
     if (blocks.length > ONELINE_CAP) {
       const elided = blocks.length - ONELINE_CAP;
-      keptLines = [...blocks.slice(0, ONELINE_CAP), `[token-goat: +${elided} more commits]`];
+      const elidedNote = inputTruncated ? `[token-goat: at least ${elided} more commits (counted over a truncated input)]` : `[token-goat: +${elided} more commits]`;
+      keptLines = [...blocks.slice(0, ONELINE_CAP), elidedNote];
     } else {
       keptLines = blocks;
     }
@@ -20010,8 +20174,8 @@ function _compressGitLogEnhanced(stdout, stderr, argv) {
 var GitLogFilter = class extends GitBaseFilter {
   name = "git-log";
   subcommands = /* @__PURE__ */ new Set(["log"]);
-  compress(stdout, stderr, _exitCode, argv) {
-    return _compressGitLogEnhanced(stdout, stderr, argv);
+  compress(stdout, stderr, _exitCode, argv, ctx = {}) {
+    return _compressGitLogEnhanced(stdout, stderr, argv, ctx.inputTruncated === true);
   }
 };
 var _GIT_DIFF_BINARY_RE = /^Binary files?(?: .+)? differ$/;
@@ -20252,43 +20416,6 @@ function _compressGitDiffBody(stdout, stderr, maxHunksPerFile = 10) {
   if (stderr.trim()) text += "\n---\n" + stderr.replace(/\s+$/, "");
   return text;
 }
-function _compressGitDiffSimple(stdout, stderr, maxHunksPerFile = 3) {
-  const fileBlocks = splitBlocks(stdout, _GIT_DIFF_FILE_RE);
-  if (!fileBlocks.length) return stdout;
-  const realFiles = fileBlocks.filter((b) => _GIT_DIFF_FILE_RE.test(b));
-  if (realFiles.length > 200) {
-    const statLines = realFiles.map((b) => {
-      const header = b.split("\n", 1)[0] ?? "";
-      const lines = b.split("\n");
-      const adds = lines.filter(_isDiffAdd2).length;
-      const dels = lines.filter(_isDiffRemove2).length;
-      return `${header}  +${adds} -${dels}`;
-    });
-    return `[token-goat: large diff (${realFiles.length} files); showing stat-only view]
-` + statLines.join("\n");
-  }
-  const outBlocks = [];
-  for (const block of fileBlocks) {
-    if (!_GIT_DIFF_FILE_RE.test(block)) {
-      outBlocks.push(block);
-      continue;
-    }
-    const hunks = splitBlocks(block, _GIT_DIFF_HUNK_RE);
-    if (hunks.length <= maxHunksPerFile + 1) {
-      outBlocks.push(block);
-      continue;
-    }
-    const head = hunks.slice(0, maxHunksPerFile + 1);
-    const elided = hunks.slice(maxHunksPerFile + 1);
-    outBlocks.push(
-      head.join("\n") + `
-[token-goat: +${elided.length} more hunks in this file elided]`
-    );
-  }
-  let text = outBlocks.join("\n");
-  if (stderr.trim()) text += "\n---\n" + stderr.replace(/\s+$/, "");
-  return text;
-}
 function _compressGitDiffEnhanced(stdout, stderr, argv) {
   const flags = new Set(argv);
   const isStat = flags.has("--stat") || flags.has("--shortstat") || flags.has("--name-only");
@@ -20805,13 +20932,7 @@ var GitFilter = class extends GitBaseFilter {
     const positionals = gitPositionalArgs(argv.slice(1));
     const subcommand = positionals[0] ?? "";
     if (subcommand === "diff" || subcommand === "show") {
-      let maxHunksPerFile;
-      try {
-        maxHunksPerFile = loadConfig().bash_diff.max_hunks_per_file;
-      } catch {
-        maxHunksPerFile = void 0;
-      }
-      return maxHunksPerFile === void 0 ? _compressGitDiffSimple(stdout, stderr) : _compressGitDiffSimple(stdout, stderr, maxHunksPerFile);
+      return _compressGitDiffEnhanced(stdout, stderr, argv);
     }
     if (subcommand === "ls-files" || subcommand === "ls-tree")
       return _truncateListing(stdout, stderr, 100);