harnesstrim 0.2.1 → 0.3.0

package/dist/chunks/chunk-XLAPDMOY.mjs

@@ -0,0 +1,1004 @@
+// ../core/src/reducers/tap-output-slim.ts
+var MARKER = "[harnesstrim:tap-output-slim]";
+var SIGNAL = /\b(fail(ed|ure)?|error|warn(ing)?|exception|traceback|assertionerror)\b/i;
+var tapOutputSlim = {
+  name: "tap-output-slim",
+  reduce(input) {
+    if (input.includes(MARKER) || !/^TAP version 13\r?$/m.test(input)) {
+      return { output: input, changed: false };
+    }
+    const eol = input.includes("\r\n") ? "\r\n" : "\n";
+    const lines = input.split(eol);
+    const out = [];
+    let omitted = 0;
+    let pending = [];
+    let count = 0;
+    const flush = () => {
+      if (count >= 2) {
+        out.push(`${MARKER} omitted ${count} passing subtests (duration/type only)`);
+        omitted += count;
+      } else out.push(...pending);
+      pending = [];
+      count = 0;
+    };
+    let diagnosticTail = false;
+    for (let i = 0; i < lines.length; ) {
+      if (/^not ok\b|^Bail out!/i.test(lines[i])) diagnosticTail = true;
+      const header = /^# Subtest: (.+)$/.exec(lines[i]);
+      const success = /^ok \d+ - (.+)$/.exec(lines[i + 1] ?? "");
+      let end = i + 2;
+      let known = !diagnosticTail && !!header && !!success && header[1] === success[1] && !SIGNAL.test(header[1]) && !/#\s*(?:SKIP|TODO)/i.test(success[1]);
+      if (known && lines[end] === "  ---") {
+        end++;
+        const start = end;
+        while (/^  (?:duration_ms: [0-9]+(?:\.[0-9]+)?|type: ['"]?test['"]?)$/.test(lines[end] ?? "")) end++;
+        known = end > start && lines[end] === "  ...";
+        if (known) end++;
+      }
+      known = known && (end === lines.length || /^(?:# Subtest: |1\.\.|# (?:tests|suites|pass|fail|cancelled|skipped|todo|duration_ms)\b)/.test(lines[end] ?? ""));
+      if (known) {
+        pending.push(...lines.slice(i, end));
+        count++;
+        i = end;
+      } else {
+        flush();
+        out.push(lines[i]);
+        i++;
+      }
+    }
+    flush();
+    const output = out.join(eol);
+    return omitted > 0 && output.length < input.length ? { output, changed: true, note: `omitted ${omitted} passing subtests` } : { output: input, changed: false };
+  }
+};
+
+// ../core/src/reducers/test-output-slim.ts
+var MARKER2 = "[harnesstrim:test-output-slim]";
+var SIGNAL2 = /\b(fail(ed|ure)?|error|warn(ing)?|exception|traceback|assert(ion)?(error)?|expected|received)\b/i;
+var PASS = /^(?:PASS\s+|\s*[\u2713\u2714]\s+|\S+::\S+\s+PASSED(?:\s|$))/;
+var ANSI = /\x1b\[[0-?]*[ -/]*[@-~]/g;
+var testOutputSlim = {
+  name: "test-output-slim",
+  reduce(input) {
+    if (input.includes(MARKER2)) return { output: input, changed: false };
+    const eol = input.includes("\r\n") ? "\r\n" : "\n";
+    const lines = input.split(eol);
+    const out = [];
+    let run = [];
+    let dropped = 0;
+    let diagnosticTail = false;
+    const flush = () => {
+      if (run.length >= 2) {
+        out.push(`${MARKER2} omitted ${run.length} passing/noise line(s)`);
+        dropped += run.length;
+      } else out.push(...run);
+      run = [];
+    };
+    for (const line of lines) {
+      const clean = line.replace(ANSI, "");
+      if (SIGNAL2.test(clean) || /^\s*[A-Za-z]*Error:|^\s*[\u2715\u2717\u00d7\u25cf]\s/.test(clean)) diagnosticTail = true;
+      if (!diagnosticTail && PASS.test(clean)) run.push(line);
+      else {
+        flush();
+        out.push(line);
+      }
+    }
+    flush();
+    const output = out.join(eol);
+    return dropped > 0 && output.length < input.length ? { output, changed: true, note: `dropped ${dropped} confirmed passing-test lines` } : { output: input, changed: false };
+  }
+};
+
+// ../core/src/reducers/git-diff-slim.ts
+var MARKER_PREFIX = "[harnesstrim:git-diff-slim]";
+var GENERATED_PATH_RE = /(^|\/)(package-lock\.json|pnpm-lock\.yaml|yarn\.lock|Cargo\.lock|go\.sum)$|\.min\.(js|css)$|\.map$|(^|\/)(dist|build)\//i;
+var DIFF_HEADER_RE = /^diff --git a\/(.+) b\/(.+)$/;
+var HUNK_HEADER_RE = /^@@ .*@@/;
+function isBlockHeaderLine(line) {
+  return DIFF_HEADER_RE.test(line) || line.startsWith("index ") || line.startsWith("--- ") || line.startsWith("+++ ") || line.startsWith("new file mode") || line.startsWith("deleted file mode") || line.startsWith("similarity index") || line.startsWith("rename from") || line.startsWith("rename to");
+}
+var gitDiffSlim = {
+  name: "git-diff-slim",
+  reduce(input) {
+    const lines = input.split(/\r?\n/);
+    const out = [];
+    let droppedTotal = 0;
+    let i = 0;
+    while (i < lines.length) {
+      const headerMatch = DIFF_HEADER_RE.exec(lines[i]);
+      if (!headerMatch) {
+        out.push(lines[i]);
+        i++;
+        continue;
+      }
+      const filePath = headerMatch[2];
+      const blockStart = i;
+      let j = i + 1;
+      while (j < lines.length && !DIFF_HEADER_RE.test(lines[j])) j++;
+      const blockEnd = j;
+      if (!GENERATED_PATH_RE.test(filePath)) {
+        for (let k = blockStart; k < blockEnd; k++) out.push(lines[k]);
+        i = blockEnd;
+        continue;
+      }
+      out.push(lines[blockStart]);
+      let added = 0;
+      let removed = 0;
+      let hunkLineCount = 0;
+      let inHunk = false;
+      for (let k = blockStart + 1; k < blockEnd; k++) {
+        const line = lines[k];
+        if (isBlockHeaderLine(line)) {
+          out.push(line);
+          continue;
+        }
+        if (HUNK_HEADER_RE.test(line)) {
+          inHunk = true;
+          hunkLineCount++;
+          continue;
+        }
+        if (inHunk) {
+          hunkLineCount++;
+          if (line.startsWith("+") && !line.startsWith("+++")) added++;
+          else if (line.startsWith("-") && !line.startsWith("---")) removed++;
+          continue;
+        }
+        out.push(line);
+      }
+      if (hunkLineCount > 0) {
+        out.push(`${MARKER_PREFIX} ${filePath}: +${added} -${removed} (generated/lockfile, hunk omitted)`);
+        droppedTotal += hunkLineCount;
+      }
+      i = blockEnd;
+    }
+    const output = out.join("\n");
+    return {
+      output,
+      changed: droppedTotal > 0,
+      note: droppedTotal > 0 ? `collapsed ${droppedTotal} generated-file diff line(s)` : void 0
+    };
+  }
+};
+
+// ../core/src/reducers/generic-text-slim.ts
+var MARKER_PREFIX2 = "[harnesstrim:generic-text-slim]";
+var HEADER_RE = /^#{1,6}\s/m;
+var EMOJI_BULLET_RE = /^[\s]*[✅❌⚠️🔍📡🔧🚀🎯💡📝🔄⚡🎨🔒📊📍🏗️🧹⬆️⬇️🔀⏪📋📂🔐📖👀🛠️🔥♻️🧪🏁]/;
+var BULLET_RE = /^\s*[-*+]\s/;
+var NUMBERED_RE = /^\s*\d+[\.\)]\s/;
+var BOLD_RE = /\*\*.+\*\*/;
+var TABLE_RE = /^\s*\|.+\|\s*$/;
+var HR_RE = /^---+$/;
+var CODE_FENCE_RE = /^```/;
+var KEY_VALUE_RE = /^\s*\*{0,2}\w[\w\s]+\*{0,2}:/;
+var CONTEXT_AFTER = 2;
+var MIN_COLLAPSE_RUN = 3;
+function isSignalLine(line) {
+  return line.startsWith(MARKER_PREFIX2) || HEADER_RE.test(line) || EMOJI_BULLET_RE.test(line) || BULLET_RE.test(line) || NUMBERED_RE.test(line) || BOLD_RE.test(line) || KEY_VALUE_RE.test(line) || TABLE_RE.test(line) || HR_RE.test(line) || CODE_FENCE_RE.test(line);
+}
+var genericTextSlim = {
+  name: "generic-text-slim",
+  reduce(input) {
+    const lines = input.split(/\r?\n/);
+    const n = lines.length;
+    const keep = new Array(n).fill(false);
+    for (let i2 = 0; i2 < Math.min(CONTEXT_AFTER, n); i2++) {
+      keep[i2] = true;
+    }
+    for (let i2 = Math.max(0, n - CONTEXT_AFTER); i2 < n; i2++) {
+      keep[i2] = true;
+    }
+    let insideCodeFence = false;
+    for (let i2 = 0; i2 < n; i2++) {
+      if (CODE_FENCE_RE.test(lines[i2])) {
+        keep[i2] = true;
+        insideCodeFence = !insideCodeFence;
+        continue;
+      }
+      if (insideCodeFence) {
+        keep[i2] = true;
+        continue;
+      }
+      if (isSignalLine(lines[i2])) {
+        keep[i2] = true;
+        for (let j = i2 + 1; j <= Math.min(i2 + CONTEXT_AFTER, n - 1); j++) {
+          keep[j] = true;
+        }
+      }
+    }
+    const out = [];
+    let i = 0;
+    let droppedTotal = 0;
+    while (i < n) {
+      if (keep[i]) {
+        out.push(lines[i]);
+        i++;
+        continue;
+      }
+      let runEnd = i;
+      while (runEnd < n && !keep[runEnd]) runEnd++;
+      const runLength = runEnd - i;
+      if (runLength >= MIN_COLLAPSE_RUN) {
+        out.push(`${MARKER_PREFIX2} omitted ${runLength} line(s) of prose/narrative`);
+        droppedTotal += runLength;
+      } else {
+        for (let j = i; j < runEnd; j++) out.push(lines[j]);
+      }
+      i = runEnd;
+    }
+    const output = out.join("\n");
+    return {
+      output,
+      changed: droppedTotal > 0,
+      note: droppedTotal > 0 ? `dropped ${droppedTotal} prose/narrative line(s)` : void 0
+    };
+  }
+};
+
+// ../core/src/reducers/json-output-slim.ts
+var MARKER_PREFIX3 = "[harnesstrim:json-output-slim]";
+var LEADING_ITEMS = 3;
+var TRAILING_ITEMS = 3;
+var MIN_ARRAY_LENGTH = 20;
+var MAX_OBJECT_KEYS = 15;
+var jsonOutputSlim = {
+  name: "json-output-slim",
+  reduce(input) {
+    let parsed;
+    try {
+      parsed = JSON.parse(input);
+    } catch {
+      return tryExtractJsonBlocks(input);
+    }
+    if (Array.isArray(parsed)) {
+      return reduceArray(parsed, input);
+    }
+    if (typeof parsed === "object" && parsed !== null) {
+      return reduceObject(parsed, input);
+    }
+    return { output: input, changed: false };
+  }
+};
+function reduceArray(arr, originalInput) {
+  if (arr.length < MIN_ARRAY_LENGTH) {
+    return { output: originalInput, changed: false };
+  }
+  const n = arr.length;
+  const keptCount = LEADING_ITEMS + TRAILING_ITEMS;
+  if (n <= keptCount) {
+    return { output: originalInput, changed: false };
+  }
+  const leading = arr.slice(0, LEADING_ITEMS);
+  const trailing = arr.slice(n - TRAILING_ITEMS);
+  const out = [
+    `${MARKER_PREFIX3} array with ${n} total items, showing ${LEADING_ITEMS} first + ${TRAILING_ITEMS} last`
+  ];
+  for (const item of leading) {
+    out.push(jsonPreview(item));
+  }
+  out.push(`${MARKER_PREFIX3} ... omitted ${n - keptCount} items ...`);
+  for (const item of trailing) {
+    out.push(jsonPreview(item));
+  }
+  return {
+    output: out.join("\n"),
+    changed: true,
+    note: `collapsed JSON array from ${n} to ${keptCount} visible items`
+  };
+}
+function reduceObject(obj, originalInput) {
+  const keys = Object.keys(obj);
+  let hasLongArray = false;
+  for (const key of keys) {
+    if (Array.isArray(obj[key]) && obj[key].length >= MIN_ARRAY_LENGTH) {
+      hasLongArray = true;
+    }
+  }
+  if (keys.length < MAX_OBJECT_KEYS && !hasLongArray) {
+    return { output: originalInput, changed: false };
+  }
+  const keyCount = keys.length;
+  const out = [];
+  if (keyCount >= MAX_OBJECT_KEYS) {
+    out.push(
+      `${MARKER_PREFIX3} object with ${keyCount} keys, first ${MAX_OBJECT_KEYS} shown`
+    );
+  }
+  const shownKeys = keys.slice(0, Math.min(keyCount, MAX_OBJECT_KEYS));
+  let changed = false;
+  for (const key of shownKeys) {
+    const val = obj[key];
+    if (Array.isArray(val) && val.length >= MIN_ARRAY_LENGTH) {
+      const arrResult = reduceArray(val, JSON.stringify(val));
+      if (arrResult.changed) {
+        changed = true;
+        out.push(`  "${key}": [reduced: ${val.length} items]`);
+        continue;
+      }
+    }
+    out.push(`  "${key}": ${jsonPreview(val, true)}`);
+  }
+  if (keyCount >= MAX_OBJECT_KEYS) {
+    const omitted = keyCount - MAX_OBJECT_KEYS;
+    out.push(`  ${MARKER_PREFIX3} ... omitted ${omitted} keys ...`);
+    changed = true;
+  }
+  if (!changed) {
+    return { output: originalInput, changed: false };
+  }
+  return {
+    output: out.join("\n"),
+    changed: true,
+    note: hasLongArray ? `collapsed nested array(s) inside object` : `collapsed JSON object from ${keyCount} to ${MAX_OBJECT_KEYS} keys`
+  };
+}
+function jsonPreview(value, inline = false) {
+  if (value === null) return "null";
+  if (typeof value === "string") {
+    const short = value.length > 80 ? value.slice(0, 77) + "..." : value;
+    return JSON.stringify(short);
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "[]";
+    if (inline) return `[${value.length} items]`;
+    if (value.length <= 5) {
+      return value.map((v) => jsonPreview(v, true)).join("\n");
+    }
+    return `[${value.length} items]`;
+  }
+  if (typeof value === "object") {
+    const keys = Object.keys(value);
+    if (keys.length === 0) return "{}";
+    if (inline) return `{${keys.length} keys}`;
+    if (keys.length <= 5) {
+      return JSON.stringify(value).slice(0, 200) + "...";
+    }
+    return `{${keys.length} keys}`;
+  }
+  return String(value);
+}
+function tryExtractJsonBlocks(input) {
+  let cursor = 0;
+  let output = "";
+  let changed = false;
+  while (cursor < input.length) {
+    const match = input.slice(cursor).match(/^[\t ]*[\[{]/m);
+    if (!match || match.index === void 0) {
+      output += input.slice(cursor);
+      break;
+    }
+    const start = cursor + match.index + match[0].search(/[\[{]/);
+    const end = findJsonBlockEnd(input, start);
+    if (end === -1) {
+      output += input.slice(cursor);
+      break;
+    }
+    output += input.slice(cursor, start);
+    const jsonBlock = input.slice(start, end);
+    let parsed;
+    try {
+      parsed = JSON.parse(jsonBlock);
+    } catch {
+      output += input.slice(start, start + 1);
+      cursor = start + 1;
+      continue;
+    }
+    const result = Array.isArray(parsed) ? reduceArray(parsed, jsonBlock) : typeof parsed === "object" && parsed !== null ? reduceObject(parsed, jsonBlock) : { output: jsonBlock, changed: false };
+    output += result.output;
+    changed ||= result.changed;
+    cursor = end;
+  }
+  return changed ? { output, changed: true, note: "reduced embedded JSON block(s)" } : { output: input, changed: false };
+}
+function findJsonBlockEnd(input, start) {
+  const stack = [];
+  let inString = false;
+  let escape = false;
+  for (let i = start; i < input.length; i++) {
+    const ch = input[i];
+    if (escape) {
+      escape = false;
+      continue;
+    }
+    if (ch === "\\") {
+      escape = true;
+      continue;
+    }
+    if (ch === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString) continue;
+    if (ch === "{" || ch === "[") stack.push(ch);
+    if (ch === "}" || ch === "]") {
+      stack.pop();
+      if (stack.length === 0) return i + 1;
+    }
+  }
+  return -1;
+}
+
+// ../core/src/reducers/file-listing-slim.ts
+var MARKER_PREFIX4 = "[harnesstrim:file-listing-slim]";
+var HEADER_KEEP = 5;
+var FOOTER_KEEP = 3;
+var MIN_LINES = 20;
+var FILE_LIKE_THRESHOLD = 0.5;
+var LEADING_ENTRIES = 4;
+var TRAILING_ENTRIES = 3;
+var MIN_FILE_RUN = 10;
+function isFileEntry(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return false;
+  if (/^[\-bcdlsp][\-r][\-w][\-xs\-][\-r][\-w][\-xs\-][\-r][\-w][\-xs\-]/.test(trimmed)) return true;
+  if (/^\.\/(?:\.|[^.\s])/.test(trimmed)) return true;
+  if (/^\s*(?:├──|└──|│\s+)/.test(trimmed)) return true;
+  if (/^[\w.\/\-]+\.[a-zA-Z]{1,4}:\d+\|/.test(trimmed)) return true;
+  if (/^total\s+\d+$/.test(trimmed)) return true;
+  return false;
+}
+var fileListingSlim = {
+  name: "file-listing-slim",
+  reduce(input) {
+    const lines = input.split(/\r?\n/);
+    const n = lines.length;
+    if (n < MIN_LINES) return { output: input, changed: false };
+    let nonBlank = 0;
+    let fileLike = 0;
+    for (const line of lines) {
+      if (line.trim()) {
+        nonBlank++;
+        if (isFileEntry(line)) fileLike++;
+      }
+    }
+    if (nonBlank === 0 || fileLike / nonBlank < FILE_LIKE_THRESHOLD) {
+      return { output: input, changed: false };
+    }
+    const keep = new Array(n).fill(false);
+    for (let i2 = 0; i2 < Math.min(HEADER_KEEP, n); i2++) keep[i2] = true;
+    for (let i2 = Math.max(0, n - FOOTER_KEEP); i2 < n; i2++) keep[i2] = true;
+    let i = 0;
+    while (i < n) {
+      if (!isFileEntry(lines[i])) {
+        i++;
+        continue;
+      }
+      const runStart = i;
+      while (i < n && isFileEntry(lines[i])) i++;
+      const runEnd = i;
+      const runLength = runEnd - runStart;
+      if (runLength >= MIN_FILE_RUN) {
+        for (let j = runStart; j < runStart + Math.min(LEADING_ENTRIES, runLength); j++) {
+          keep[j] = true;
+        }
+        for (let j = Math.max(runStart + LEADING_ENTRIES, runEnd - TRAILING_ENTRIES); j < runEnd; j++) {
+          keep[j] = true;
+        }
+      } else {
+        for (let j = runStart; j < runEnd; j++) keep[j] = true;
+      }
+    }
+    const out = [];
+    let pos = 0;
+    let droppedTotal = 0;
+    while (pos < n) {
+      if (keep[pos]) {
+        out.push(lines[pos]);
+        pos++;
+        continue;
+      }
+      const dropStart = pos;
+      while (pos < n && !keep[pos]) pos++;
+      const dropLength = pos - dropStart;
+      if (dropLength >= 3) {
+        out.push(`${MARKER_PREFIX4} omitted ${dropLength} line(s)`);
+        droppedTotal += dropLength;
+      } else {
+        for (let j = dropStart; j < pos; j++) {
+          out.push(lines[j]);
+        }
+      }
+    }
+    const changed = droppedTotal > 0;
+    if (!changed) return { output: input, changed: false };
+    return {
+      output: out.join("\n"),
+      changed: true,
+      note: `collapsed ${droppedTotal} lines of file listing`
+    };
+  }
+};
+
+// ../core/src/reducers/cron-output-slim.ts
+var MARKER_PREFIX5 = "[harnesstrim:cron-output-slim]";
+var CRON_HEADER_RE = /^# Cron Job:/m;
+var PROMPT_RE = /^## Prompt\s*$/m;
+var RESPONSE_RE = /^## Response\s*$/m;
+var cronOutputSlim = {
+  name: "cron-output-slim",
+  reduce(input) {
+    if (input.includes(MARKER_PREFIX5) || !CRON_HEADER_RE.test(input)) {
+      return { output: input, changed: false };
+    }
+    const prompt = PROMPT_RE.exec(input);
+    const response = RESPONSE_RE.exec(input);
+    if (!prompt || !response || response.index <= prompt.index) {
+      return { output: input, changed: false };
+    }
+    const promptEnd = input.indexOf("\n", prompt.index) + 1;
+    const omitted = input.slice(promptEnd, response.index);
+    const omittedLines = omitted.split(/\r?\n/).filter(Boolean).length;
+    if (omittedLines === 0) return { output: input, changed: false };
+    const output = `${input.slice(0, promptEnd)}${MARKER_PREFIX5} omitted ${omittedLines} archived prompt/skill line(s)
+
+${input.slice(response.index)}`;
+    return {
+      output,
+      changed: true,
+      note: `omitted ${omittedLines} archived prompt/skill line(s)`
+    };
+  }
+};
+
+// ../core/src/reducers/lint-output-slim.ts
+var MARKER_PREFIX6 = "[harnesstrim:lint-output-slim]";
+var LINT_LINE_RE = /^[\w.\/\\-]+:\d+:\d+\s+(warning|error)\s+([\w@.\/-]+)/;
+var MAX_RULES_IN_MARKER = 8;
+function isLintLine(line) {
+  return LINT_LINE_RE.test(line);
+}
+var lintOutputSlim = {
+  name: "lint-output-slim",
+  reduce(input) {
+    const lines = input.split(/\r?\n/);
+    const out = [];
+    let droppedTotal = 0;
+    let i = 0;
+    while (i < lines.length) {
+      const line = lines[i];
+      if (!isLintLine(line)) {
+        out.push(line);
+        i++;
+        continue;
+      }
+      const counts = [];
+      const byKey = /* @__PURE__ */ new Map();
+      let runEnd = i;
+      while (runEnd < lines.length && isLintLine(lines[runEnd])) {
+        const m = LINT_LINE_RE.exec(lines[runEnd]);
+        const severity = m[1] === "error" ? "error" : "warning";
+        const rule = m[2];
+        const key = `${severity}:${rule}`;
+        const existing = byKey.get(key);
+        if (existing) {
+          existing.count++;
+        } else {
+          const entry = { severity, rule, count: 1 };
+          byKey.set(key, entry);
+          counts.push(entry);
+        }
+        runEnd++;
+      }
+      const runLength = runEnd - i;
+      if (runLength >= 2) {
+        const parts = counts.slice(0, MAX_RULES_IN_MARKER).map(
+          (c) => `${c.rule} \xD7${c.count}`
+        );
+        const truncated = counts.length > MAX_RULES_IN_MARKER;
+        const suffix = truncated ? `, +${counts.length - MAX_RULES_IN_MARKER} more rule(s)` : "";
+        const severities = counts.some((c) => c.severity === "error") && counts.some((c) => c.severity === "warning") ? "error(s) and warning(s)" : counts.some((c) => c.severity === "error") ? "error(s)" : "warning(s)";
+        out.push(`${MARKER_PREFIX6} omitted ${runLength} lint line(s) (${severities}: ${parts.join(", ")}${suffix})`);
+        droppedTotal += runLength;
+      } else {
+        for (let j = i; j < runEnd; j++) out.push(lines[j]);
+      }
+      i = runEnd;
+    }
+    const output = out.join("\n");
+    return {
+      output,
+      changed: droppedTotal > 0,
+      note: droppedTotal > 0 ? `dropped ${droppedTotal} lint noise line(s)` : void 0
+    };
+  }
+};
+
+// ../core/src/reducers/ci-log-slim.ts
+var MARKER_PREFIX7 = "[harnesstrim:ci-log-slim]";
+var MIN_NOISE_RUN = 3;
+var SIGNAL_RE = /\b(?:error|warning|warn|fail(?:ed|ure)?|fatal|exception|traceback)\b|exit code/i;
+var CI_NOISE_PATTERNS = [
+  /##\[debug\]/,
+  /^Syncing repository:/,
+  /^Getting Git version info$/,
+  /^Temporarily overriding HOME=/,
+  /^Adding repository directory to the temporary git global config as a safe directory$/,
+  /^Disabling automatic garbage collection$/,
+  /^Setting up auth$/,
+  /^Persisting credentials$/,
+  /^Fetching the repository$/,
+  /^Determining the checkout info$/,
+  /^Checking out the ref$/,
+  /^Post job cleanup\.$/,
+  /^Cleaning up orphan processes$/,
+  /^git version \d/i,
+  /^\/usr\/bin\/git config --global --add safe\.directory /,
+  /^\/usr\/bin\/git config --local --name-only --get-regexp /
+];
+function stripGhRunPrefix(line) {
+  const parts = line.split("	");
+  return parts.length >= 4 ? parts.slice(3).join("	") : line;
+}
+function isNoiseLine(line) {
+  if (line.startsWith(MARKER_PREFIX7)) return false;
+  const payload = stripGhRunPrefix(line).trim();
+  if (!payload || SIGNAL_RE.test(payload)) return false;
+  return CI_NOISE_PATTERNS.some((pattern) => pattern.test(payload));
+}
+var ciLogSlim = {
+  name: "ci-log-slim",
+  reduce(input) {
+    const lines = input.split(/\r?\n/);
+    const out = [];
+    let dropped = 0;
+    let index = 0;
+    while (index < lines.length) {
+      if (!isNoiseLine(lines[index])) {
+        out.push(lines[index]);
+        index += 1;
+        continue;
+      }
+      let end = index;
+      while (end < lines.length && isNoiseLine(lines[end])) end += 1;
+      const runLength = end - index;
+      if (runLength >= MIN_NOISE_RUN) {
+        out.push(`${MARKER_PREFIX7} omitted ${runLength} CI setup/debug line(s)`);
+        dropped += runLength;
+      } else {
+        for (let cursor = index; cursor < end; cursor += 1) out.push(lines[cursor]);
+      }
+      index = end;
+    }
+    return {
+      output: out.join("\n"),
+      changed: dropped > 0,
+      note: dropped > 0 ? `dropped ${dropped} CI setup/debug line(s)` : void 0
+    };
+  }
+};
+
+// ../core/src/reducers/package-manager-output-slim.ts
+var MARKER_PREFIX8 = "[harnesstrim:package-manager-output-slim]";
+var PNPM_PROGRESS_RE = /^Progress:\s+resolved\s+\d+,\s+reused\s+\d+,\s+downloaded\s+\d+,\s+added\s+\d+(?:,\s+done)?\s*$/;
+var DECORATION_RE = /^[+\-]{20,}\s*$/;
+function isProgress(line) {
+  return PNPM_PROGRESS_RE.test(line);
+}
+function isDecoration(line) {
+  return DECORATION_RE.test(line);
+}
+var packageManagerOutputSlim = {
+  name: "package-manager-output-slim",
+  reduce(input) {
+    if (input.includes(MARKER_PREFIX8)) {
+      return { output: input, changed: false };
+    }
+    const lines = input.split(/\r?\n/);
+    const progressIndexes = lines.map((line, index) => isProgress(line) ? index : -1).filter((index) => index >= 0);
+    if (progressIndexes.length < 3) {
+      return { output: input, changed: false };
+    }
+    const finalProgressIndex = progressIndexes[progressIndexes.length - 1];
+    const out = [];
+    let omittedProgress = 0;
+    let omittedDecoration = 0;
+    let markerWritten = false;
+    for (let index = 0; index < lines.length; index += 1) {
+      const line = lines[index];
+      if (isProgress(line) && index !== finalProgressIndex) {
+        omittedProgress += 1;
+        if (!markerWritten) {
+          out.push(MARKER_PREFIX8);
+          markerWritten = true;
+        }
+        continue;
+      }
+      if (isDecoration(line)) {
+        omittedDecoration += 1;
+        if (!markerWritten) {
+          out.push(MARKER_PREFIX8);
+          markerWritten = true;
+        }
+        continue;
+      }
+      out.push(line);
+    }
+    if (!markerWritten) return { output: input, changed: false };
+    const markerIndex = out.indexOf(MARKER_PREFIX8);
+    out[markerIndex] = `${MARKER_PREFIX8} omitted ${omittedProgress} intermediate progress snapshot(s)` + (omittedDecoration > 0 ? ` and ${omittedDecoration} decorative line(s)` : "");
+    return {
+      output: out.join("\n"),
+      changed: true,
+      note: `dropped ${omittedProgress} pnpm progress snapshot(s)` + (omittedDecoration > 0 ? ` and ${omittedDecoration} decorative line(s)` : "")
+    };
+  }
+};
+
+// ../core/src/dispatch.ts
+var DEFAULT_MIN_LENGTH = 400;
+var GIT_DIFF_RE = /^diff --git /m;
+var TEST_OUTPUT_RE = /\b\d+\s+(passed|failed)\b|^(PASS|FAIL)\s|::\w.*\b(PASSED|FAILED)\b|=+\s*(FAILURES|short test summary)/im;
+var JSON_RE = /^\s*[\[{]/m;
+var FILE_LISTING_RE = /(?:^total\s+\d+|^[\-bcdlsp][\-r][\-w][\-xs\-][\-r][\-w][\-xs\-][\-r][\-w][\-xs\-]|^\.\/(?:\.|[^.\s])|^\s*(?:├──|└──|│\s+)|^[\w.\/\-]+\.[a-zA-Z]{1,4}:\d+\|)/m;
+var CRON_OUTPUT_RE = /^# Cron Job:.*\n[\s\S]*^## Prompt\s*$[\s\S]*^## Response\s*$/m;
+var CI_LOG_RE = /##\[(?:debug|group|endgroup)\]|(?:^|\t)(?:Syncing repository:|Post job cleanup\.)/m;
+var LINT_OUTPUT_RE = /^[\w.\/\\-]+:\d+:\d+\s+(?:warning|error)\s+[\w@.\/-]+\s/m;
+var PACKAGE_MANAGER_OUTPUT_RE = /^Progress:\s+resolved\s+\d+,\s+reused\s+\d+,\s+downloaded\s+\d+,\s+added\s+\d+(?:,\s+done)?\s*$/m;
+var LONG_TEXT_RE = /^#{1,4}\s.*\n(?:(?!^#{1,4}\s|^diff --git |^```).*\n){5,}/m;
+function pickReducer(text) {
+  if (GIT_DIFF_RE.test(text)) return gitDiffSlim;
+  if (CI_LOG_RE.test(text) && text.length >= 400) return ciLogSlim;
+  if (/^TAP version 13\r?$/m.test(text)) return tapOutputSlim;
+  if (TEST_OUTPUT_RE.test(text)) return testOutputSlim;
+  if (CRON_OUTPUT_RE.test(text) && text.length >= 400) return cronOutputSlim;
+  if (LINT_OUTPUT_RE.test(text) && text.length >= 400) return lintOutputSlim;
+  if (PACKAGE_MANAGER_OUTPUT_RE.test(text) && text.length >= 400) return packageManagerOutputSlim;
+  if (JSON_RE.test(text) && text.length >= 400) return jsonOutputSlim;
+  if (FILE_LISTING_RE.test(text) && text.length >= 400) return fileListingSlim;
+  if (LONG_TEXT_RE.test(text) && text.length >= 1e3) return genericTextSlim;
+  return null;
+}
+function runReducerSafely(reducer, text) {
+  try {
+    const result = reducer.reduce(text);
+    if (!result.changed || result.output.length >= text.length) {
+      return { output: text, changed: false, reducer: null };
+    }
+    return { ...result, reducer: reducer.name };
+  } catch (error) {
+    return {
+      output: text,
+      changed: false,
+      reducer: null,
+      reductionError: {
+        reducer: reducer.name,
+        message: error instanceof Error ? error.message : String(error)
+      }
+    };
+  }
+}
+function reduceAuto(text, minLength = DEFAULT_MIN_LENGTH) {
+  if (text.length < minLength) {
+    return { output: text, changed: false, reducer: null };
+  }
+  const reducer = pickReducer(text);
+  if (!reducer) {
+    return { output: text, changed: false, reducer: null };
+  }
+  return runReducerSafely(reducer, text);
+}
+
+// ../core/src/metrics/trim-event.ts
+import { randomUUID } from "node:crypto";
+var TRIM_EVENT_SCHEMA_VERSION = 1;
+function makeTrimEvent(partial) {
+  return {
+    schemaVersion: TRIM_EVENT_SCHEMA_VERSION,
+    eventId: randomUUID(),
+    ts: partial.ts ?? (/* @__PURE__ */ new Date()).toISOString(),
+    harness: partial.harness,
+    tool: partial.tool,
+    reducer: partial.reducer,
+    beforeChars: partial.beforeChars,
+    afterChars: partial.afterChars,
+    changed: partial.changed ?? true,
+    reductionFailed: partial.reductionFailed ?? false,
+    beforeTokens: partial.beforeTokens ?? null,
+    afterTokens: partial.afterTokens ?? null
+  };
+}
+function pct(before, after) {
+  if (before === 0) return 0;
+  return Math.round((1 - after / before) * 1e3) / 10;
+}
+function summarize(events) {
+  let beforeChars = 0;
+  let afterChars = 0;
+  let reduced = 0;
+  let passThrough = 0;
+  let reducerFailures = 0;
+  let reductionErrors = 0;
+  let grewChars = 0;
+  const byReducerMap = /* @__PURE__ */ new Map();
+  const byHarnessMap = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    beforeChars += e.beforeChars;
+    afterChars += e.afterChars;
+    if (e.reductionFailed) {
+      reducerFailures++;
+    } else if (e.changed === false) {
+      passThrough++;
+    } else if (e.afterChars > e.beforeChars) {
+      reductionErrors++;
+      grewChars += e.afterChars - e.beforeChars;
+    } else {
+      reduced++;
+    }
+    const harness = e.harness ?? "unknown";
+    const h = byHarnessMap.get(harness) ?? {
+      harness,
+      count: 0,
+      failures: 0,
+      beforeChars: 0,
+      afterChars: 0,
+      savedChars: 0,
+      reductionPct: 0
+    };
+    h.count += 1;
+    if (e.reductionFailed) h.failures += 1;
+    h.beforeChars += e.beforeChars;
+    h.afterChars += e.afterChars;
+    h.savedChars += e.beforeChars - e.afterChars;
+    byHarnessMap.set(harness, h);
+    if (e.reducer === null) continue;
+    const b = byReducerMap.get(e.reducer) ?? {
+      reducer: e.reducer,
+      count: 0,
+      failures: 0,
+      beforeChars: 0,
+      afterChars: 0,
+      savedChars: 0
+    };
+    b.count += 1;
+    if (e.reductionFailed) b.failures += 1;
+    b.beforeChars += e.beforeChars;
+    b.afterChars += e.afterChars;
+    b.savedChars += e.beforeChars - e.afterChars;
+    byReducerMap.set(e.reducer, b);
+  }
+  const byReducer = [...byReducerMap.values()].sort((a, b) => b.savedChars - a.savedChars);
+  const byHarness = [...byHarnessMap.values()].map((h) => ({ ...h, reductionPct: pct(h.beforeChars, h.afterChars) })).sort((a, b) => b.savedChars - a.savedChars);
+  return {
+    events: events.length,
+    beforeChars,
+    afterChars,
+    savedChars: beforeChars - afterChars,
+    reductionPct: pct(beforeChars, afterChars),
+    byReducer,
+    byHarness,
+    reduced,
+    passThrough,
+    passThroughRate: events.length === 0 ? 0 : Math.round(passThrough / events.length * 1e3) / 10,
+    reducerFailures,
+    reductionErrors,
+    grewChars
+  };
+}
+function parseTrimEvents(jsonl) {
+  const out = [];
+  for (const line of jsonl.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (isTrimEvent(parsed)) out.push(normalize(parsed));
+  }
+  return out;
+}
+function isTrimEvent(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  return typeof v.beforeChars === "number" && typeof v.afterChars === "number" && typeof v.tool === "string" && (typeof v.reducer === "string" || v.reducer === null);
+}
+function normalize(v) {
+  return {
+    schemaVersion: typeof v.schemaVersion === "number" ? v.schemaVersion : 0,
+    eventId: typeof v.eventId === "string" ? v.eventId : "",
+    ts: v.ts,
+    harness: v.harness,
+    tool: v.tool,
+    reducer: v.reducer,
+    beforeChars: v.beforeChars,
+    afterChars: v.afterChars,
+    changed: typeof v.changed === "boolean" ? v.changed : true,
+    reductionFailed: typeof v.reductionFailed === "boolean" ? v.reductionFailed : false,
+    beforeTokens: typeof v.beforeTokens === "number" ? v.beforeTokens : null,
+    afterTokens: typeof v.afterTokens === "number" ? v.afterTokens : null
+  };
+}
+
+// ../core/src/presets/index.ts
+var PRESETS = {
+  "lean-debug": {
+    name: "lean-debug",
+    description: "Debugging with noisy logs: aggressively slim tool output, keep effort low.",
+    adapter: { mode: "active", minLength: 300, compactionHandoff: true },
+    skills: ["debug-log-slim", "delta-response"],
+    reasoningEffort: "low",
+    notes: "Mechanical debug/grep loops rarely need high reasoning; the win is cutting log noise."
+  },
+  "lean-review": {
+    name: "lean-review",
+    description: "Code review focused on problems, not restating the diff.",
+    adapter: { mode: "active", minLength: 400, compactionHandoff: true },
+    skills: ["review-delta", "delta-response"],
+    reasoningEffort: "medium",
+    notes: "Review benefits from some reasoning; output discipline avoids diff-narration bloat."
+  },
+  "lean-scaffold": {
+    name: "lean-scaffold",
+    description: "Boilerplate and mechanical transforms: minimal reasoning, terse output.",
+    adapter: { mode: "active", minLength: 400, compactionHandoff: true },
+    skills: ["scaffold-fast", "delegate-bulk", "delta-response"],
+    reasoningEffort: "minimal",
+    notes: "Settled-shape work; spend budget on code, and delegate bulk volume to isolated contexts."
+  },
+  "deep-architecture": {
+    name: "deep-architecture",
+    description: "Architecture / complex debugging: preserve more context, allow high reasoning.",
+    adapter: { mode: "active", minLength: 800, compactionHandoff: true },
+    skills: ["delta-response", "compact-handoff"],
+    reasoningEffort: "high",
+    notes: "Higher minLength keeps more tool context intact; handoff matters across compaction."
+  }
+};
+function getPreset(name) {
+  return PRESETS[name];
+}
+function listPresets() {
+  return Object.values(PRESETS);
+}
+
+// ../core/src/hook-output.ts
+function extractBashOutput(rawJson, allowLegacyOutput = false) {
+  let parsed;
+  try {
+    parsed = JSON.parse(rawJson);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  const p = parsed;
+  if (p.tool_name !== "Bash") return null;
+  if (p.hook_event_name !== void 0 && p.hook_event_name !== "PostToolUse") return null;
+  const value = Object.hasOwn(p, "tool_response") ? p.tool_response : allowLegacyOutput ? p.tool_output : void 0;
+  if (typeof value === "string") {
+    return { toolName: p.tool_name, text: value, before: value, replace: (text) => text };
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const output = value;
+  if (output.isImage === true || Array.isArray(output.content)) return null;
+  for (const key of ["stdout", "output", "content"]) {
+    if (typeof output[key] !== "string") continue;
+    return {
+      toolName: p.tool_name,
+      text: output[key],
+      before: JSON.stringify(output),
+      // stderr, exit codes, interruption/truncation flags and unknown metadata survive.
+      replace: (text) => ({ ...output, [key]: text })
+    };
+  }
+  return null;
+}
+function serializeToolOutput(value) {
+  return typeof value === "string" ? value : JSON.stringify(value);
+}
+
+export {
+  DEFAULT_MIN_LENGTH,
+  reduceAuto,
+  makeTrimEvent,
+  summarize,
+  parseTrimEvents,
+  getPreset,
+  listPresets,
+  extractBashOutput,
+  serializeToolOutput
+};