@unerr-ai/unerr 0.1.6 → 0.1.7

package/dist/__tests__/shadow-ledger.test.js

@@ -1,203 +0,0 @@
-/**
- * P10-TEST-04: Shadow Ledger tests — append-only JSONL intent journal.
- */
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync, } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { ShadowLedger } from "../tracking/shadow-ledger.js";
-let tempDir;
-let unerrDir;
-beforeEach(() => {
-    tempDir = join(tmpdir(), `unerr-ledger-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    unerrDir = join(tempDir, ".unerr");
-    mkdirSync(unerrDir, { recursive: true });
-});
-afterEach(() => {
-    try {
-        rmSync(tempDir, { recursive: true, force: true });
-    }
-    catch {
-        /* ignore */
-    }
-});
-describe("ShadowLedger", () => {
-    it("creates ledger directory and file on first record", () => {
-        const ledger = new ShadowLedger(unerrDir);
-        ledger.record("get_function", { key: "abc" }, { found: true }, "main", "deadbeef");
-        const filePath = join(unerrDir, "ledger", "shadow.jsonl");
-        expect(existsSync(filePath)).toBe(true);
-        const content = readFileSync(filePath, "utf-8").trim();
-        const entry = JSON.parse(content);
-        expect(entry.tool).toBe("get_function");
-        expect(entry.branch).toBe("main");
-        expect(entry.head_sha).toBe("deadbeef");
-        expect(entry.args_summary).toEqual({ key: "abc" });
-        expect(entry.result_summary).toEqual({ found: true });
-    });
-    it("generates unique 12-char hex IDs", () => {
-        const ledger = new ShadowLedger(unerrDir);
-        const e1 = ledger.record("get_function", {}, {}, "main", "aaa");
-        const e2 = ledger.record("get_class", {}, {}, "main", "aaa");
-        expect(e1.id).toHaveLength(12);
-        expect(e2.id).toHaveLength(12);
-        expect(e1.id).not.toBe(e2.id);
-        expect(/^[0-9a-f]{12}$/.test(e1.id)).toBe(true);
-    });
-    it("assigns session ID consistent across records", () => {
-        const ledger = new ShadowLedger(unerrDir);
-        const e1 = ledger.record("get_function", {}, {}, "main", "aaa");
-        const e2 = ledger.record("get_class", {}, {}, "main", "aaa");
-        expect(e1.session_id).toBe(e2.session_id);
-        expect(e1.session_id).toBe(ledger.getSessionId());
-    });
-    it("appends entries as JSONL (one JSON per line)", () => {
-        const ledger = new ShadowLedger(unerrDir);
-        ledger.record("get_function", { key: "a" }, { found: true }, "main", "aaa");
-        ledger.record("get_class", { key: "b" }, { found: false }, "main", "bbb");
-        ledger.record("search_code", { query: "foo" }, { count: 5 }, "main", "ccc");
-        const filePath = join(unerrDir, "ledger", "shadow.jsonl");
-        const lines = readFileSync(filePath, "utf-8").trim().split("\n");
-        expect(lines).toHaveLength(3);
-        const entries = lines.map((l) => JSON.parse(l));
-        expect(entries[0]?.tool).toBe("get_function");
-        expect(entries[1]?.tool).toBe("get_class");
-        expect(entries[2]?.tool).toBe("search_code");
-    });
-    it("correlates entries within 30s window", () => {
-        const ledger = new ShadowLedger(unerrDir);
-        const root = ledger.record("get_function", {}, {}, "main", "aaa");
-        const child = ledger.record("get_callers", {}, {}, "main", "aaa");
-        // Root has null correlation_id
-        expect(root.correlation_id).toBeNull();
-        // Child correlates to root
-        expect(child.correlation_id).toBe(root.id);
-    });
-    it("sync_local_diff always correlates to current root", () => {
-        const ledger = new ShadowLedger(unerrDir);
-        const root = ledger.record("get_function", {}, {}, "main", "aaa");
-        const sync = ledger.record("sync_local_diff", { diff: "..." }, {}, "main", "aaa");
-        expect(sync.correlation_id).toBe(root.id);
-    });
-    it("maintains in-memory buffer of recent entries", () => {
-        const ledger = new ShadowLedger(unerrDir);
-        for (let i = 0; i < 5; i++) {
-            ledger.record(`tool_${i}`, {}, {}, "main", "aaa");
-        }
-        const recent = ledger.getRecentEntries(3);
-        expect(recent).toHaveLength(3);
-        expect(recent[0]?.tool).toBe("tool_2");
-        expect(recent[2]?.tool).toBe("tool_4");
-    });
-    it("truncates arg values longer than 200 chars", () => {
-        const ledger = new ShadowLedger(unerrDir);
-        const longValue = "x".repeat(500);
-        const entry = ledger.record("get_function", { content: longValue }, {}, "main", "aaa");
-        const truncated = entry.args_summary.content;
-        expect(truncated.length).toBeLessThanOrEqual(203); // 200 + "..."
-        expect(truncated.endsWith("...")).toBe(true);
-    });
-    it("recovers from corrupted JSONL on startup", () => {
-        // Write a file with one valid line and one corrupt line
-        const ledgerDir = join(unerrDir, "ledger");
-        mkdirSync(ledgerDir, { recursive: true });
-        const filePath = join(ledgerDir, "shadow.jsonl");
-        const validEntry = JSON.stringify({
-            id: "aabbccddeeff",
-            ts: new Date().toISOString(),
-            tool: "get_function",
-            args_summary: {},
-            result_summary: {},
-            branch: "main",
-            head_sha: "abc",
-            session_id: "112233445566",
-            correlation_id: null,
-        });
-        writeFileSync(filePath, `${validEntry}\n{broken json\n`, "utf-8");
-        // Loading should recover — keep valid line, drop corrupt
-        const ledger = new ShadowLedger(unerrDir);
-        const content = readFileSync(filePath, "utf-8").trim();
-        const lines = content.split("\n").filter((l) => l.trim().length > 0);
-        expect(lines).toHaveLength(1);
-        // Should still be able to record new entries
-        const entry = ledger.record("get_class", {}, {}, "main", "def");
-        expect(entry.tool).toBe("get_class");
-    });
-    it("loads recent entries from file into buffer on startup", () => {
-        // Create a ledger with entries
-        const ledger1 = new ShadowLedger(unerrDir);
-        ledger1.record("get_function", {}, {}, "main", "aaa");
-        ledger1.record("get_class", {}, {}, "main", "bbb");
-        // Create a new ledger instance — should load entries from file
-        const ledger2 = new ShadowLedger(unerrDir);
-        const recent = ledger2.getRecentEntries(10);
-        expect(recent.length).toBeGreaterThanOrEqual(2);
-        expect(recent.some((e) => e.tool === "get_function")).toBe(true);
-        expect(recent.some((e) => e.tool === "get_class")).toBe(true);
-    });
-    it("getStats returns correct counts", () => {
-        const ledger = new ShadowLedger(unerrDir);
-        ledger.record("get_function", {}, {}, "main", "aaa");
-        ledger.record("get_class", {}, {}, "main", "bbb");
-        const stats = ledger.getStats();
-        expect(stats.totalEntries).toBe(2);
-        expect(stats.bufferSize).toBe(2);
-        expect(stats.sessionId).toBe(ledger.getSessionId());
-        expect(stats.lastEntryAt).toBeTruthy();
-    });
-    it("readAllEntries reads full file", () => {
-        const ledger = new ShadowLedger(unerrDir);
-        ledger.record("get_function", {}, {}, "main", "aaa");
-        ledger.record("get_class", {}, {}, "main", "bbb");
-        const all = ledger.readAllEntries();
-        expect(all).toHaveLength(2);
-        expect(all[0]?.tool).toBe("get_function");
-        expect(all[1]?.tool).toBe("get_class");
-    });
-    it("getSessionEntryCount counts current session only", () => {
-        const ledger = new ShadowLedger(unerrDir);
-        ledger.record("get_function", {}, {}, "main", "aaa");
-        ledger.record("get_class", {}, {}, "main", "bbb");
-        expect(ledger.getSessionEntryCount()).toBe(2);
-    });
-    it("handles empty file gracefully", () => {
-        const ledgerDir = join(unerrDir, "ledger");
-        mkdirSync(ledgerDir, { recursive: true });
-        writeFileSync(join(ledgerDir, "shadow.jsonl"), "", "utf-8");
-        const ledger = new ShadowLedger(unerrDir);
-        expect(ledger.getRecentEntries()).toHaveLength(0);
-        expect(ledger.getStats().totalEntries).toBe(0);
-    });
-});
-describe("ShadowLedger.getLastSyncTimestamp", () => {
-    it("returns 0 when no sync_local_diff recorded", () => {
-        const ledger = new ShadowLedger(unerrDir);
-        expect(ledger.getLastSyncTimestamp()).toBe(0);
-    });
-    it("returns 0 when only non-sync tools recorded", () => {
-        const ledger = new ShadowLedger(unerrDir);
-        ledger.record("get_entity", {}, {}, "main", "abc");
-        ledger.record("search", {}, {}, "main", "abc");
-        expect(ledger.getLastSyncTimestamp()).toBe(0);
-    });
-    it("returns timestamp of most recent sync_local_diff", () => {
-        const ledger = new ShadowLedger(unerrDir);
-        const beforeTs = Date.now();
-        ledger.record("sync_local_diff", {}, {}, "main", "abc");
-        const afterTs = Date.now();
-        const syncTs = ledger.getLastSyncTimestamp();
-        expect(syncTs).toBeGreaterThanOrEqual(beforeTs);
-        expect(syncTs).toBeLessThanOrEqual(afterTs);
-    });
-    it("returns latest sync when multiple syncs recorded", () => {
-        const ledger = new ShadowLedger(unerrDir);
-        ledger.record("sync_local_diff", {}, {}, "main", "abc");
-        ledger.record("get_entity", {}, {}, "main", "abc");
-        const beforeSecond = Date.now();
-        ledger.record("sync_local_diff", {}, {}, "main", "def");
-        const afterSecond = Date.now();
-        const syncTs = ledger.getLastSyncTimestamp();
-        expect(syncTs).toBeGreaterThanOrEqual(beforeSecond);
-        expect(syncTs).toBeLessThanOrEqual(afterSecond);
-    });
-});

package/dist/__tests__/shell-classifier.test.js

@@ -1,151 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { classifyShellOutput, matchCommandHint, normalizeShellCommand, } from "../proxy/shell-classifier.js";
-describe("shell-classifier", () => {
-    it("normalizes whitespace", () => {
-        expect(normalizeShellCommand("  ps   aux  ")).toBe("ps aux");
-    });
-    it("matches longest command hint", () => {
-        const m = matchCommandHint("docker ps -a");
-        expect(m?.category).toBe("tabular");
-    });
-    it("classifies ps aux + tabular stdout as high confidence", () => {
-        const stdout = "USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND\nroot         1  0.0  0.1 12345  678 ?        Ss   Jan01   0:01 init";
-        const r = classifyShellOutput("ps aux", stdout);
-        expect(r.category).toBe("tabular");
-        expect(r.confidence).toBeGreaterThanOrEqual(0.82);
-    });
-    it("uses command hint for npm test when output is weak", () => {
-        const r = classifyShellOutput("npm test", "something vague");
-        expect(r.category).toBe("test_results");
-        expect(r.hint_source).toBe("command_name");
-    });
-    it("detects git diff from content", () => {
-        const out = "diff --git a/x.ts b/x.ts\n--- a/x.ts\n+++ b/x.ts\n@@ -1 +1 @@\n";
-        const r = classifyShellOutput("unknown-cmd", out);
-        expect(r.category).toBe("diff");
-    });
-    it("detects tail-like logs from timestamps", () => {
-        const out = "2024-01-15T10:00:01Z INFO hello\n2024-01-15T10:00:02Z INFO world";
-        const r = classifyShellOutput("cat server.log", out);
-        expect(r.category).toBe("log_text");
-    });
-    it("detects pytest-style failures", () => {
-        const out = "FAIL tests/foo.py::test_bar\nAssertionError: expected 1";
-        const r = classifyShellOutput("pytest", out);
-        expect(r.category).toBe("test_results");
-    });
-    it("detects progress streaming", () => {
-        const out = "Downloading numpy-2.0.tar.gz\n[████████░░] 80% ETA 0:12";
-        const r = classifyShellOutput("pip install numpy", out);
-        expect(r.category).toBe("progress_streaming");
-    });
-    it("detects env-style key=value", () => {
-        const out = "HOME=/Users/x\nPATH=/usr/bin\nSHELL=/bin/zsh\nFOO=bar";
-        const r = classifyShellOutput("env", out);
-        expect(r.category).toBe("key_value");
-    });
-    it("passthrough commands defer to strong content heuristics", () => {
-        const rustcOutput = [
-            "error[E0308]: mismatched types",
-            "  --> src/main.rs:10:5",
-            "   |",
-            '10 |     let x: u32 = "hello";',
-            "   |            ---   ^^^^^^^ expected `u32`, found `&str`",
-        ].join("\n");
-        // cat is passthrough — rustc content (score 0.94) should override
-        const r = classifyShellOutput("cat /tmp/errors.txt", rustcOutput);
-        expect(r.category).toBe("error_diagnostic");
-        expect(r.hint_source).toBe("content_heuristic");
-    });
-    it("non-passthrough commands keep their hint even with strong content", () => {
-        // npm run build is NOT passthrough — hint should win
-        const gccOutput = "src/main.c:10:5: error: expected ';' after expression";
-        const r = classifyShellOutput("npm run build", gccOutput);
-        expect(r.category).toBe("log_text"); // hint wins
-        expect(r.hint_source).toBe("command_name");
-    });
-    it("classifies git blame as log_text (not tabular)", () => {
-        const r = classifyShellOutput("git blame src/main.ts", "abc123 (author 2024-01-01 10) line");
-        expect(r.category).toBe("log_text");
-    });
-    it("classifies git shortlog as log_text", () => {
-        const r = classifyShellOutput("git shortlog -sn", "42\tJohn Doe\n10\tJane");
-        expect(r.category).toBe("log_text");
-    });
-    it("classifies pgrep as log_text (not tabular)", () => {
-        const r = classifyShellOutput("pgrep node", "12345\n67890");
-        expect(r.category).toBe("log_text");
-    });
-    // ── Chain-aware matchCommandHint (Option B + improved #1) ───────────────
-    it("matchCommandHint: silent leading segment, hinted last segment", () => {
-        // chmod is silent; ls -la is the actual producer
-        const m = matchCommandHint("chmod +x foo.sh && ls -la dir/");
-        expect(m?.category).toBe("tabular");
-        expect(m?.key).toBe("ls -la");
-    });
-    it("matchCommandHint: hinted first segment, silent last (reversed order)", () => {
-        // The trailing chmod is silent — pass 1 walks back, skips it, finds ls -la
-        const m = matchCommandHint("ls -la dir/ && chmod +x foo");
-        expect(m?.category).toBe("tabular");
-        expect(m?.key).toBe("ls -la");
-    });
-    it("matchCommandHint: multiple silent prefixes, hinted trailing", () => {
-        const m = matchCommandHint("mkdir -p foo && cd foo && ls -lah");
-        expect(m?.category).toBe("tabular");
-        expect(m?.key).toBe("ls -lah");
-    });
-    it("matchCommandHint: pipeline last consumer wins (grep)", () => {
-        const m = matchCommandHint("find . -name '*.ts' | grep proxy");
-        // grep has a known hint (error_diagnostic via shellcheck-style content or log_text)
-        expect(m).not.toBeNull();
-    });
-    it("matchCommandHint: all-silent chain returns null", () => {
-        expect(matchCommandHint("git add . && git commit -m wip")).toBeNull();
-    });
-    it("matchCommandHint: single non-chain command still works", () => {
-        expect(matchCommandHint("docker ps -a")?.category).toBe("tabular");
-    });
-    it("matchCommandHint: strips redirects before matching", () => {
-        expect(matchCommandHint("ls -la dir/ > out.txt")?.category).toBe("tabular");
-        expect(matchCommandHint("ls -la dir/ 2>&1")?.category).toBe("tabular");
-    });
-    it("matchCommandHint: semicolon-separated chain", () => {
-        const m = matchCommandHint("echo start; ls -la dir/; echo done");
-        // echo is not in SILENT_COMMANDS (it produces meaningful output), so pass 1
-        // walks last→first; trailing `echo done` is non-silent but unhinted; falls
-        // through to `ls -la` which has a hint.
-        expect(m?.category).toBe("tabular");
-    });
-    // ── Short-output tabular detection (Option B) ───────────────────────────
-    it("classifies 3-row aligned output as tabular (short-output rule)", () => {
-        // ls -la of a 3-file directory — 3 aligned rows, would previously fall to
-        // omni because aligned was < 4. New short-output rule catches it.
-        // Each row needs ≥2 consecutive spaces somewhere (column padding).
-        const stdout = [
-            "total 8",
-            "drwxr-xr-x  3 user  wheel    96 May 12 02:31 .",
-            "drwxr-xr-x  4 user  wheel   128 May 12 02:31 ..",
-            "-rwxr-xr-x  1 user  wheel  1643 May 12 02:31 run-scenario.sh",
-        ].join("\n");
-        const r = classifyShellOutput("anything-unhinted-cmd", stdout);
-        expect(r.category).toBe("tabular");
-        // Lower confidence (0.72) so command-hint disagreement can still win
-        expect(r.confidence).toBeGreaterThanOrEqual(0.7);
-    });
-    it("does NOT classify random 2-row alignment as tabular", () => {
-        // Only 2 aligned rows + 1 short — should not trigger the short-output rule
-        const stdout = "ab\nfoo  bar\nbaz  qux";
-        const r = classifyShellOutput("randomcmd", stdout);
-        expect(r.category).not.toBe("tabular");
-    });
-    it("chain-aware classifier: chmod && ls -la routes to tabular", () => {
-        const stdout = [
-            "total 8",
-            "drwxr-xr-x  3 user  wheel    96 May 12 02:31 .",
-            "drwxr-xr-x  4 user  wheel   128 May 12 02:31 ..",
-            "-rwxr-xr-x  1 user  wheel  1643 May 12 02:31 script.sh",
-        ].join("\n");
-        const r = classifyShellOutput("chmod +x /tmp/x.sh && ls -la /tmp/", stdout);
-        expect(r.category).toBe("tabular");
-    });
-});

package/dist/__tests__/shell-compression-floor.test.js

@@ -1,189 +0,0 @@
-/**
- * R10 — per-classifier ≥60% compression CI gate.
- *
- * Asserts each strategy compresses its representative fixture by at least
- * the per-strategy floor. RTK's rule: filters must justify their existence.
- *
- * If you add a new strategy, add a fixture + floor here. If a fixture
- * regresses below floor, fix the strategy — don't lower the floor.
- */
-import { describe, expect, it } from "vitest";
-import { compressDiff } from "../proxy/shell-strategies/diff.js";
-import { compressErrorDiagnostic } from "../proxy/shell-strategies/error-diagnostic.js";
-import { compressKeyValue } from "../proxy/shell-strategies/key-value.js";
-import { compressLogText } from "../proxy/shell-strategies/log-text.js";
-import { compressProgress } from "../proxy/shell-strategies/progress.js";
-import { compressStructured } from "../proxy/shell-strategies/structured.js";
-import { compressTabular } from "../proxy/shell-strategies/tabular.js";
-import { compressTestResults } from "../proxy/shell-strategies/test-results.js";
-import { compressTreePaths } from "../proxy/shell-strategies/tree-paths.js";
-function ratio(raw, out) {
-    if (raw.length === 0)
-        return 0;
-    return (raw.length - out.length) / raw.length;
-}
-// Fixture builders — kept self-contained, no I/O
-const fxDiff = (() => {
-    const lines = [
-        "diff --git a/src/foo.ts b/src/foo.ts",
-        "index 1234567..abcdef 100644",
-        "--- a/src/foo.ts",
-        "+++ b/src/foo.ts",
-        "@@ -1,400 +1,400 @@",
-    ];
-    for (let i = 0; i < 800; i++) {
-        lines.push(i % 50 === 0
-            ? `+ const change_${i} = ${i};`
-            : `  const same_${i} = ${i};  // unchanged context line`);
-    }
-    return lines.join("\n");
-})();
-const fxLog = (() => {
-    const out = ["BUILD START"];
-    for (let i = 0; i < 1500; i++) {
-        out.push(`2026-05-13T14:32:0${i % 10}.123Z INFO compiling module/foo-${i % 8}.ts`);
-    }
-    out.push("Finished build in 12.3s");
-    return out.join("\n");
-})();
-const fxTree = (() => {
-    const out = ["."];
-    const dirs = ["components", "lib", "pages", "hooks", "utils", "tests"];
-    const exts = [".ts", ".tsx", ".test.ts", ".css"];
-    for (const d of dirs) {
-        for (let i = 0; i < 40; i++) {
-            const ext = exts[i % exts.length];
-            out.push(`src/${d}/file_${i}${ext}`);
-        }
-    }
-    return out.join("\n");
-})();
-const fxTabular = (() => {
-    const out = [
-        "USER       PID %CPU %MEM     VSZ    RSS TTY   STAT START   TIME COMMAND",
-    ];
-    for (let i = 0; i < 200; i++) {
-        out.push(`user${i.toString().padStart(3, "0")} ${(1000 + i).toString().padStart(5)} ${(i % 20).toFixed(1)}  ${(i % 8).toFixed(1)}  123456 ${(20000 + i).toString().padStart(6)} ?     S    10:00   0:00 some/long/process/name-${i}`);
-    }
-    return out.join("\n");
-})();
-const fxKeyValue = (() => {
-    const out = [];
-    for (let i = 0; i < 300; i++) {
-        out.push(`MY_LONG_ENV_VAR_${i}=value_with_meaningful_content_${i}_padded`);
-    }
-    return out.join("\n");
-})();
-const fxStructured = JSON.stringify({
-    items: Array.from({ length: 200 }, (_, i) => ({
-        id: i,
-        name: `item-${i}`,
-        tags: ["a", "b", "c"],
-        meta: { ts: "2026-05-13T14:32:01.123Z", uuid: "abc-123-def-456" },
-    })),
-}, null, 2);
-const fxProgress = (() => {
-    const out = [];
-    for (let i = 0; i <= 100; i += 2) {
-        out.push(`[${"#".repeat(i / 2)}${" ".repeat(50 - i / 2)}] ${i}% downloading pkg-name`);
-    }
-    out.push("done");
-    return out.join("\n");
-})();
-const fxTestResults = (() => {
-    const out = ["RUNS  src/example.test.ts"];
-    for (let i = 0; i < 80; i++) {
-        out.push(`  ✓ test case ${i} should pass when conditions are met (${i}ms)`);
-    }
-    out.push("");
-    out.push("Test Suites: 1 passed, 1 total");
-    out.push("Tests:       80 passed, 80 total");
-    out.push("Snapshots:   0 total");
-    out.push("Time:        2.345 s");
-    return out.join("\n");
-})();
-const fxErrorDiag = (() => {
-    const out = [];
-    for (let i = 0; i < 50; i++) {
-        out.push(`src/file_${i}.ts(${10 + i},${5 + (i % 30)}): error TS2304: Cannot find name 'foo${i}'.`);
-        out.push(`   10   const x = foo${i}();`);
-        out.push("                  ~~~~~~");
-        out.push("");
-    }
-    return out.join("\n");
-})();
-const cases = [
-    {
-        name: "diff",
-        // Synthetic fixture: 800 lines, 16 changes — heavy unchanged-context tail
-        // limits real-world ratios. Real-world README claim is 99% on actual diffs;
-        // this floor protects against strategy regressing to passthrough.
-        floor: 0.65,
-        raw: fxDiff,
-        run: () => compressDiff(fxDiff, undefined, "git diff"),
-    },
-    {
-        name: "log_text",
-        floor: 0.6,
-        raw: fxLog,
-        run: () => compressLogText(fxLog, "vite build"),
-    },
-    {
-        name: "tree_paths",
-        floor: 0.6,
-        raw: fxTree,
-        run: () => compressTreePaths(fxTree, 3, "tree"),
-    },
-    {
-        name: "tabular",
-        // Synthetic ps aux fixture has high column-uniqueness; real-world ratios
-        // (77% per README) come from outputs with more repeated values. Floor
-        // here protects against the strategy regressing to passthrough.
-        floor: 0.4,
-        raw: fxTabular,
-        run: () => compressTabular(fxTabular, "ps aux"),
-    },
-    {
-        name: "key_value",
-        floor: 0.4,
-        raw: fxKeyValue,
-        run: () => compressKeyValue(fxKeyValue, "env"),
-    },
-    {
-        name: "structured",
-        floor: 0.6,
-        raw: fxStructured,
-        run: () => compressStructured(fxStructured, "curl"),
-    },
-    {
-        name: "progress",
-        floor: 0.6,
-        raw: fxProgress,
-        run: () => compressProgress(fxProgress, "npm install"),
-    },
-    {
-        name: "test_results",
-        floor: 0.8,
-        raw: fxTestResults,
-        run: () => compressTestResults(fxTestResults, "vitest", 0),
-    },
-    {
-        name: "error_diagnostic",
-        floor: 0.5,
-        raw: fxErrorDiag,
-        run: () => compressErrorDiagnostic(fxErrorDiag, "tsc"),
-    },
-];
-describe("R10 — per-classifier compression floor (≥ per-strategy floor)", () => {
-    for (const c of cases) {
-        it(`${c.name} compresses by ≥${Math.round(c.floor * 100)}%`, () => {
-            const out = c.run();
-            const r = ratio(c.raw, out);
-            if (r < c.floor) {
-                // Helpful failure message — what we got vs what's required
-                throw new Error(`${c.name}: ratio ${(r * 100).toFixed(1)}% < floor ${(c.floor * 100).toFixed(0)}% — raw ${c.raw.length}B, out ${out.length}B`);
-            }
-            expect(r).toBeGreaterThanOrEqual(c.floor);
-        });
-    }
-});