@shrkcrft/compress 0.1.0-alpha.16

package/dist/text/compress-diff.js

@@ -0,0 +1,344 @@
+import { EContentType } from "../content/content-type.js";
+import { ECompressionStrategy } from "../result/compression-strategy.js";
+import { splitLines, queryTokens, queryOverlap, elide } from "./line-utils.js";
+import { finalizeLossy, passthroughResult } from "./finalize.js";
+import { formatCcrMarker } from "../ccr/ccr-marker.js";
+import { isLockfileName } from "./lockfile-names.js";
+// Header tokens that are unambiguous at column 0 (a hunk body line starts with
+// ` `/`+`/`-`, never these). `--- `/`+++ ` are handled separately because they
+// collide with deleted/added content lines.
+const SAFE_HEADER_RE = /^(?:diff --git |index |new file|deleted file|old mode|new mode|similarity |rename |copy )/;
+const HUNK_HEADER_RE = /^@@ /;
+function isChangeLine(line) {
+    if (line.startsWith('+') && !line.startsWith('+++'))
+        return true;
+    if (line.startsWith('-') && !line.startsWith('---'))
+        return true;
+    return false;
+}
+/**
+ * Reduce a unified diff to its highest-signal lines. Two passes compose:
+ *
+ *  1. **Diff-noise offload** (this wrapper): lockfile sections
+ *     (`package-lock.json` & friends) collapse to a one-line marker, and
+ *     whitespace-only hunks (pure reindentation) collapse to a marker — the
+ *     single largest sources of useless diff tokens. Both are CCR-recoverable.
+ *  2. **Core hunk compression** ({@link compressDiffCore}): the remaining real
+ *     changes keep their changed lines plus a tight context window, capped per
+ *     file.
+ *
+ * The offload pass only engages when a `diff --git` section is actually a
+ * lockfile or contains a whitespace-only hunk; every other diff routes straight
+ * to the core compressor, byte-identical to before. Recoverable via CCR; output
+ * favours LLM readability over `git apply` fidelity.
+ */
+export function compressDiff(text, opts = {}) {
+    const lines = splitLines(text);
+    const sections = segmentDiffSections(lines);
+    // Only take the offload path when the diff cleanly segments into `diff --git`
+    // sections AND at least one is noise. Anything else stays on the core path.
+    const hasNoise = sections !== null &&
+        sections.some((s) => s.isLockfile || s.hunks.some((h) => h.whitespaceOnly));
+    if (!sections || !hasNoise)
+        return compressDiffCore(text, opts);
+    const out = [];
+    let lockfileCount = 0;
+    let wsHunkCount = 0;
+    for (const s of sections) {
+        if (s.isLockfile) {
+            lockfileCount += 1;
+            const sectionText = s.lines.join('\n');
+            const elided = s.lines.length - s.headerLines.length;
+            const key = opts.store ? opts.store.put(sectionText) : undefined;
+            const marker = `[lockfile ${s.basename}: ${plural(elided, 'line')} elided${key ? ` ${formatCcrMarker(key)}` : ''}]`;
+            out.push([...s.headerLines, marker].join('\n'));
+            continue;
+        }
+        const wsHunks = s.hunks.filter((h) => h.whitespaceOnly);
+        const normalHunks = s.hunks.filter((h) => !h.whitespaceOnly);
+        if (wsHunks.length === 0) {
+            // No noise in this section — compress it with the core pass (per-section
+            // CCR is handled once over the whole diff by finalizeLossy below).
+            out.push(compressDiffCore(s.lines.join('\n'), { ...opts, store: undefined }).compressed);
+            continue;
+        }
+        wsHunkCount += wsHunks.length;
+        const normalSection = [...s.headerLines, ...normalHunks.flatMap((h) => h.lines)];
+        const compressedNormal = normalHunks.length > 0
+            ? compressDiffCore(normalSection.join('\n'), { ...opts, store: undefined }).compressed
+            : s.headerLines.join('\n');
+        const wsText = wsHunks.flatMap((h) => h.lines).join('\n');
+        const wsLines = wsHunks.reduce((n, h) => n + h.lines.length, 0);
+        const key = opts.store ? opts.store.put(wsText) : undefined;
+        const wsMarker = `[whitespace-only: ${plural(wsHunks.length, 'hunk')}, ${plural(wsLines, 'line')} elided${key ? ` ${formatCcrMarker(key)}` : ''}]`;
+        out.push([compressedNormal, wsMarker].join('\n'));
+    }
+    const note = `full diff: ${plural(lockfileCount, 'lockfile')} + ${plural(wsHunkCount, 'whitespace hunk')} offloaded`;
+    return finalizeLossy({
+        original: text,
+        body: out.join('\n'),
+        contentType: EContentType.GitDiff,
+        strategy: ECompressionStrategy.Diff,
+        opts,
+        note,
+    });
+}
+function plural(n, noun) {
+    return `${n} ${noun}${n === 1 ? '' : 's'}`;
+}
+/**
+ * Split a diff into per-file sections at `diff --git` boundaries. Returns null
+ * when the diff doesn't cleanly start with a `diff --git` section (preamble,
+ * headerless `diff -u`, etc.) so the caller falls back to the core path rather
+ * than risk a fragile segmentation.
+ */
+function segmentDiffSections(lines) {
+    const starts = [];
+    for (let i = 0; i < lines.length; i += 1) {
+        if ((lines[i] ?? '').startsWith('diff --git '))
+            starts.push(i);
+    }
+    if (starts.length === 0 || starts[0] !== 0)
+        return null;
+    const sections = [];
+    for (let k = 0; k < starts.length; k += 1) {
+        const begin = starts[k];
+        const end = k + 1 < starts.length ? starts[k + 1] : lines.length;
+        const sectionLines = lines.slice(begin, end);
+        sections.push(buildSection(sectionLines));
+    }
+    return sections;
+}
+function buildSection(sectionLines) {
+    let firstHunk = sectionLines.findIndex((l) => HUNK_HEADER_RE.test(l));
+    if (firstHunk < 0)
+        firstHunk = sectionLines.length;
+    const headerLines = sectionLines.slice(0, firstHunk);
+    const hunks = [];
+    let cur = null;
+    for (let i = firstHunk; i < sectionLines.length; i += 1) {
+        const line = sectionLines[i] ?? '';
+        if (HUNK_HEADER_RE.test(line)) {
+            if (cur)
+                hunks.push({ lines: cur, whitespaceOnly: isWhitespaceOnlyHunk(cur) });
+            cur = [line];
+        }
+        else if (cur) {
+            cur.push(line);
+        }
+    }
+    if (cur)
+        hunks.push({ lines: cur, whitespaceOnly: isWhitespaceOnlyHunk(cur) });
+    const basename = sectionPath(headerLines);
+    return {
+        lines: sectionLines,
+        headerLines,
+        hunks,
+        basename,
+        isLockfile: basename.length > 0 && isLockfileName(basename),
+    };
+}
+/** The changed file's basename, parsed from `+++ b/<path>` or the git header. */
+function sectionPath(headerLines) {
+    let path = '';
+    for (const line of headerLines) {
+        const plus = /^\+\+\+ b\/(.*)$/.exec(line);
+        if (plus) {
+            path = plus[1] ?? '';
+            break;
+        }
+    }
+    if (!path) {
+        const git = /^diff --git a\/.+ b\/(.+)$/.exec(headerLines[0] ?? '');
+        if (git)
+            path = git[1] ?? '';
+    }
+    // `+++ b/path` is clean inside a `diff --git` section, but guard a stray tab.
+    path = (path.split('\t')[0] ?? '').trim();
+    return path.split('/').pop() ?? '';
+}
+/**
+ * True when a hunk's only real change is whitespace: the normalized contents of
+ * its removed lines and added lines are identical multisets (so each `-x` is
+ * answered by a `+x` differing only in leading/trailing/internal whitespace).
+ * Pure-context hunks (no changes) are NOT whitespace-only — they're left for the
+ * core pass.
+ */
+function isWhitespaceOnlyHunk(hunkLines) {
+    const norm = (s) => s.replace(/\s+/g, ' ').trim();
+    const removed = [];
+    const added = [];
+    for (const line of hunkLines) {
+        if (line.startsWith('-') && !line.startsWith('---'))
+            removed.push(norm(line.slice(1)));
+        else if (line.startsWith('+') && !line.startsWith('+++'))
+            added.push(norm(line.slice(1)));
+    }
+    if (removed.length === 0 || removed.length !== added.length)
+        return false;
+    const a = [...removed].sort();
+    const b = [...added].sort();
+    return a.every((v, i) => v === b[i]);
+}
+/**
+ * Reduce a unified diff to the changed lines plus a tight context window,
+ * capping hunks per file (first + last + highest-scoring kept). File headers
+ * are preserved so the diff stays attributable; trimmed context and dropped
+ * hunks are elided. Recoverable via CCR. Output favours LLM readability over
+ * `git apply` fidelity.
+ */
+function compressDiffCore(text, opts = {}) {
+    const lines = splitLines(text);
+    const minLines = opts.minLines ?? 12;
+    if (lines.length < minLines)
+        return passthroughResult(text, EContentType.GitDiff);
+    const tokens = queryTokens(opts.query);
+    const maxContext = 3;
+    const maxHunks = opts.maxItems ?? 12;
+    const fileHeaderLines = new Map();
+    const hunks = [];
+    let currentFile = -1;
+    let current = null;
+    let sawGitHeader = false; // a `diff --git` just opened the current file
+    let expectPlusHeader = false; // a `--- ` file header was just seen; its `+++ ` partner is next
+    const registerHeader = (i) => {
+        if (currentFile < 0) {
+            currentFile = 0;
+            if (!fileHeaderLines.has(0))
+                fileHeaderLines.set(0, []);
+        }
+        const list = fileHeaderLines.get(currentFile) ?? [];
+        list.push(i);
+        fileHeaderLines.set(currentFile, list);
+        current = null; // header lines sit between hunks
+    };
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i] ?? '';
+        if (line.startsWith('diff --git ')) {
+            currentFile += 1;
+            fileHeaderLines.set(currentFile, [i]);
+            current = null;
+            sawGitHeader = true;
+            expectPlusHeader = false;
+            continue;
+        }
+        if (HUNK_HEADER_RE.test(line)) {
+            if (currentFile < 0) {
+                currentFile = 0;
+                if (!fileHeaderLines.has(0))
+                    fileHeaderLines.set(0, []);
+            }
+            current = { file: currentFile, header: i, body: [], changeCount: 0, score: 0 };
+            hunks.push(current);
+            sawGitHeader = false;
+            expectPlusHeader = false;
+            continue;
+        }
+        // A `--- ` line is a file header only when its `+++ ` partner follows AND a
+        // hunk header comes next — a real header is immediately followed by `@@`.
+        // This rejects an in-hunk deleted/added content pair (`--- foo` / `+++ bar`)
+        // that would otherwise be mistaken for a new file. It begins a NEW file
+        // unless a `diff --git` already opened this one (headerless `diff -u`).
+        if (line.startsWith('--- ') &&
+            (lines[i + 1] ?? '').startsWith('+++ ') &&
+            (lines[i + 2] ?? '').startsWith('@@')) {
+            if (!sawGitHeader) {
+                currentFile += 1;
+                fileHeaderLines.set(currentFile, []);
+            }
+            registerHeader(i);
+            sawGitHeader = false;
+            expectPlusHeader = true;
+            continue;
+        }
+        if (expectPlusHeader && line.startsWith('+++ ')) {
+            registerHeader(i);
+            expectPlusHeader = false;
+            continue;
+        }
+        if (SAFE_HEADER_RE.test(line)) {
+            registerHeader(i);
+            continue;
+        }
+        if (current) {
+            current.body.push(i);
+            if (isChangeLine(line)) {
+                current.changeCount += 1;
+                current.score += queryOverlap(line, tokens) * 0.3;
+            }
+        }
+    }
+    if (hunks.length === 0)
+        return passthroughResult(text, EContentType.GitDiff);
+    // Per-file hunk cap: always keep first + last, fill remainder by score.
+    const keptHunks = new Set();
+    const byFile = new Map();
+    for (const h of hunks) {
+        const list = byFile.get(h.file) ?? [];
+        list.push(h);
+        byFile.set(h.file, list);
+    }
+    for (const list of byFile.values()) {
+        if (list.length <= maxHunks) {
+            for (const h of list)
+                keptHunks.add(h);
+            continue;
+        }
+        // Select per file so the cap is honoured exactly: the first hunk, the last
+        // (only if the cap allows two), then the highest-scoring until full. A
+        // per-file set is the source of truth — a global counter has cross-file
+        // slack and lets one file overflow by one.
+        const fileKept = new Set();
+        fileKept.add(list[0]);
+        if (maxHunks >= 2)
+            fileKept.add(list[list.length - 1]);
+        const ranked = [...list].sort((a, b) => (b.score - a.score) || (b.changeCount - a.changeCount) || (a.header - b.header));
+        for (const h of ranked) {
+            if (fileKept.size >= maxHunks)
+                break;
+            fileKept.add(h);
+        }
+        for (const h of fileKept)
+            keptHunks.add(h);
+    }
+    const keep = new Set();
+    const filesWithKeptHunk = new Set();
+    for (const h of keptHunks)
+        filesWithKeptHunk.add(h.file);
+    for (const [file, headerLines] of fileHeaderLines) {
+        if (filesWithKeptHunk.has(file))
+            for (const i of headerLines)
+                keep.add(i);
+    }
+    for (const h of keptHunks) {
+        keep.add(h.header);
+        // Mark change-line positions, then keep context within ±maxContext.
+        const changePos = new Set();
+        for (let p = 0; p < h.body.length; p += 1) {
+            const li = h.body[p];
+            if (isChangeLine(lines[li] ?? ''))
+                changePos.add(p);
+        }
+        for (let p = 0; p < h.body.length; p += 1) {
+            const li = h.body[p];
+            let near = changePos.has(p);
+            if (!near) {
+                for (let d = 1; d <= maxContext && !near; d += 1) {
+                    if (changePos.has(p - d) || changePos.has(p + d))
+                        near = true;
+                }
+            }
+            if (near)
+                keep.add(li);
+        }
+    }
+    const body = elide(lines, keep);
+    return finalizeLossy({
+        original: text,
+        body,
+        contentType: EContentType.GitDiff,
+        strategy: ECompressionStrategy.Diff,
+        opts,
+        note: `full diff: ${hunks.length} hunks across ${byFile.size} files`,
+    });
+}

