@unerr-ai/unerr 0.0.1 → 0.1.1

package/dist/__tests__/components.test.js

@@ -0,0 +1,449 @@
+/**
+ * Tests for Sprint 1 Ink components (Task 1.2).
+ *
+ * Tests validate:
+ *   - Banner: renders brand name and tagline
+ *   - Section: renders title with line decoration
+ *   - KeyValue: renders label and value with alignment
+ *   - ProgressBar: sub-character Unicode blocks, clamping, label
+ *   - GradeBadge: colored grade with optional score
+ *   - StepLine: icon + label + value for each status
+ *   - HealthCard: grade + bar + dead functions + chokepoints
+ *   - DriftSummary: modified/added/deleted counts
+ *   - ViolationList: severity icons + messages + suggestions
+ *   - SessionSummaryCard: tool calls, local rate, savings, latency
+ *   - InkSpinner: renders frame and label
+ *   - ConfirmPrompt: renders message and hint
+ */
+import { render } from "ink-testing-library";
+import React from "react";
+import { describe, expect, it } from "vitest";
+import { Banner } from "../components/Banner.js";
+import { ConfirmPrompt } from "../components/ConfirmPrompt.js";
+import { DriftSummary } from "../components/DriftSummary.js";
+import { GradeBadge } from "../components/GradeBadge.js";
+import { HealthCard } from "../components/HealthCard.js";
+import { InkSpinner } from "../components/InkSpinner.js";
+import { KeyValue } from "../components/KeyValue.js";
+import { BLOCKS, ProgressBar } from "../components/ProgressBar.js";
+import { Section } from "../components/Section.js";
+import { SessionSummaryCard } from "../components/SessionSummaryCard.js";
+import { StepLine } from "../components/StepLine.js";
+import { ViolationList } from "../components/ViolationList.js";
+import { createSessionStats } from "../proxy/session-stats.js";
+// ── Banner ───────────────────────────────────────────────────────
+describe("Banner", () => {
+    it("renders brand name", () => {
+        const { lastFrame } = render(React.createElement(Banner));
+        expect(lastFrame()).toContain("unerr");
+    });
+    it("renders tagline", () => {
+        const { lastFrame } = render(React.createElement(Banner));
+        expect(lastFrame()).toContain("Code intelligence");
+    });
+    it("renders separator", () => {
+        const { lastFrame } = render(React.createElement(Banner));
+        expect(lastFrame()).toContain("▸");
+    });
+});
+// ── Section ──────────────────────────────────────────────────────
+describe("Section", () => {
+    it("renders title with line decoration", () => {
+        const { lastFrame } = render(React.createElement(Section, { title: "First Look" }));
+        const frame = lastFrame() ?? "";
+        expect(frame).toContain("──");
+        expect(frame).toContain("First Look");
+    });
+    it("renders with custom width", () => {
+        const { lastFrame } = render(React.createElement(Section, { title: "Test", width: 30 }));
+        expect(lastFrame()).toContain("──");
+        expect(lastFrame()).toContain("Test");
+    });
+});
+// ── KeyValue ─────────────────────────────────────────────────────
+describe("KeyValue", () => {
+    it("renders label and value", () => {
+        const { lastFrame } = render(React.createElement(KeyValue, {
+            label: "Repository",
+            value: "acme/widgets",
+        }));
+        const frame = lastFrame() ?? "";
+        expect(frame).toContain("Repository");
+        expect(frame).toContain("acme/widgets");
+    });
+    it("pads label to specified width", () => {
+        const { lastFrame } = render(React.createElement(KeyValue, {
+            label: "Key",
+            value: "val",
+            labelWidth: 10,
+        }));
+        // Label "Key" padded to 10 chars
+        expect(lastFrame()).toContain("Key");
+        expect(lastFrame()).toContain("val");
+    });
+});
+// ── ProgressBar ──────────────────────────────────────────────────
+describe("ProgressBar", () => {
+    it("renders empty bar for value 0", () => {
+        const { lastFrame } = render(React.createElement(ProgressBar, { value: 0, width: 10 }));
+        const frame = lastFrame() ?? "";
+        // Should be all spaces (empty bar)
+        expect(frame.includes("█")).toBe(false);
+    });
+    it("renders full bar for value 1", () => {
+        const { lastFrame } = render(React.createElement(ProgressBar, { value: 1, width: 10 }));
+        const frame = lastFrame() ?? "";
+        expect(frame).toContain("██████████");
+    });
+    it("renders partial fill for value 0.5", () => {
+        const { lastFrame } = render(React.createElement(ProgressBar, { value: 0.5, width: 10 }));
+        const frame = lastFrame() ?? "";
+        expect(frame).toContain("█████");
+    });
+    it("shows percentage label when showLabel is true", () => {
+        const { lastFrame } = render(React.createElement(ProgressBar, {
+            value: 0.62,
+            width: 10,
+            showLabel: true,
+        }));
+        expect(lastFrame()).toContain("62%");
+    });
+    it("clamps value above 1 to 100%", () => {
+        const { lastFrame } = render(React.createElement(ProgressBar, {
+            value: 1.5,
+            width: 5,
+            showLabel: true,
+        }));
+        expect(lastFrame()).toContain("100%");
+    });
+    it("clamps value below 0 to 0%", () => {
+        const { lastFrame } = render(React.createElement(ProgressBar, {
+            value: -0.5,
+            width: 5,
+            showLabel: true,
+        }));
+        expect(lastFrame()).toContain("0%");
+    });
+    it("BLOCKS array has 9 sub-character elements", () => {
+        expect(BLOCKS).toHaveLength(9);
+        expect(BLOCKS[0]).toBe(" ");
+        expect(BLOCKS[8]).toBe("█");
+    });
+});
+// ── GradeBadge ───────────────────────────────────────────────────
+describe("GradeBadge", () => {
+    it("renders grade letter", () => {
+        const { lastFrame } = render(React.createElement(GradeBadge, { grade: "A" }));
+        expect(lastFrame()).toContain("A");
+    });
+    it("renders grade with score when provided", () => {
+        const { lastFrame } = render(React.createElement(GradeBadge, { grade: "C+", score: 62 }));
+        const frame = lastFrame() ?? "";
+        expect(frame).toContain("C+");
+        expect(frame).toContain("62/100");
+    });
+    it("renders without score when not provided", () => {
+        const { lastFrame } = render(React.createElement(GradeBadge, { grade: "B+" }));
+        expect(lastFrame()).toContain("B+");
+        expect(lastFrame()).not.toContain("/100");
+    });
+});
+// ── StepLine ─────────────────────────────────────────────────────
+describe("StepLine", () => {
+    it("renders done status with check icon", () => {
+        const { lastFrame } = render(React.createElement(StepLine, {
+            label: "Authenticated",
+            value: "Org",
+            status: "done",
+        }));
+        const frame = lastFrame() ?? "";
+        expect(frame).toContain("✓");
+        expect(frame).toContain("Authenticated");
+        expect(frame).toContain("Org");
+    });
+    it("renders active status with filled circle", () => {
+        const { lastFrame } = render(React.createElement(StepLine, {
+            label: "Loading",
+            status: "active",
+        }));
+        expect(lastFrame()).toContain("●");
+        expect(lastFrame()).toContain("Loading");
+    });
+    it("renders error status with cross icon", () => {
+        const { lastFrame } = render(React.createElement(StepLine, {
+            label: "Failed",
+            status: "error",
+        }));
+        expect(lastFrame()).toContain("✗");
+    });
+    it("renders pending status with empty circle", () => {
+        const { lastFrame } = render(React.createElement(StepLine, {
+            label: "Waiting",
+            status: "pending",
+        }));
+        expect(lastFrame()).toContain("○");
+    });
+});
+// ── HealthCard ───────────────────────────────────────────────────
+describe("HealthCard", () => {
+    const baseHealth = {
+        grade: "C+",
+        totalEntities: 2341,
+        totalEdges: 1892,
+        totalRules: 12,
+        deadFunctionCount: 23,
+        highRiskEntities: [
+            {
+                name: "processPayment",
+                kind: "function",
+                file_path: "src/billing.ts",
+                fan_in: 14,
+                fan_out: 8,
+            },
+        ],
+        score: 62,
+    };
+    it("renders grade and score in full mode", () => {
+        const { lastFrame } = render(React.createElement(HealthCard, { health: baseHealth }));
+        const frame = lastFrame() ?? "";
+        expect(frame).toContain("C+");
+        expect(frame).toContain("62/100");
+    });
+    it("renders dead function warning", () => {
+        const { lastFrame } = render(React.createElement(HealthCard, { health: baseHealth }));
+        expect(lastFrame()).toContain("23 dead functions");
+    });
+    it("renders chokepoint warning with fan counts", () => {
+        const { lastFrame } = render(React.createElement(HealthCard, { health: baseHealth }));
+        const frame = lastFrame() ?? "";
+        expect(frame).toContain("processPayment");
+        expect(frame).toContain("14 callers");
+        expect(frame).toContain("8 callees");
+        expect(frame).toContain("chokepoint");
+    });
+    it("renders compact mode with entity/edge counts", () => {
+        const { lastFrame } = render(React.createElement(HealthCard, { health: baseHealth, compact: true }));
+        const frame = lastFrame() ?? "";
+        expect(frame).toContain("C+");
+        expect(frame).toContain("2341 entities");
+        expect(frame).toContain("1892 edges");
+    });
+    it("omits dead function line when count is 0", () => {
+        const healthy = { ...baseHealth, deadFunctionCount: 0 };
+        const { lastFrame } = render(React.createElement(HealthCard, { health: healthy }));
+        expect(lastFrame()).not.toContain("dead function");
+    });
+});
+// ── DriftSummary ─────────────────────────────────────────────────
+describe("DriftSummary", () => {
+    it("renders zero drift message", () => {
+        const { lastFrame } = render(React.createElement(DriftSummary, {
+            drift: { modified: 0, added: 0, deleted: 0 },
+        }));
+        expect(lastFrame()).toContain("No drift detected");
+    });
+    it("renders modified count", () => {
+        const { lastFrame } = render(React.createElement(DriftSummary, {
+            drift: { modified: 5, added: 0, deleted: 0 },
+        }));
+        expect(lastFrame()).toContain("5 modified");
+    });
+    it("renders all drift types", () => {
+        const { lastFrame } = render(React.createElement(DriftSummary, {
+            drift: { modified: 3, added: 2, deleted: 1 },
+        }));
+        const frame = lastFrame() ?? "";
+        expect(frame).toContain("6 drifted entities");
+        expect(frame).toContain("3 modified");
+        expect(frame).toContain("2 added");
+        expect(frame).toContain("1 deleted");
+    });
+    it("uses singular 'entity' for count of 1", () => {
+        const { lastFrame } = render(React.createElement(DriftSummary, {
+            drift: { modified: 1, added: 0, deleted: 0 },
+        }));
+        expect(lastFrame()).toContain("1 drifted entity");
+    });
+});
+// ── ViolationList ────────────────────────────────────────────────
+describe("ViolationList", () => {
+    it("renders no-violations message when empty", () => {
+        const { lastFrame } = render(React.createElement(ViolationList, { violations: [] }));
+        expect(lastFrame()).toContain("No violations");
+    });
+    it("renders error violation with cross icon", () => {
+        const { lastFrame } = render(React.createElement(ViolationList, {
+            violations: [
+                { message: "Missing return type", severity: "error" },
+            ],
+        }));
+        const frame = lastFrame() ?? "";
+        expect(frame).toContain("✗");
+        expect(frame).toContain("Missing return type");
+    });
+    it("renders warning violation with warning icon", () => {
+        const { lastFrame } = render(React.createElement(ViolationList, {
+            violations: [
+                { message: "Unused import", severity: "warning" },
+            ],
+        }));
+        const frame = lastFrame() ?? "";
+        expect(frame).toContain("⚠");
+        expect(frame).toContain("Unused import");
+    });
+    it("renders file path when provided", () => {
+        const { lastFrame } = render(React.createElement(ViolationList, {
+            violations: [
+                {
+                    message: "Bad naming",
+                    severity: "info",
+                    file: "src/foo.ts",
+                },
+            ],
+        }));
+        expect(lastFrame()).toContain("src/foo.ts");
+    });
+    it("renders suggestion when provided", () => {
+        const { lastFrame } = render(React.createElement(ViolationList, {
+            violations: [
+                {
+                    message: "Unused var",
+                    severity: "warning",
+                    suggestion: "Remove or prefix with _",
+                },
+            ],
+        }));
+        expect(lastFrame()).toContain("Remove or prefix with _");
+    });
+    it("renders violation count in title", () => {
+        const { lastFrame } = render(React.createElement(ViolationList, {
+            violations: [
+                { message: "Issue 1", severity: "error" },
+                { message: "Issue 2", severity: "warning" },
+            ],
+            title: "Violations",
+        }));
+        expect(lastFrame()).toContain("2 violations");
+    });
+});
+// ── SessionSummaryCard ───────────────────────────────────────────
+describe("SessionSummaryCard", () => {
+    it("renders tool call counts in full summary", () => {
+        const stats = createSessionStats();
+        stats.toolCallsLocal = 15;
+        const { lastFrame } = render(React.createElement(SessionSummaryCard, { stats }));
+        const frame = lastFrame() ?? "";
+        expect(frame).toContain("15 (all local)");
+    });
+    it("renders local rate with progress bar", () => {
+        const stats = createSessionStats();
+        stats.toolCallsLocal = 16;
+        const { lastFrame } = render(React.createElement(SessionSummaryCard, { stats }));
+        expect(lastFrame()).toContain("100%");
+        expect(lastFrame()).toContain("Local rate");
+    });
+    it("renders session section header with duration", () => {
+        const stats = createSessionStats();
+        stats.toolCallsLocal = 20;
+        const { lastFrame } = render(React.createElement(SessionSummaryCard, { stats }));
+        expect(lastFrame()).toContain("unerr session");
+    });
+    it("renders specific caught event labels", () => {
+        const stats = createSessionStats();
+        stats.toolCallsLocal = 20;
+        stats.events.conventionViolationsCaught = 3;
+        stats.events.chokepointWarningsIssued = 2;
+        const { lastFrame } = render(React.createElement(SessionSummaryCard, { stats }));
+        const frame = lastFrame() ?? "";
+        expect(frame).toContain("Caught:");
+        expect(frame).toContain("3 convention violations before commit");
+        expect(frame).toContain("2 chokepoint modifications warned");
+    });
+    it("renders one-liner for short sessions (≤10 tool calls)", () => {
+        const stats = createSessionStats();
+        stats.toolCallsLocal = 5;
+        const { lastFrame } = render(React.createElement(SessionSummaryCard, { stats }));
+        const frame = lastFrame() ?? "";
+        expect(frame).toContain("5 tool calls");
+        // Should NOT show full section header
+        expect(frame).not.toContain("Tool calls");
+    });
+    it("renders nothing when zero tool calls", () => {
+        const stats = createSessionStats();
+        const { lastFrame } = render(React.createElement(SessionSummaryCard, { stats }));
+        expect(lastFrame()).toBe("");
+    });
+    it("renders deep link when provided", () => {
+        const stats = createSessionStats();
+        stats.toolCallsLocal = 20;
+        const { lastFrame } = render(React.createElement(SessionSummaryCard, {
+            stats,
+            deepLink: "https://app.unerr.dev/r/repo_123?utm_source=cli_session",
+        }));
+        expect(lastFrame()).toContain("https://app.unerr.dev/r/repo_123");
+    });
+    it("renders cumulative this-week stats", () => {
+        const stats = createSessionStats();
+        stats.toolCallsLocal = 20;
+        const cumulative = {
+            totalTokensSaved: 100000,
+            totalDollarsSaved: 5.6,
+            totalSessions: 4,
+            weekStart: "2026-04-06",
+            violationsCaughtAllTime: 12,
+            chokepointWarningsAllTime: 3,
+        };
+        const { lastFrame } = render(React.createElement(SessionSummaryCard, { stats, cumulative }));
+        const frame = lastFrame() ?? "";
+        expect(frame).toContain("This week:");
+        expect(frame).toContain("4 sessions");
+        expect(frame).toContain("$5.60");
+    });
+    it("omits caught section when no events", () => {
+        const stats = createSessionStats();
+        stats.toolCallsLocal = 20;
+        const { lastFrame } = render(React.createElement(SessionSummaryCard, { stats }));
+        expect(lastFrame()).not.toContain("Caught:");
+    });
+    it("renders token savings", () => {
+        const stats = createSessionStats();
+        stats.toolCallsLocal = 20;
+        stats.estimatedTokensSaved = 64000;
+        const { lastFrame } = render(React.createElement(SessionSummaryCard, { stats }));
+        expect(lastFrame()).toContain("64.0k tokens");
+    });
+});
+// ── InkSpinner ───────────────────────────────────────────────────
+describe("InkSpinner", () => {
+    it("renders label text", () => {
+        const { lastFrame } = render(React.createElement(InkSpinner, { label: "Loading graph..." }));
+        expect(lastFrame()).toContain("Loading graph...");
+    });
+    it("renders a spinner frame character", () => {
+        const { lastFrame } = render(React.createElement(InkSpinner, { label: "test" }));
+        const frame = lastFrame() ?? "";
+        // Should contain one of the braille spinner chars
+        expect(frame.match(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/)).toBeTruthy();
+    });
+});
+// ── ConfirmPrompt ────────────────────────────────────────────────
+describe("ConfirmPrompt", () => {
+    it("renders message and default-yes hint", () => {
+        const { lastFrame } = render(React.createElement(ConfirmPrompt, {
+            message: "Delete this?",
+            onConfirm: () => { },
+            defaultYes: true,
+        }));
+        const frame = lastFrame() ?? "";
+        expect(frame).toContain("Delete this?");
+        expect(frame).toContain("[Y/n]");
+    });
+    it("renders default-no hint", () => {
+        const { lastFrame } = render(React.createElement(ConfirmPrompt, {
+            message: "Proceed?",
+            onConfirm: () => { },
+            defaultYes: false,
+        }));
+        expect(lastFrame()).toContain("[y/N]");
+    });
+});

