@unerr-ai/unerr 0.1.6 → 0.1.7

package/dist/__tests__/nudge-v2.test.js

@@ -1,225 +0,0 @@
-/**
- * Tests for Nudge v2 — drift detector + session state.
- *
- * Critical contract: the new system must NOT degrade unerr MCP tool adoption.
- * - Drift detector must fire on grep/find/cat on code paths.
- * - Drift detector must NOT fire on legitimate Bash commands (npm, git tag,
- *   mkdir, clean linters, ls without -R, grep of log files, etc.) so the
- *   agent isn't nudged for things that don't have an unerr equivalent.
- * - State machine must enforce one-Tier-1-per-kind-per-session.
- * - markUnerrToolUsed must reset the drift accumulator so Tier 2 only fires
- *   on PERSISTENT drift, never on a single mistake.
- */
-import { mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { formatDriftNudge, isDriftCommand } from "../proxy/drift-detector.js";
-import { _resetNudgeState, markUnerrToolUsed, readNudgeState, updateNudgeState, } from "../proxy/nudge-state.js";
-describe("isDriftCommand — TRUE POSITIVES (must nudge)", () => {
-    it("flags grep on a code path", () => {
-        const h = isDriftCommand("grep -r 'compressShellOutput' src/proxy/");
-        expect(h?.kind).toBe("code_search");
-        expect(h?.arg).toBe("compressShellOutput");
-        expect(h?.suggest).toContain("search_code");
-    });
-    it("flags rg on a code path", () => {
-        const h = isDriftCommand("rg foo src/");
-        expect(h?.kind).toBe("code_search");
-    });
-    it("flags find -name *.ts", () => {
-        const h = isDriftCommand("find . -name '*.ts'");
-        expect(h?.kind).toBe("code_search");
-        expect(h?.suggest).toContain("search_code");
-    });
-    it("flags cat on a .ts file", () => {
-        const h = isDriftCommand("cat src/proxy/shell-compressor.ts");
-        expect(h?.kind).toBe("code_read");
-        expect(h?.suggest).toContain("file_read");
-        expect(h?.suggest).toContain("src/proxy/shell-compressor.ts");
-    });
-    it("flags head -100 on a .py file", () => {
-        const h = isDriftCommand("head -100 lib/foo.py");
-        expect(h?.kind).toBe("code_read");
-    });
-    it("flags ls -R src/", () => {
-        const h = isDriftCommand("ls -R src/");
-        expect(h?.kind).toBe("dir_explore");
-        expect(h?.suggest).toContain("file_outline");
-    });
-    it("strips leading env vars before classification", () => {
-        const h = isDriftCommand("FOO=1 BAR=2 grep -r 'x' src/");
-        expect(h?.kind).toBe("code_search");
-    });
-    it("strips leading sudo / time prefixes", () => {
-        const h = isDriftCommand("time grep -r 'x' src/");
-        expect(h?.kind).toBe("code_search");
-    });
-    // Regression: absolute paths like /Users/foo/repo/src/proxy/ must fire too.
-    // CODE_PATH_HINT_RE previously required src/lib/etc to be preceded by
-    // whitespace/quote/start — slashes were excluded, so abs paths silently
-    // bypassed the v2 drift nudge.
-    it("flags grep against an absolute path containing src/", () => {
-        const h = isDriftCommand("grep -rn 'compressShellOutput' /Users/foo/repo/src/proxy/");
-        expect(h?.kind).toBe("code_search");
-        expect(h?.suggest).toContain("search_code");
-    });
-    it("flags grep against an absolute path containing lib/", () => {
-        const h = isDriftCommand("grep -rn 'foo' /home/u/code/lib/");
-        expect(h?.kind).toBe("code_search");
-    });
-});
-describe("isDriftCommand — TRUE NEGATIVES (must NOT nudge)", () => {
-    // These are the commands the v1 nudge fired on unnecessarily.
-    // Each one should return null — there is no unerr alternative.
-    it("does NOT flag npm version", () => {
-        expect(isDriftCommand("npm version 0.0.0-beta.11 --no-git-tag-version")).toBeNull();
-    });
-    it("does NOT flag git tag / git status / git log", () => {
-        expect(isDriftCommand("git tag v1.0.0")).toBeNull();
-        expect(isDriftCommand("git status")).toBeNull();
-        expect(isDriftCommand("git log --oneline -10")).toBeNull();
-    });
-    it("does NOT flag mkdir / chmod / rm", () => {
-        expect(isDriftCommand("mkdir -p /tmp/foo")).toBeNull();
-        expect(isDriftCommand("chmod +x /tmp/foo.sh")).toBeNull();
-        expect(isDriftCommand("rm -rf /tmp/foo")).toBeNull();
-    });
-    it("does NOT flag a clean eslint run", () => {
-        expect(isDriftCommand("node_modules/.bin/eslint 'app/(launch)'")).toBeNull();
-    });
-    it("does NOT flag pnpm install / build / test", () => {
-        expect(isDriftCommand("pnpm install")).toBeNull();
-        expect(isDriftCommand("pnpm run build")).toBeNull();
-        expect(isDriftCommand("pnpm exec vitest run")).toBeNull();
-    });
-    it("does NOT flag grep on a log file (no code extension)", () => {
-        expect(isDriftCommand("grep ERROR build.log")).toBeNull();
-        expect(isDriftCommand("grep 'foo' /var/log/syslog")).toBeNull();
-    });
-    it("does NOT flag cat on a non-code file", () => {
-        expect(isDriftCommand("cat README.md")).toBeNull();
-        expect(isDriftCommand("cat package.json")).toBeNull();
-        expect(isDriftCommand("cat /tmp/output.txt")).toBeNull();
-    });
-    it("does NOT flag ls without -R", () => {
-        expect(isDriftCommand("ls src/")).toBeNull();
-        expect(isDriftCommand("ls -la /tmp/")).toBeNull();
-    });
-    it("does NOT flag find without -name on code", () => {
-        expect(isDriftCommand("find . -type d")).toBeNull();
-        expect(isDriftCommand("find /tmp -mmin -5")).toBeNull();
-    });
-    it("does NOT flag find -name '*.log'", () => {
-        expect(isDriftCommand("find . -name '*.log'")).toBeNull();
-    });
-    it("does NOT flag empty or whitespace command", () => {
-        expect(isDriftCommand("")).toBeNull();
-        expect(isDriftCommand("   ")).toBeNull();
-    });
-});
-describe("formatDriftNudge — output shape", () => {
-    it("produces a one-line nudge with the alternative", () => {
-        // Post-trim format (table rows #1-4): drops the internal "drift(<kind>):
-        // try" preamble. Line starts with "[unerr]" + the paste-ready call.
-        const hint = isDriftCommand("grep -r foo src/");
-        const line = formatDriftNudge(hint);
-        expect(line).toMatch(/^\[unerr\] search_code\(/);
-        expect(line).toContain("search_code");
-        expect(line).not.toContain("drift("); // taxonomy prefix removed
-        expect(line.length).toBeLessThan(200);
-    });
-});
-describe("nudge-state — session flag persistence", () => {
-    let tmpRoot;
-    beforeEach(() => {
-        tmpRoot = join(tmpdir(), `unerr-nudge-${Date.now()}-${Math.random()}`);
-        mkdirSync(join(tmpRoot, ".unerr"), { recursive: true });
-        _resetNudgeState(tmpRoot);
-    });
-    afterEach(() => {
-        try {
-            rmSync(tmpRoot, { recursive: true, force: true });
-        }
-        catch {
-            // ignore
-        }
-    });
-    it("reads default state for a fresh session", () => {
-        const s = readNudgeState(tmpRoot);
-        expect(s.tier0_emitted).toBe(false);
-        expect(s.tier1_emitted_kinds).toEqual([]);
-        expect(s.drift_count).toBe(0);
-        expect(s.tier2_emitted).toBe(false);
-    });
-    it("persists tier1 emissions per kind", () => {
-        updateNudgeState(tmpRoot, (s) => {
-            s.tier1_emitted_kinds.push("code_search");
-            s.drift_count = 1;
-        });
-        const s2 = readNudgeState(tmpRoot);
-        expect(s2.tier1_emitted_kinds).toEqual(["code_search"]);
-        expect(s2.drift_count).toBe(1);
-    });
-    it("markUnerrToolUsed resets drift_count and clears Tier-2", () => {
-        updateNudgeState(tmpRoot, (s) => {
-            s.drift_count = 5;
-            s.tier2_emitted = true;
-        });
-        markUnerrToolUsed(tmpRoot);
-        const s = readNudgeState(tmpRoot);
-        expect(s.drift_count).toBe(0);
-        expect(s.tier2_emitted).toBe(false);
-        expect(s.last_unerr_tool_at).toBeDefined();
-    });
-    it("readNudgeState recovers gracefully from corrupt state", () => {
-        // Make sure the state dir exists, then write garbage
-        mkdirSync(join(tmpRoot, ".unerr", "state"), { recursive: true });
-        writeFileSync(join(tmpRoot, ".unerr", "state", `nudge-pid-${process.pid}.flags`), "{not json", { flag: "w" });
-        // Should not throw
-        const s = readNudgeState(tmpRoot);
-        expect(s.tier0_emitted).toBe(false);
-    });
-});
-describe("anti-drift correctness — guarantees that protect MCP tool adoption", () => {
-    // These are the safety properties the new system MUST preserve.
-    it("every drift-positive command has a non-empty suggestion", () => {
-        const positives = [
-            "grep -r foo src/",
-            "rg pattern src/proxy/",
-            "find . -name '*.ts'",
-            "cat src/foo.ts",
-            "head src/bar.py",
-            "tail -50 src/baz.rs",
-            "ls -R src/",
-        ];
-        for (const cmd of positives) {
-            const h = isDriftCommand(cmd);
-            expect(h).not.toBeNull();
-            expect(h?.suggest.length).toBeGreaterThan(20);
-            expect(h?.suggest).toMatch(/search_code|file_read|file_outline|get_/);
-        }
-    });
-    it("nudge text length is always shorter than ~10× a small command", () => {
-        // The drift nudge must be tight enough that even a 30-byte command
-        // gets a useful one-liner, not a paragraph.
-        const h = isDriftCommand("grep -r x src/");
-        expect(formatDriftNudge(h).length).toBeLessThan(150);
-    });
-    it("no drift-positive overlaps with build/test/install commands", () => {
-        // If we ever falsely flag these, Phase B rollout would break agent flow.
-        const benign = [
-            "pnpm test",
-            "pnpm install --frozen-lockfile",
-            "npm run build",
-            "cargo test",
-            "go test ./...",
-            "make all",
-            "docker build -t foo .",
-            "kubectl apply -f k8s.yaml",
-        ];
-        for (const cmd of benign) {
-            expect(isDriftCommand(cmd)).toBeNull();
-        }
-    });
-});

package/dist/__tests__/offline-rewind.test.js

@@ -1,251 +0,0 @@
-/**
- * Tests for Zero-Network Rewind — Phase 5.5 P5.5-TEST-07a
- *
- * Tests offline rewind via CozoDB + local git operations.
- * Covers: file restoration, local ledger updates, timeline branching,
- * and blast radius resolution (<200ms).
- */
-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, vi } from "vitest";
-import { offlineRewind } from "../tracking/offline-rewind.js";
-import { ShadowLedger } from "../tracking/shadow-ledger.js";
-vi.mock("../utils/git.js", () => ({
-    checkoutFile: vi.fn().mockResolvedValue(undefined),
-    getGit: vi.fn(),
-    isGitRepo: vi.fn().mockResolvedValue(true),
-}));
-class MockCozoGraphStore {
-    entities = [];
-    edges = [];
-    addEntity(entity) {
-        this.entities.push(entity);
-    }
-    addEdge(edge) {
-        this.edges.push(edge);
-    }
-    getEntitiesByFile(filePath) {
-        return this.entities
-            .filter((e) => e.file_path === filePath)
-            .map((e) => ({
-            ...e,
-            risk_level: e.risk_level,
-        }));
-    }
-    getCallersOf(entityKey) {
-        return this.edges
-            .filter((e) => e.to_key === entityKey)
-            .map((e) => {
-            const entity = this.entities.find((ent) => ent.key === e.from_key);
-            return entity
-                ? {
-                    ...entity,
-                    risk_level: entity.risk_level,
-                }
-                : null;
-        })
-            .filter(Boolean);
-    }
-    clearDriftOverlay() {
-        /* no-op for tests */
-    }
-}
-let testDir;
-let unerrDir;
-let graph;
-let ledger;
-beforeEach(() => {
-    testDir = join(tmpdir(), `unerr-test-rewind-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    unerrDir = join(testDir, ".unerr");
-    mkdirSync(join(unerrDir, "ledger"), { recursive: true });
-    mkdirSync(join(unerrDir, "state"), { recursive: true });
-    graph = new MockCozoGraphStore();
-    ledger = new ShadowLedger(unerrDir);
-});
-afterEach(() => {
-    vi.restoreAllMocks();
-    try {
-        rmSync(testDir, { recursive: true, force: true });
-    }
-    catch {
-        /* ignore */
-    }
-});
-function recordEntry(tool, branch, headSha, args) {
-    return ledger.record(tool, args ?? {}, {}, branch, headSha);
-}
-describe("Zero-Network Rewind (P5.5-TEST-07a)", () => {
-    it("returns error when target entry not found in local ledger", async () => {
-        const result = await offlineRewind({
-            targetEntryId: "nonexistent",
-            cwd: testDir,
-            unerrDir,
-            graph: graph,
-            ledger,
-        });
-        expect(result.status).toBe("error");
-        expect(result.errorMessage).toContain("not found");
-    });
-    it("dry run returns blast radius without applying changes", async () => {
-        const target = recordEntry("sync_local_diff", "main", "sha-target", {
-            files: ["src/ok.ts"],
-        });
-        recordEntry("sync_local_diff", "main", "sha-bad", {
-            files: ["src/bad.ts"],
-        });
-        const result = await offlineRewind({
-            targetEntryId: target.id,
-            cwd: testDir,
-            unerrDir,
-            graph: graph,
-            ledger,
-            dryRun: true,
-        });
-        expect(result.status).toBe("dry_run");
-        expect(result.rewindEntryId).toBeNull();
-        expect(result.filesRestored.length).toBe(0);
-    });
-    it("local shadow.jsonl updated with status: simulated", async () => {
-        const target = recordEntry("sync_local_diff", "main", "sha-111", {
-            files: ["src/a.ts"],
-        });
-        recordEntry("sync_local_diff", "main", "sha-222", {
-            files: ["src/b.ts"],
-        });
-        const result = await offlineRewind({
-            targetEntryId: target.id,
-            cwd: testDir,
-            unerrDir,
-            graph: graph,
-            ledger,
-        });
-        expect(result.status).toBe("simulated");
-        const allEntries = ledger.readAllEntries();
-        const rewindEntry = allEntries.find((e) => e.id === result.rewindEntryId);
-        expect(rewindEntry).toBeDefined();
-        expect(rewindEntry?.tool).toBe("revert_to_working_state");
-        expect((rewindEntry?.result_summary).rewind_status).toBe("simulated");
-        expect((rewindEntry?.args_summary).offline).toBe(true);
-    });
-    it("local timeline_branch incremented in branch_context.json", async () => {
-        const target = recordEntry("sync_local_diff", "main", "sha-aaa");
-        recordEntry("sync_local_diff", "main", "sha-bbb");
-        const result = await offlineRewind({
-            targetEntryId: target.id,
-            cwd: testDir,
-            unerrDir,
-            graph: graph,
-            ledger,
-        });
-        expect(result.timelineBranch).toBe(2);
-        const contextPath = join(unerrDir, "ledger", "branch_context.json");
-        expect(existsSync(contextPath)).toBe(true);
-        const context = JSON.parse(readFileSync(contextPath, "utf-8"));
-        expect(context.timeline_branch).toBe(2);
-    });
-    it("rewind produces a valid rewind entry", async () => {
-        const target = recordEntry("sync_local_diff", "main", "sha-ccc");
-        recordEntry("sync_local_diff", "main", "sha-ddd");
-        const result = await offlineRewind({
-            targetEntryId: target.id,
-            cwd: testDir,
-            unerrDir,
-            graph: graph,
-            ledger,
-        });
-        expect(result.status).toBe("simulated");
-        expect(result.rewindEntryId).toBeTruthy();
-    });
-    it("blast radius resolution uses CozoDB entities and callers", async () => {
-        graph.addEntity({
-            key: "fn-process",
-            kind: "function",
-            name: "processOrder",
-            file_path: "src/orders.ts",
-            start_line: 10,
-            signature: "processOrder()",
-            body: "",
-            fan_in: 5,
-            fan_out: 2,
-            risk_level: "high",
-        });
-        graph.addEntity({
-            key: "fn-checkout",
-            kind: "function",
-            name: "checkout",
-            file_path: "src/checkout.ts",
-            start_line: 1,
-            signature: "checkout()",
-            body: "",
-            fan_in: 3,
-            fan_out: 1,
-            risk_level: "medium",
-        });
-        graph.addEdge({
-            from_key: "fn-checkout",
-            to_key: "fn-process",
-            type: "calls",
-        });
-        const ledgerPath = join(unerrDir, "ledger", "shadow.jsonl");
-        const targetEntry = {
-            id: "tgt-blast",
-            ts: new Date(Date.now() - 2000).toISOString(),
-            tool: "sync_local_diff",
-            args_summary: { files: ["src/ok.ts"] },
-            result_summary: {},
-            branch: "main",
-            head_sha: "sha-tgt",
-            session_id: "test-session",
-            correlation_id: null,
-        };
-        const badEntry = {
-            id: "bad-blast",
-            ts: new Date(Date.now() - 1000).toISOString(),
-            tool: "sync_local_diff",
-            args_summary: { files: ["src/orders.ts"] },
-            result_summary: {},
-            branch: "main",
-            head_sha: "sha-bad",
-            session_id: "test-session",
-            correlation_id: null,
-        };
-        writeFileSync(ledgerPath, `${JSON.stringify(targetEntry)}\n${JSON.stringify(badEntry)}\n`);
-        const freshLedger = new ShadowLedger(unerrDir);
-        const result = await offlineRewind({
-            targetEntryId: "tgt-blast",
-            cwd: testDir,
-            unerrDir,
-            graph: graph,
-            ledger: freshLedger,
-            dryRun: true,
-        });
-        expect(result.status).toBe("dry_run");
-        expect(result.blastRadius.affectedEntities.length).toBe(1);
-        expect(result.blastRadius.affectedEntities[0]?.key).toBe("fn-process");
-        expect(result.blastRadius.affectedEntities[0]?.riskLevel).toBe("high");
-        expect(result.blastRadius.affectedCallers).toBe(1);
-        expect(result.blastRadius.resolvedInMs).toBeLessThan(200);
-    });
-    it("sequential offline rewinds increment timeline branch correctly", async () => {
-        const target = recordEntry("sync_local_diff", "main", "sha-seq-1");
-        recordEntry("sync_local_diff", "main", "sha-seq-2");
-        const r1 = await offlineRewind({
-            targetEntryId: target.id,
-            cwd: testDir,
-            unerrDir,
-            graph: graph,
-            ledger,
-        });
-        expect(r1.timelineBranch).toBe(2);
-        recordEntry("sync_local_diff", "main", "sha-seq-3");
-        const r2 = await offlineRewind({
-            targetEntryId: target.id,
-            cwd: testDir,
-            unerrDir,
-            graph: graph,
-            ledger,
-        });
-        expect(r2.timelineBranch).toBe(3);
-    });
-});

package/dist/__tests__/open-threads.test.js

@@ -1,89 +0,0 @@
-/**
- * ST-3a: Open threads — mark_blocker entries without a matching mark_resolution.
- */
-import { describe, expect, it } from "vitest";
-import { computeOpenThreads } from "../timeline/open-threads.js";
-function blocker(id, text, ts = 0) {
-    return {
-        marker_id: id,
-        type: "mark_blocker",
-        text,
-        session_id: "s1",
-        turn_id: "t1",
-        ts,
-        blocker_ref: "",
-        file_path: "",
-    };
-}
-function resolution(refId, ts = 0) {
-    return {
-        marker_id: `res-${refId}`,
-        type: "mark_resolution",
-        text: `resolved ${refId}`,
-        session_id: "s1",
-        turn_id: "t1",
-        ts,
-        blocker_ref: refId,
-        file_path: "",
-    };
-}
-describe("computeOpenThreads", () => {
-    it("returns all blockers when no resolutions exist", () => {
-        const open = computeOpenThreads([
-            blocker("b1", "type error", 100),
-            blocker("b2", "auth flow stuck", 200),
-        ]);
-        expect(open.map((t) => t.marker_id)).toEqual(["b2", "b1"]); // newest first
-    });
-    it("filters out blockers with a matching resolution", () => {
-        const open = computeOpenThreads([
-            blocker("b1", "type error", 100),
-            blocker("b2", "auth flow stuck", 200),
-            resolution("b1", 150),
-        ]);
-        expect(open).toHaveLength(1);
-        expect(open[0]?.marker_id).toBe("b2");
-    });
-    it("returns empty when all blockers resolved", () => {
-        const open = computeOpenThreads([
-            blocker("b1", "x", 100),
-            blocker("b2", "y", 200),
-            resolution("b1", 300),
-            resolution("b2", 400),
-        ]);
-        expect(open).toEqual([]);
-    });
-    it("ignores non-blocker / non-resolution markers", () => {
-        const open = computeOpenThreads([
-            {
-                marker_id: "i1",
-                type: "mark_intent",
-                text: "refactor",
-                session_id: "s1",
-                turn_id: "t1",
-                ts: 50,
-                blocker_ref: "",
-                file_path: "",
-            },
-            blocker("b1", "stuck", 100),
-        ]);
-        expect(open).toHaveLength(1);
-        expect(open[0]?.marker_id).toBe("b1");
-    });
-    it("a resolution without blocker_ref does not silence any blocker", () => {
-        const open = computeOpenThreads([
-            blocker("b1", "x", 100),
-            {
-                marker_id: "r1",
-                type: "mark_resolution",
-                text: "?",
-                session_id: "s1",
-                turn_id: "t1",
-                ts: 200,
-                blocker_ref: "",
-                file_path: "",
-            },
-        ]);
-        expect(open).toHaveLength(1);
-    });
-});

package/dist/__tests__/output-compressor.test.js

@@ -1,93 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { compressOutput, } from "../proxy/output-compressor.js";
-const LARGE_DIFF = `diff --git a/src/proxy/proxy.ts b/src/proxy/proxy.ts
---- a/src/proxy/proxy.ts
-+++ b/src/proxy/proxy.ts
-@@ -10,6 +10,10 @@ import { join } from "node:path";
- import { PidLock } from "./pid-lock.js";
-+import { createLifecycleActor } from "./lifecycle-actor.js";
-+import { createEnvelopePipeline } from "./response-envelope.js";
- 
- const log = {
-   info: (msg: string) => process.stderr.write(msg),
- };
-${Array.from({ length: 100 }, (_, i) => `+  line ${i}: added utility function`).join("\n")}
-diff --git a/src/utils/helpers.ts b/src/utils/helpers.ts
---- a/src/utils/helpers.ts
-+++ b/src/utils/helpers.ts
-@@ -1,3 +1,5 @@
-+export function helper1() { return 1; }
-+export function helper2() { return 2; }
-${Array.from({ length: 50 }, (_, i) => `   unchanged line ${i}`).join("\n")}
-diff --git a/src/tracking/drift-tracker.ts b/src/tracking/drift-tracker.ts
---- a/src/tracking/drift-tracker.ts
-+++ b/src/tracking/drift-tracker.ts
-@@ -5,3 +5,8 @@
-+ERROR: TypeScript compilation failed
-+TypeError: Cannot read property 'length' of undefined
-${Array.from({ length: 30 }, (_, i) => `+  drift change ${i}`).join("\n")}`;
-describe("compressOutput", () => {
-    it("passes through small outputs unchanged", () => {
-        const small = "hello world\nline 2\nline 3";
-        const result = compressOutput(small, { tokenBudget: 10000 });
-        expect(result.output).toBe(small);
-        expect(result.sectionsOmitted).toBe(0);
-    });
-    it("compresses large outputs below token budget", () => {
-        const result = compressOutput(LARGE_DIFF, { tokenBudget: 500 });
-        expect(result.compressedTokens).toBeLessThan(result.originalTokens);
-        expect(result.sectionsOmitted).toBeGreaterThan(0);
-    });
-    it("preserves error sections with highest priority", () => {
-        const result = compressOutput(LARGE_DIFF, { tokenBudget: 300 });
-        expect(result.output).toContain("ERROR");
-        expect(result.output).toContain("TypeError");
-    });
-    it("adds omission markers for removed sections", () => {
-        const result = compressOutput(LARGE_DIFF, { tokenBudget: 200 });
-        expect(result.output).toContain("[...");
-        expect(result.output).toContain("lines omitted");
-    });
-    it("annotates high-risk entity sections", () => {
-        const riskMap = new Map([
-            [
-                "src/proxy/proxy.ts::startProxy",
-                {
-                    riskLevel: "high",
-                    fanIn: 14,
-                    isChokepoint: true,
-                    conventions: ["camelCase"],
-                },
-            ],
-        ]);
-        const result = compressOutput(LARGE_DIFF, {
-            tokenBudget: 800,
-            entityRiskMap: riskMap,
-        });
-        expect(result.annotations.length).toBeGreaterThan(0);
-        if (result.annotations.some((a) => a.includes("HIGH_RISK"))) {
-            expect(result.output).toContain("[HIGH_RISK");
-        }
-    });
-    it("annotates chokepoint entities", () => {
-        const riskMap = new Map([
-            [
-                "src/proxy/proxy.ts::startProxy",
-                { riskLevel: "high", fanIn: 20, isChokepoint: true },
-            ],
-        ]);
-        const result = compressOutput(LARGE_DIFF, {
-            tokenBudget: 800,
-            entityRiskMap: riskMap,
-        });
-        if (result.annotations.some((a) => a.includes("CHOKEPOINT"))) {
-            expect(result.output).toContain("[CHOKEPOINT]");
-        }
-    });
-    it("reports compression metrics", () => {
-        const result = compressOutput(LARGE_DIFF, { tokenBudget: 300 });
-        expect(result.originalTokens).toBeGreaterThan(0);
-        expect(result.compressedTokens).toBeGreaterThan(0);
-        expect(result.compressedTokens).toBeLessThanOrEqual(result.originalTokens);
-    });
-});