package/dist/text/compress-lines.d.ts

@@ -0,0 +1,12 @@
+import { EContentType } from '../content/content-type.js';
+import type { ICompressionResult } from '../result/compression-result.js';
+import type { ICompressOptions } from '../result/compress-options.js';
+/**
+ * Conservative generic reduction for prose / plain text: drop exact-duplicate
+ * non-blank lines (keeping the first occurrence) and collapse runs of blank
+ * lines. Prose with little repetition passes through unchanged — which is the
+ * honest outcome; structured content should route to a typed compressor
+ * instead. Recoverable via CCR.
+ */
+export declare function compressLines(text: string, contentType?: EContentType, opts?: ICompressOptions): ICompressionResult;
+//# sourceMappingURL=compress-lines.d.ts.map

package/dist/text/compress-lines.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compress-lines.d.ts","sourceRoot":"","sources":["../../src/text/compress-lines.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAC1E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAItE;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,WAAW,GAAE,YAAqC,EAClD,IAAI,GAAE,gBAAqB,GAC1B,kBAAkB,CA+BpB"}

package/dist/text/compress-lines.js

@@ -0,0 +1,44 @@
+import { EContentType } from "../content/content-type.js";
+import { ECompressionStrategy } from "../result/compression-strategy.js";
+import { splitLines, elide } from "./line-utils.js";
+import { finalizeLossy, passthroughResult } from "./finalize.js";
+/**
+ * Conservative generic reduction for prose / plain text: drop exact-duplicate
+ * non-blank lines (keeping the first occurrence) and collapse runs of blank
+ * lines. Prose with little repetition passes through unchanged — which is the
+ * honest outcome; structured content should route to a typed compressor
+ * instead. Recoverable via CCR.
+ */
+export function compressLines(text, contentType = EContentType.PlainText, opts = {}) {
+    const lines = splitLines(text);
+    const minLines = opts.minLines ?? 8;
+    if (lines.length < minLines)
+        return passthroughResult(text, contentType);
+    const keep = new Set();
+    const seen = new Set();
+    let prevBlank = false;
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i] ?? '';
+        const blank = line.trim().length === 0;
+        if (blank) {
+            if (!prevBlank)
+                keep.add(i);
+            prevBlank = true;
+            continue;
+        }
+        prevBlank = false;
+        if (seen.has(line))
+            continue; // exact duplicate — drop
+        seen.add(line);
+        keep.add(i);
+    }
+    const body = elide(lines, keep);
+    return finalizeLossy({
+        original: text,
+        body,
+        contentType,
+        strategy: ECompressionStrategy.Lines,
+        opts,
+        note: `full text: ${lines.length} lines`,
+    });
+}