package/dist/__tests__/compression-log.test.js

@@ -0,0 +1,174 @@
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import os from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { appendCompressionLog, appendFileReadLog, readRecentCompressionLogs, readRecentFileReadLogs, } from "../proxy/shell-compression-log.js";
+import { closeMetricsStore } from "../tracking/metrics-store.js";
+describe("compression-log", () => {
+    let tmpDir;
+    let unerrDir;
+    let dbPath;
+    beforeEach(() => {
+        tmpDir = join(os.tmpdir(), `unerr-complog-test-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
+        mkdirSync(tmpDir, { recursive: true });
+        unerrDir = join(tmpDir, ".unerr");
+        dbPath = join(unerrDir, "metrics.db");
+    });
+    afterEach(() => {
+        closeMetricsStore(unerrDir);
+        rmSync(tmpDir, { recursive: true, force: true });
+    });
+    function makeEntry(overrides) {
+        return {
+            ts: new Date().toISOString(),
+            command: "ps aux",
+            category: "tabular",
+            confidence: 0.85,
+            rawBytes: 1000,
+            compressedBytes: 300,
+            savedPct: 70,
+            omniFallback: false,
+            ...overrides,
+        };
+    }
+    it("creates metrics.db and inserts compression rows", () => {
+        appendCompressionLog(tmpDir, makeEntry());
+        expect(existsSync(dbPath)).toBe(true);
+        const entries = readRecentCompressionLogs(tmpDir, 10);
+        expect(entries).toHaveLength(1);
+        expect(entries[0].command).toBe("ps aux");
+        expect(entries[0].category).toBe("tabular");
+        expect(entries[0].savedPct).toBe(70);
+    });
+    it("records entries with 0% savings (passthrough)", () => {
+        appendCompressionLog(tmpDir, makeEntry({ savedPct: 0, compressedBytes: 1000 }));
+        const entries = readRecentCompressionLogs(tmpDir, 10);
+        expect(entries).toHaveLength(1);
+        expect(entries[0].savedPct).toBe(0);
+    });
+    it("readRecentCompressionLogs returns entries in reverse chronological order", () => {
+        appendCompressionLog(tmpDir, makeEntry({ command: "first", ts: "2024-01-01T00:00:00Z" }));
+        appendCompressionLog(tmpDir, makeEntry({ command: "second", ts: "2024-01-01T00:01:00Z" }));
+        appendCompressionLog(tmpDir, makeEntry({ command: "third", ts: "2024-01-01T00:02:00Z" }));
+        const entries = readRecentCompressionLogs(tmpDir, 10);
+        expect(entries).toHaveLength(3);
+        expect(entries[0].command).toBe("third");
+        expect(entries[2].command).toBe("first");
+    });
+    it("readRecentCompressionLogs respects limit", () => {
+        for (let i = 0; i < 20; i++) {
+            appendCompressionLog(tmpDir, makeEntry({ command: `cmd-${i}` }));
+        }
+        const entries = readRecentCompressionLogs(tmpDir, 5);
+        expect(entries).toHaveLength(5);
+        expect(entries[0].command).toBe("cmd-19");
+    });
+    it("returns empty array when no log file exists", () => {
+        const entries = readRecentCompressionLogs(tmpDir, 10);
+        expect(entries).toHaveLength(0);
+    });
+    it("includes teeFile when present", () => {
+        appendCompressionLog(tmpDir, makeEntry({ teeFile: "/tmp/shell-tee-123.txt" }));
+        const entries = readRecentCompressionLogs(tmpDir, 1);
+        expect(entries[0].teeFile).toBe("/tmp/shell-tee-123.txt");
+    });
+    it("handles high-volume writes (replaces legacy line rotation)", () => {
+        // SQLite doesn't trim rows — it indexes them. Verify 1050 inserts
+        // round-trip and the most recent entry surfaces first.
+        for (let i = 0; i < 1050; i++) {
+            appendCompressionLog(tmpDir, makeEntry({ command: `cmd-${i}` }));
+        }
+        const entries = readRecentCompressionLogs(tmpDir, 5);
+        expect(entries).toHaveLength(5);
+        expect(entries[0].command).toBe("cmd-1049");
+        expect(entries[4].command).toBe("cmd-1045");
+    });
+});
+describe("file-read-log", () => {
+    let tmpDir;
+    let unerrDir;
+    let dbPath;
+    beforeEach(() => {
+        tmpDir = join(os.tmpdir(), `unerr-filelog-test-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
+        mkdirSync(tmpDir, { recursive: true });
+        unerrDir = join(tmpDir, ".unerr");
+        dbPath = join(unerrDir, "metrics.db");
+    });
+    afterEach(() => {
+        closeMetricsStore(unerrDir);
+        rmSync(tmpDir, { recursive: true, force: true });
+    });
+    function makeFileEntry(overrides) {
+        return {
+            ts: new Date().toISOString(),
+            file: "src/main.ts",
+            mode: "entity",
+            totalLines: 500,
+            returnedLines: 45,
+            savedPct: 91,
+            ...overrides,
+        };
+    }
+    it("creates metrics.db and inserts file-read rows", () => {
+        appendFileReadLog(tmpDir, makeFileEntry());
+        expect(existsSync(dbPath)).toBe(true);
+        const entries = readRecentFileReadLogs(tmpDir, 10);
+        expect(entries).toHaveLength(1);
+        expect(entries[0].file).toBe("src/main.ts");
+        expect(entries[0].mode).toBe("entity");
+        expect(entries[0].savedPct).toBe(91);
+    });
+    it("entry contains all fields", () => {
+        appendFileReadLog(tmpDir, makeFileEntry({
+            entity: "MyClass",
+            tokenEstimate: 1200,
+        }));
+        const entries = readRecentFileReadLogs(tmpDir, 1);
+        expect(entries).toHaveLength(1);
+        const e = entries[0];
+        expect(e.file).toBe("src/main.ts");
+        expect(e.mode).toBe("entity");
+        expect(e.totalLines).toBe(500);
+        expect(e.returnedLines).toBe(45);
+        expect(e.savedPct).toBe(91);
+        expect(e.entity).toBe("MyClass");
+        expect(e.tokenEstimate).toBe(1200);
+    });
+    it("readRecentFileReadLogs returns entries in reverse chronological order", () => {
+        appendFileReadLog(tmpDir, makeFileEntry({ file: "a.ts", ts: "2024-01-01T00:00:00Z" }));
+        appendFileReadLog(tmpDir, makeFileEntry({ file: "b.ts", ts: "2024-01-01T00:01:00Z" }));
+        appendFileReadLog(tmpDir, makeFileEntry({ file: "c.ts", ts: "2024-01-01T00:02:00Z" }));
+        const entries = readRecentFileReadLogs(tmpDir, 10);
+        expect(entries).toHaveLength(3);
+        expect(entries[0].file).toBe("c.ts");
+        expect(entries[2].file).toBe("a.ts");
+    });
+    it("readRecentFileReadLogs respects limit", () => {
+        for (let i = 0; i < 15; i++) {
+            appendFileReadLog(tmpDir, makeFileEntry({ file: `file-${i}.ts` }));
+        }
+        const entries = readRecentFileReadLogs(tmpDir, 5);
+        expect(entries).toHaveLength(5);
+        expect(entries[0].file).toBe("file-14.ts");
+    });
+    it("returns empty array when no log file exists", () => {
+        const entries = readRecentFileReadLogs(tmpDir, 10);
+        expect(entries).toHaveLength(0);
+    });
+    it("supports all file-read modes", () => {
+        const modes = [
+            "outline",
+            "entity",
+            "slice",
+            "full",
+            "log_tail",
+            "gated",
+        ];
+        for (const mode of modes) {
+            appendFileReadLog(tmpDir, makeFileEntry({ mode }));
+        }
+        const entries = readRecentFileReadLogs(tmpDir, 10);
+        expect(entries).toHaveLength(6);
+        expect(entries.map((e) => e.mode).sort()).toEqual([...modes].sort());
+    });
+});

package/dist/__tests__/compression-quality-monitor.test.js

@@ -0,0 +1,40 @@
+/**
+ * Layer 6 Sprint FE-E — Layer 6 tier escalation on repeated retries.
+ */
+import { describe, expect, it } from "vitest";
+import { createCompressionQualityMonitor } from "../proxy/compression-quality-monitor.js";
+describe("CompressionQualityMonitor Layer 6 tiers (FE-E)", () => {
+    it("starts at columnar tier", () => {
+        const m = createCompressionQualityMonitor();
+        expect(m.getLayer6Tier("get_callers")).toBe("columnar");
+        expect(m.getLayer6RetryCount("get_callers")).toBe(0);
+    });
+    it("escalates to minified after 3 retries", () => {
+        const m = createCompressionQualityMonitor();
+        m.recordLayer6Retry("search_code");
+        m.recordLayer6Retry("search_code");
+        expect(m.getLayer6Tier("search_code")).toBe("columnar");
+        m.recordLayer6Retry("search_code");
+        expect(m.getLayer6Tier("search_code")).toBe("minified");
+        expect(m.getLayer6RetryCount("search_code")).toBe(3);
+    });
+    it("escalates to expanded after 6 retries", () => {
+        const m = createCompressionQualityMonitor();
+        for (let i = 0; i < 6; i++)
+            m.recordLayer6Retry("get_function");
+        expect(m.getLayer6Tier("get_function")).toBe("expanded");
+    });
+    it("tracks layer6 content types for retention", () => {
+        const m = createCompressionQualityMonitor();
+        expect(m.getRetention("layer6_columnar")).toBeGreaterThanOrEqual(0.4);
+    });
+    it("FE-F: shell category retention defaults exist", () => {
+        const m = createCompressionQualityMonitor();
+        expect(m.getRetention("shell_diff")).toBeGreaterThanOrEqual(0.4);
+        expect(m.getRetention("shell_structured")).toBeGreaterThanOrEqual(0.4);
+        expect(m.getRetention("shell_error_diagnostic")).toBeGreaterThanOrEqual(0.4);
+        m.recordCompression("s1", "shell_tabular", 0.5);
+        m.recordAgentAction("e", true, false);
+        expect(m.getSignalCount()).toBeGreaterThan(0);
+    });
+});