@unerr-ai/unerr 0.0.1 → 0.1.1

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

@@ -0,0 +1,225 @@
+/**
+ * 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

@@ -0,0 +1,251 @@
+/**
+ * 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

@@ -0,0 +1,89 @@
+/**
+ * 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

@@ -0,0 +1,93 @@
+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);
+    });
+});