package/dist/text/compress-log.d.ts

@@ -0,0 +1,12 @@
+import type { ICompressionResult } from '../result/compression-result.js';
+import type { ICompressOptions } from '../result/compress-options.js';
+/**
+ * Reduce build / test / runtime logs to their signal: errors and their FULL
+ * multi-frame stack traces, the exception punchline, de-duplicated warnings,
+ * summary lines, and first/last anchors. The rest is elided. When a hard
+ * `maxItems` cap applies, lines are dropped by PRIORITY (summaries > errors >
+ * anchors > other), never by position — so the closing summary always survives.
+ * Deterministic and order-preserving; the full log is recoverable via CCR.
+ */
+export declare function compressLog(text: string, opts?: ICompressOptions): ICompressionResult;
+//# sourceMappingURL=compress-log.d.ts.map

package/dist/text/compress-log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compress-log.d.ts","sourceRoot":"","sources":["../../src/text/compress-log.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAC1E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AA0BtE;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,gBAAqB,GAAG,kBAAkB,CAsIzF"}

package/dist/text/compress-log.js

@@ -0,0 +1,202 @@
+import { EContentType } from "../content/content-type.js";
+import { ECompressionStrategy } from "../result/compression-strategy.js";
+import { splitLines, dedupeKey, queryTokens } from "./line-utils.js";
+import { finalizeLossy, passthroughResult } from "./finalize.js";
+import { mineLogTemplates } from "./log-template.js";
+import { bm25Scores } from "../relevance/bm25.js";
+import { formatCcrMarker } from "../ccr/ccr-marker.js";
+const ERROR_RE = /\b(?:ERROR|FATAL|FAIL(?:ED|URE)?|EXCEPTION|panic)\b/i;
+// High-signal failure lines that often carry NONE of the ERROR/FATAL/FAIL
+// keywords yet ARE the root cause: native crashes (segfault, core dump, bus
+// error), the OOM killer, linker errors, fatal POSIX signals, and assertion
+// failures. Without this they get elided when they aren't an anchor. Treated
+// exactly like an error line (kept, with the preceding line and any following
+// trace). Keeping an occasional benign match costs one extra line — far cheaper
+// than dropping the actual cause.
+const FATAL_SIGNAL_RE = /\b(?:segmentation fault|segfault|core dumped|bus error|out of memory|oom[- ]?kill(?:er|ed)?|killed process|undefined reference to|undefined symbol|symbol\(s\) not found|cannot find -l|assertion (?:failed|.*failed)|SIG(?:SEGV|ABRT|KILL|BUS|FPE|ILL)\b|signal \d+|Aborted)\b/i;
+const WARN_RE = /\bWARN(?:ING)?\b/i;
+const SUMMARY_RE = /\b(?:\d+ (?:passed|failed|error|errors|skipped)|Tests:|Test Suites:|collected \d+|BUILD (?:SUCCESS|FAIL(?:ED|URE)?)|Summary:)\b|^[✓✗×]/;
+const STACK_RE = /^\s+(?:at\s+\S+|File ".*", line \d+)/;
+// Start of a multi-frame trace region.
+const TRACEBACK_START = /^\s*Traceback\b|^\s*Caused by:|^\s*Exception in thread\b/;
+// The punchline of a trace: `ValueError: boom`, `java.lang.NullPointerException: null`.
+const EXCEPTION_SUMMARY = /^[\w.$]*(?:Error|Exception|Warning|Panic)\b.*:/;
+/**
+ * Reduce build / test / runtime logs to their signal: errors and their FULL
+ * multi-frame stack traces, the exception punchline, de-duplicated warnings,
+ * summary lines, and first/last anchors. The rest is elided. When a hard
+ * `maxItems` cap applies, lines are dropped by PRIORITY (summaries > errors >
+ * anchors > other), never by position — so the closing summary always survives.
+ * Deterministic and order-preserving; the full log is recoverable via CCR.
+ */
+export function compressLog(text, opts = {}) {
+    const lines = splitLines(text);
+    const minLines = opts.minLines ?? 12;
+    if (lines.length < minLines)
+        return passthroughResult(text, EContentType.BuildLog);
+    const tokens = queryTokens(opts.query);
+    // P3.2: BM25 relevance for the query (idf-weighted, length-normalized, ID-term
+    // boosted). Computed only when a query is present, so the no-query path is
+    // unchanged.
+    const relScores = opts.query ? bm25Scores(opts.query, lines) : null;
+    const keep = new Set();
+    const errorIdx = new Set();
+    const summaryIdx = new Set();
+    const anchorIdx = new Set();
+    const queryIdx = new Set();
+    const seenWarn = new Set();
+    let stackActive = false;
+    let inFrameSource = false; // we are inside a frame's indented source block
+    for (const i of [0, 1, lines.length - 2, lines.length - 1]) {
+        if (i >= 0 && i < lines.length) {
+            keep.add(i);
+            anchorIdx.add(i);
+        }
+    }
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i] ?? '';
+        const isSummary = SUMMARY_RE.test(line);
+        // Errors / trace starts are handled FIRST so trace control flow is correct,
+        // but a line that is ALSO a summary (e.g. "Tests: 1 failed" — "failed"
+        // matches ERROR_RE) is still tagged into summaryIdx so the cap ranks it as
+        // a summary. This keeps multi-frame traces intact while letting the closing
+        // result survive a tight cap.
+        if (ERROR_RE.test(line) ||
+            FATAL_SIGNAL_RE.test(line) ||
+            TRACEBACK_START.test(line) ||
+            EXCEPTION_SUMMARY.test(line)) {
+            keep.add(i);
+            errorIdx.add(i);
+            if (isSummary)
+                summaryIdx.add(i);
+            if (i - 1 >= 0)
+                keep.add(i - 1);
+            stackActive = true;
+            inFrameSource = false;
+            continue;
+        }
+        if (stackActive) {
+            if (line.trim().length === 0) {
+                stackActive = false; // a blank line ends the trace region
+                inFrameSource = false;
+            }
+            else if (STACK_RE.test(line)) {
+                keep.add(i); // a real stack frame (`at …` / `File …`)
+                errorIdx.add(i);
+                inFrameSource = true;
+                continue;
+            }
+            else if (inFrameSource && /^\s/.test(line)) {
+                keep.add(i); // indented source line(s) under a frame — keep the whole block
+                errorIdx.add(i);
+                continue;
+            }
+            else if (/^\s/.test(line)) {
+                // Indented, but NOT after a frame (e.g. a captured-stdout / locals dump
+                // straight after the error) — drop it, but stay in the trace region.
+                continue;
+            }
+            else {
+                stackActive = false; // a dedented non-trace line ends the region — re-check it below
+                inFrameSource = false;
+            }
+        }
+        if (isSummary) {
+            keep.add(i);
+            summaryIdx.add(i);
+            continue;
+        }
+        if (WARN_RE.test(line)) {
+            const k = dedupeKey(line);
+            if (!seenWarn.has(k)) {
+                seenWarn.add(k);
+                keep.add(i);
+            }
+            continue;
+        }
+        if (relScores && relScores[i] > 0) {
+            keep.add(i);
+            queryIdx.add(i);
+        }
+    }
+    // Hard cap: force-keep the CLOSING summary (the last summary line) so the
+    // test/build result always survives, then fill the rest errors-first, then
+    // other summaries, then anchors, then the remainder. This keeps both the real
+    // error and the closing result even when summary-shaped noise is abundant.
+    if (opts.maxItems && keep.size > opts.maxItems) {
+        const cap = opts.maxItems;
+        const chosen = new Set();
+        const summaries = [...summaryIdx].sort((a, b) => a - b);
+        if (summaries.length > 0)
+            chosen.add(summaries[summaries.length - 1]);
+        const rank = (i) => errorIdx.has(i) ? 0 : summaryIdx.has(i) ? 1 : queryIdx.has(i) ? 2 : anchorIdx.has(i) ? 3 : 4;
+        // Within a tier, the more query-relevant line (higher BM25) wins; rel is 0
+        // for non-query lines, so this is a no-op tiebreak without a query.
+        const rel = (i) => (relScores ? relScores[i] : 0);
+        const rest = [...keep]
+            .filter((i) => !chosen.has(i))
+            .sort((a, b) => rank(a) - rank(b) || rel(b) - rel(a) || a - b);
+        for (const i of rest) {
+            if (chosen.size >= cap)
+                break;
+            chosen.add(i);
+        }
+        keep.clear();
+        for (const i of chosen)
+            keep.add(i);
+    }
+    // P2.2: collapse repetitive runs of KEPT lines (summary/query spam) into
+    // lossless template blocks. Mining only the *kept* runs is the key: lines the
+    // selector drops stay dropped (a one-line `… omitted …` always beats keeping
+    // a template block), so noise logs never regress — only signal the agent
+    // actually sees gets the lossless columnar collapse.
+    //
+    // P4.5: when a CCR store is present, cache the original up front and stamp its
+    // key into each elision hint, so the agent can tell a root cause was dropped
+    // RIGHT THERE and retrieve it. finalizeLossy reuses this same key (and skips
+    // its own trailing marker since the body already carries it).
+    const ccrKey = opts.store ? opts.store.put(text) : undefined;
+    const body = elideWithTemplates(lines, keep, ccrKey);
+    return finalizeLossy({
+        original: text,
+        body,
+        contentType: EContentType.BuildLog,
+        strategy: ECompressionStrategy.Log,
+        opts,
+        note: `full log: ${lines.length} lines`,
+    });
+}
+/**
+ * Like {@link elide}, but each maximal run of consecutive KEPT lines is passed
+ * through {@link mineLogTemplates} so repetitive kept lines collapse to a
+ * lossless template block. Each dropped run becomes a single hint; when
+ * `ccrKey` is given the hint carries `→ <<ccr:KEY>>` so the elided detail is
+ * retrievable in place (P4.5).
+ */
+function elideWithTemplates(lines, keep, ccrKey) {
+    const out = [];
+    let dropped = 0;
+    const flush = () => {
+        if (dropped > 0) {
+            const hint = ccrKey ? ` → ${formatCcrMarker(ccrKey)}` : '';
+            out.push(`… ${dropped} line${dropped === 1 ? '' : 's'} omitted${hint}`);
+            dropped = 0;
+        }
+    };
+    let i = 0;
+    while (i < lines.length) {
+        if (!keep.has(i)) {
+            dropped += 1;
+            i += 1;
+            continue;
+        }
+        flush();
+        let j = i;
+        while (j < lines.length && keep.has(j))
+            j += 1;
+        out.push(...mineLogTemplates(lines.slice(i, j)).lines);
+        i = j;
+    }
+    flush();
+    return out.join('\n');
+}

package/dist/text/compress-markdown.d.ts

@@ -0,0 +1,15 @@
+import type { ICompressionResult } from '../result/compression-result.js';
+import type { ICompressOptions } from '../result/compress-options.js';
+/**
+ * Markdown-aware reduction that keeps a document's SKELETON — every header, the
+ * first line of each section/paragraph, table rows, and a capped run of list
+ * items — while thinning paragraph continuations and collapsing fenced code
+ * block bodies. Structure is never dropped (headers always survive), so the
+ * outline stays navigable; the full document is recoverable via CCR.
+ *
+ * Note: this runs only when an agent explicitly compresses markdown (via
+ * `shrk compress` / `compress_context`). SharkCraft's own briefs/context are
+ * never silently passed through it.
+ */
+export declare function compressMarkdown(text: string, opts?: ICompressOptions): ICompressionResult;
+//# sourceMappingURL=compress-markdown.d.ts.map

package/dist/text/compress-markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compress-markdown.d.ts","sourceRoot":"","sources":["../../src/text/compress-markdown.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAC1E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAStE;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,gBAAqB,GAAG,kBAAkB,CA8E9F"}