@unerr-ai/unerr 0.1.0 → 0.1.1

package/dist/__tests__/layer3-sprint-q.test.js

@@ -0,0 +1,160 @@
+/**
+ * Layer 3 Sprint Q: Output Compression & Budget Enforcement tests.
+ *
+ * Tests: compression stats, quality monitor, skills, performance.
+ */
+import { describe, expect, it } from "vitest";
+import { enforceBudget } from "../proxy/budget-enforcer.js";
+import { createCompressionQualityMonitor, } from "../proxy/compression-quality-monitor.js";
+import { createCompressionStatsCollector } from "../proxy/compression-stats.js";
+import { compressOutput, } from "../proxy/output-compressor.js";
+import { LOCAL_SKILLS, getSkill, getSkillsContext, } from "../skills/local-pack.js";
+describe("Compression Stats (Q.6)", () => {
+    it("records compression events", () => {
+        const stats = createCompressionStatsCollector();
+        const id = stats.record({
+            contentType: "git_diff",
+            originalTokens: 5000,
+            compressedTokens: 1500,
+            sectionsPreserved: 3,
+            sectionsOmitted: 7,
+            annotationsAdded: 2,
+            durationMs: 3.5,
+        });
+        expect(id).toBeTruthy();
+        const event = stats.getEvent(id);
+        expect(event).not.toBeNull();
+        expect(event?.originalTokens).toBe(5000);
+        expect(event?.compressedTokens).toBe(1500);
+    });
+    it("computes session-level stats", () => {
+        const stats = createCompressionStatsCollector();
+        stats.record({
+            contentType: "git_diff",
+            originalTokens: 5000,
+            compressedTokens: 1500,
+            sectionsPreserved: 3,
+            sectionsOmitted: 7,
+            annotationsAdded: 2,
+            durationMs: 3,
+        });
+        stats.record({
+            contentType: "test_output",
+            originalTokens: 3000,
+            compressedTokens: 1000,
+            sectionsPreserved: 2,
+            sectionsOmitted: 5,
+            annotationsAdded: 0,
+            durationMs: 2,
+        });
+        const session = stats.getSessionStats();
+        expect(session.totalEvents).toBe(2);
+        expect(session.totalOriginalTokens).toBe(8000);
+        expect(session.totalCompressedTokens).toBe(2500);
+        expect(session.totalSaved).toBe(5500);
+        expect(session.avgCompressionRatio).toBeCloseTo(0.69, 1);
+        expect(session.byContentType.git_diff?.count).toBe(1);
+    });
+    it("returns recent events", () => {
+        const stats = createCompressionStatsCollector();
+        for (let i = 0; i < 5; i++) {
+            stats.record({
+                contentType: "generic",
+                originalTokens: 100,
+                compressedTokens: 50,
+                sectionsPreserved: 1,
+                sectionsOmitted: 1,
+                annotationsAdded: 0,
+                durationMs: 1,
+            });
+        }
+        expect(stats.getRecentEvents(3)).toHaveLength(3);
+    });
+});
+describe("Compression Quality Monitor (Q.13)", () => {
+    it("starts with default retention values", () => {
+        const monitor = createCompressionQualityMonitor();
+        expect(monitor.getRetention("git_diff")).toBeGreaterThanOrEqual(0.4);
+        expect(monitor.getRetention("test_output")).toBeGreaterThanOrEqual(0.4);
+    });
+    it("records compression events without error", () => {
+        const monitor = createCompressionQualityMonitor();
+        monitor.recordCompression("comp-1", "git_diff", 0.7);
+        expect(monitor.getSignalCount()).toBe(0);
+    });
+    it("detects over-compression when agent retries", () => {
+        const monitor = createCompressionQualityMonitor();
+        monitor.recordCompression("comp-1", "git_diff", 0.8);
+        monitor.recordAgentAction("entity-x", true, false);
+        expect(monitor.getSignalCount()).toBeGreaterThan(0);
+    });
+    it("increases retention after 3+ over-compression signals", () => {
+        const monitor = createCompressionQualityMonitor();
+        const initialRetention = monitor.getRetention("git_diff");
+        for (let i = 0; i < 4; i++) {
+            monitor.recordCompression(`comp-${i}`, "git_diff", 0.8);
+            monitor.recordAgentAction("entity-x", true, false);
+        }
+        const newRetention = monitor.getRetention("git_diff");
+        expect(newRetention).toBeGreaterThanOrEqual(initialRetention);
+    });
+    it("never drops below 40% hard floor", () => {
+        const monitor = createCompressionQualityMonitor();
+        const retention = monitor.getRetention("generic");
+        expect(retention).toBeGreaterThanOrEqual(0.4);
+    });
+    it("provides adaptive config with confidence", () => {
+        const monitor = createCompressionQualityMonitor();
+        const config = monitor.getAdaptiveConfig();
+        expect(config.minRetention).toBeDefined();
+        expect(config.adaptedRetention).toBeDefined();
+        expect(config.confidence).toBeGreaterThanOrEqual(0);
+    });
+});
+describe("Skills Pack (Q.11-Q.12)", () => {
+    it("has token-efficient skill", () => {
+        const skill = getSkill("token-efficient");
+        expect(skill).not.toBeNull();
+        expect(skill?.category).toBe("behavior");
+        expect(skill?.instructions).toContain("bullet points");
+    });
+    it("has graph-first navigation skill", () => {
+        const skill = getSkill("graph-first-navigation");
+        expect(skill).not.toBeNull();
+        expect(skill?.category).toBe("navigation");
+        expect(skill?.instructions).toContain("get_references");
+        expect(skill?.instructions).toContain("direction:callees");
+        expect(skill?.instructions).toContain("search_code");
+    });
+    it("getSkillsContext returns always-on skills", () => {
+        const context = getSkillsContext();
+        const skills = context["dev.unerr/active_skills"];
+        // Only always-on skills are injected into active context
+        expect(skills.length).toBe(5);
+        expect(skills.map((s) => s.id)).toContain("token-efficient");
+        expect(skills.map((s) => s.id)).toContain("graph-first-navigation");
+        expect(skills.map((s) => s.id)).toContain("understand-before-modify");
+        expect(skills.map((s) => s.id)).toContain("file-read-protocol");
+        expect(skills.map((s) => s.id)).toContain("turn-discipline");
+    });
+    it("LOCAL_SKILLS has correct count", () => {
+        expect(LOCAL_SKILLS).toHaveLength(12);
+    });
+});
+describe("Compression + Budget Pipeline (Q.7)", () => {
+    it("compresses first, then enforces budget", () => {
+        const largeInput = Array.from({ length: 200 }, (_, i) => `Line ${i}: some content that takes up space in the output`).join("\n");
+        const compressed = compressOutput(largeInput, { tokenBudget: 500 });
+        const enforced = enforceBudget(compressed.output, 300);
+        expect(enforced.deliveredTokens).toBeLessThanOrEqual(enforced.originalTokens);
+    });
+});
+describe("Performance (Q.10)", () => {
+    it("100KB input compressed in <10ms", () => {
+        const bigInput = "x".repeat(100 * 1024);
+        const start = performance.now();
+        compressOutput(bigInput, { tokenBudget: 2000 });
+        const elapsed = performance.now() - start;
+        expect(elapsed).toBeLessThan(10);
+    });
+});

package/dist/__tests__/layer3-sprint-r.test.js

@@ -0,0 +1,91 @@
+/**
+ * Layer 3 Sprint R: CLI Hooks & Auto-Configuration tests.
+ */
+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 { installClaudeHook, isClaudeHookInstalled, removeClaudeHook, } from "../config/hook-installer.js";
+import { isConfigured, removeMcpConfig, writeMcpConfig, } from "../config/mcp-config-writer.js";
+let tempDir;
+beforeEach(() => {
+    tempDir = join(tmpdir(), `unerr-r-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(tempDir, { recursive: true });
+});
+afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+});
+describe("MCP Config Writer (R.3 + R.7)", () => {
+    it("creates config for Cursor", () => {
+        const result = writeMcpConfig(tempDir, "cursor");
+        expect(result.action).toBe("created");
+        expect(existsSync(result.path)).toBe(true);
+        const config = JSON.parse(readFileSync(result.path, "utf-8"));
+        expect(config.mcpServers.unerr).toBeDefined();
+        expect(config.mcpServers.unerr.command).toBe("unerr");
+    });
+    it("creates config for Claude Code", () => {
+        const result = writeMcpConfig(tempDir, "claude-code");
+        expect(result.action).toBe("created");
+        expect(result.path).toContain(".mcp.json");
+    });
+    it("creates config for VS Code", () => {
+        const result = writeMcpConfig(tempDir, "vscode");
+        expect(result.action).toBe("created");
+        expect(result.path).toContain(".vscode");
+    });
+    it("is idempotent (skip on second run)", () => {
+        writeMcpConfig(tempDir, "cursor");
+        const result = writeMcpConfig(tempDir, "cursor");
+        expect(result.action).toBe("skipped");
+    });
+    it("merges into existing config without overwriting", () => {
+        const configPath = join(tempDir, ".cursor", "mcp.json");
+        mkdirSync(join(tempDir, ".cursor"), { recursive: true });
+        writeFileSync(configPath, JSON.stringify({
+            mcpServers: { "other-tool": { command: "other", args: [] } },
+        }), "utf-8");
+        const result = writeMcpConfig(tempDir, "cursor");
+        expect(result.action).toBe("updated");
+        const config = JSON.parse(readFileSync(configPath, "utf-8"));
+        expect(config.mcpServers["other-tool"]).toBeDefined();
+        expect(config.mcpServers.unerr).toBeDefined();
+    });
+    it("isConfigured returns correct state", () => {
+        expect(isConfigured(tempDir, "cursor")).toBe(false);
+        writeMcpConfig(tempDir, "cursor");
+        expect(isConfigured(tempDir, "cursor")).toBe(true);
+    });
+    it("removeMcpConfig removes unerr entry", () => {
+        writeMcpConfig(tempDir, "cursor");
+        const removed = removeMcpConfig(tempDir, "cursor");
+        expect(removed).toBe(true);
+        expect(isConfigured(tempDir, "cursor")).toBe(false);
+    });
+});
+describe("Hook Installer (R.4)", () => {
+    it("installs Claude hook with correct permissions", () => {
+        const result = installClaudeHook(tempDir);
+        expect(result.action).toBe("installed");
+        expect(existsSync(result.path)).toBe(true);
+        const content = readFileSync(result.path, "utf-8");
+        expect(content).toContain("#!/bin/bash");
+        expect(content).toContain("compress-output");
+    });
+    it("reports already_exists on second install", () => {
+        installClaudeHook(tempDir);
+        const result = installClaudeHook(tempDir);
+        expect(result.action).toBe("already_exists");
+    });
+    it("isClaudeHookInstalled returns correct state", () => {
+        expect(isClaudeHookInstalled(tempDir)).toBe(false);
+        installClaudeHook(tempDir);
+        expect(isClaudeHookInstalled(tempDir)).toBe(true);
+    });
+    it("removeClaudeHook removes the hook", () => {
+        installClaudeHook(tempDir);
+        const removed = removeClaudeHook(tempDir);
+        expect(removed).toBe(true);
+        expect(isClaudeHookInstalled(tempDir)).toBe(false);
+    });
+});

package/dist/__tests__/layer3-sprint-s.test.js

@@ -0,0 +1,183 @@
+/**
+ * Layer 3 Sprint S: Proactive Injection & Session Intelligence tests.
+ */
+import { describe, expect, it } from "vitest";
+import { suggestApproach, suggestApproachesForFile, } from "../intelligence/approach-suggester.js";
+import { createSessionContext } from "../intelligence/exploration-pattern-tracker.js";
+import { assembleFileIntelligence } from "../intelligence/file-intelligence.js";
+import { createSubgraphCache } from "../intelligence/subgraph-cache.js";
+describe("File Intelligence (S.1)", () => {
+    it("assembles intelligence for a file", () => {
+        const entities = [
+            {
+                key: "k1",
+                name: "processPayment",
+                kind: "function",
+                file_path: "src/pay.ts",
+                risk_level: "high",
+                fan_in: 25,
+                community: 1,
+            },
+            {
+                key: "k2",
+                name: "validateCard",
+                kind: "function",
+                file_path: "src/pay.ts",
+                risk_level: "normal",
+                fan_in: 5,
+                community: 1,
+            },
+            {
+                key: "k3",
+                name: "logError",
+                kind: "function",
+                file_path: "src/utils.ts",
+                risk_level: "normal",
+                fan_in: 2,
+                community: 0,
+            },
+        ];
+        const intel = assembleFileIntelligence("src/pay.ts", entities);
+        expect(intel.entityCount).toBe(2);
+        expect(intel.topRiskEntities).toHaveLength(1);
+        expect(intel.topRiskEntities[0]?.name).toBe("processPayment");
+        expect(intel.totalBlastRadius).toBe(30);
+        expect(intel.dominantCommunity).toBe(1);
+        expect(intel.fileRiskLevel).toBe("high");
+    });
+    it("handles file with no entities", () => {
+        const intel = assembleFileIntelligence("empty.ts", []);
+        expect(intel.entityCount).toBe(0);
+        expect(intel.fileRiskLevel).toBe("normal");
+        expect(intel.totalBlastRadius).toBe(0);
+    });
+    it("ranks entities by fan_in", () => {
+        const entities = [
+            { key: "a", name: "low", kind: "function", file_path: "f.ts", fan_in: 2 },
+            {
+                key: "b",
+                name: "high",
+                kind: "function",
+                file_path: "f.ts",
+                fan_in: 50,
+            },
+            {
+                key: "c",
+                name: "mid",
+                kind: "function",
+                file_path: "f.ts",
+                fan_in: 15,
+            },
+        ];
+        const intel = assembleFileIntelligence("f.ts", entities);
+        expect(intel.entities[0]?.name).toBe("high");
+        expect(intel.entities[1]?.name).toBe("mid");
+    });
+});
+describe("Subgraph Cache (S.3)", () => {
+    it("warms directory on first access", () => {
+        const cache = createSubgraphCache();
+        cache.warmDirectory("src/auth", ["src/auth/login.ts", "src/auth/logout.ts"], (f) => ({ file: f }));
+        expect(cache.has("src/auth/login.ts")).toBe(true);
+        expect(cache.has("src/auth/logout.ts")).toBe(true);
+        expect(cache.size()).toBe(2);
+    });
+    it("skips already-warmed directories", () => {
+        const cache = createSubgraphCache();
+        let loadCount = 0;
+        const loader = (f) => {
+            loadCount++;
+            return f;
+        };
+        cache.warmDirectory("src/auth", ["src/auth/a.ts"], loader);
+        cache.warmDirectory("src/auth", ["src/auth/b.ts"], loader);
+        expect(loadCount).toBe(1);
+    });
+    it("invalidates directory entries", () => {
+        const cache = createSubgraphCache();
+        cache.warmDirectory("src/auth", ["src/auth/a.ts", "src/auth/b.ts"], (f) => f);
+        cache.invalidateDirectory("src/auth");
+        expect(cache.has("src/auth/a.ts")).toBe(false);
+    });
+    it("respects TTL", () => {
+        const cache = createSubgraphCache();
+        cache.warmDirectory("src/x", ["src/x/a.ts"], (f) => f);
+        expect(cache.get("src/x/a.ts")).not.toBeNull();
+    });
+});
+describe("Approach Suggestions (S.4)", () => {
+    it("suggests overload for critical fan_in", () => {
+        const suggestion = suggestApproach("k1", "processPayment", "critical", 55, "function");
+        expect(suggestion).not.toBeNull();
+        expect(suggestion?.pattern).toBe("overload-adapter");
+        expect(suggestion?.suggestion).toContain("55 callers");
+    });
+    it("suggests feature flag for high fan_in", () => {
+        const suggestion = suggestApproach("k2", "validateInput", "high", 35, "function");
+        expect(suggestion).not.toBeNull();
+        expect(suggestion?.pattern).toBe("feature-flag");
+    });
+    it("suggests test-first for high risk without extreme fan_in", () => {
+        const suggestion = suggestApproach("k3", "helperFn", "high", 10, "function");
+        expect(suggestion).not.toBeNull();
+        expect(suggestion?.pattern).toBe("test-first");
+    });
+    it("returns null for low-risk entities", () => {
+        expect(suggestApproach("k4", "simpleUtil", "normal", 3, "function")).toBeNull();
+    });
+    it("generates suggestions for file", () => {
+        const entities = [
+            {
+                key: "k1",
+                name: "hub",
+                risk_level: "critical",
+                fan_in: 60,
+                kind: "function",
+            },
+            {
+                key: "k2",
+                name: "simple",
+                risk_level: "normal",
+                fan_in: 2,
+                kind: "function",
+            },
+        ];
+        const suggestions = suggestApproachesForFile(entities);
+        expect(suggestions).toHaveLength(1);
+        expect(suggestions[0]?.entityName).toBe("hub");
+    });
+});
+describe("Session Context (S.5)", () => {
+    it("tracks exploration patterns", () => {
+        const ctx = createSessionContext();
+        ctx.recordQuery("src/auth/login.ts", "k1");
+        ctx.recordQuery("src/auth/logout.ts", "k2");
+        ctx.recordQuery("src/auth/validate.ts");
+        const pattern = ctx.getPattern();
+        expect(pattern.queryCount).toBe(3);
+        expect(pattern.directories.get("src/auth")).toBe(3);
+    });
+    it("detects active directory", () => {
+        const ctx = createSessionContext();
+        ctx.recordQuery("src/auth/a.ts");
+        ctx.recordQuery("src/auth/b.ts");
+        ctx.recordQuery("src/payments/c.ts");
+        ctx.recordQuery("src/auth/d.ts");
+        expect(ctx.getActiveDirectory()).toBe("src/auth");
+    });
+    it("predicts next files from active directory", () => {
+        const ctx = createSessionContext();
+        ctx.recordQuery("src/auth/login.ts");
+        ctx.recordQuery("src/auth/logout.ts");
+        ctx.recordQuery("src/auth/validate.ts");
+        const predicted = ctx.predictNextFiles(3);
+        expect(predicted.length).toBeGreaterThan(0);
+        expect(predicted.every((f) => f.startsWith("src/auth"))).toBe(true);
+    });
+    it("resets cleanly", () => {
+        const ctx = createSessionContext();
+        ctx.recordQuery("src/a.ts");
+        ctx.reset();
+        expect(ctx.getPattern().queryCount).toBe(0);
+    });
+});

package/dist/__tests__/layer3-sprint-t.test.js

@@ -0,0 +1,201 @@
+/**
+ * Layer 3 Sprint T: Token Accounting & Visibility tests.
+ */
+import { mkdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { calculateDollarSavings, formatDollars, formatSavingsSummary, getAllModelRates, getModelRate, } from "../proxy/model-pricing.js";
+import { buildTaskCostSummaries } from "../proxy/task-token-display.js";
+import { aggregateStats, appendSessionHistory, getWeeklyStats, readSessionHistory, } from "../tracking/session-history.js";
+let tempDir;
+beforeEach(() => {
+    tempDir = join(tmpdir(), `unerr-t-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+});
+afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+});
+describe("Model Pricing (T.2-T.3)", () => {
+    it("returns Claude Sonnet rate by default", () => {
+        const rate = getModelRate();
+        expect(rate.inputPerMillion).toBe(3);
+        expect(rate.name).toBe("Claude Sonnet 4");
+    });
+    it("returns correct rates for known models", () => {
+        expect(getModelRate("gpt-4o").inputPerMillion).toBe(2.5);
+        expect(getModelRate("ollama").inputPerMillion).toBe(0);
+    });
+    it("falls back to default for unknown models", () => {
+        const rate = getModelRate("unknown-model");
+        expect(rate.inputPerMillion).toBe(3);
+    });
+    it("calculates dollar savings correctly", () => {
+        const savings = calculateDollarSavings(1_000_000, "claude-sonnet-4-20250514");
+        expect(savings).toBe(3.0);
+    });
+    it("calculates zero savings for Ollama", () => {
+        expect(calculateDollarSavings(1_000_000, "ollama")).toBe(0);
+    });
+    it("formats dollars correctly", () => {
+        expect(formatDollars(1.5)).toBe("$1.50");
+        expect(formatDollars(0.27)).toBe("$0.27");
+        expect(formatDollars(0.003)).toBe("$0.003");
+    });
+    it("formats complete savings summary", () => {
+        const summary = formatSavingsSummary(45200);
+        expect(summary).toContain("45.2K");
+        expect(summary).toContain("$");
+        expect(summary).toContain("Claude Sonnet");
+    });
+    it("lists all supported models", () => {
+        const rates = getAllModelRates();
+        expect(rates.length).toBeGreaterThanOrEqual(7);
+    });
+});
+describe("Session History (T.8)", () => {
+    it("appends and reads session entries", () => {
+        const entry = {
+            sessionId: "s1",
+            startedAt: new Date().toISOString(),
+            endedAt: new Date().toISOString(),
+            durationMs: 60000,
+            toolCalls: 47,
+            tokensSaved: 23400,
+            tokensProcessed: 35000,
+            efficiency: 67,
+            dollarsSaved: 0.07,
+            modelId: "claude-sonnet-4-20250514",
+            entityCount: 847,
+        };
+        appendSessionHistory(tempDir, entry);
+        const history = readSessionHistory(tempDir);
+        expect(history).toHaveLength(1);
+        expect(history[0]?.sessionId).toBe("s1");
+        expect(history[0]?.tokensSaved).toBe(23400);
+    });
+    it("handles missing history file", () => {
+        expect(readSessionHistory(tempDir)).toHaveLength(0);
+    });
+    it("aggregates stats correctly", () => {
+        const entries = [
+            {
+                sessionId: "s1",
+                startedAt: new Date().toISOString(),
+                endedAt: new Date().toISOString(),
+                durationMs: 60000,
+                toolCalls: 40,
+                tokensSaved: 20000,
+                tokensProcessed: 30000,
+                efficiency: 67,
+                dollarsSaved: 0.06,
+                modelId: "claude-sonnet-4-20250514",
+                entityCount: 500,
+            },
+            {
+                sessionId: "s2",
+                startedAt: new Date().toISOString(),
+                endedAt: new Date().toISOString(),
+                durationMs: 120000,
+                toolCalls: 80,
+                tokensSaved: 40000,
+                tokensProcessed: 60000,
+                efficiency: 67,
+                dollarsSaved: 0.12,
+                modelId: "claude-sonnet-4-20250514",
+                entityCount: 500,
+            },
+        ];
+        const stats = aggregateStats(entries, "Test");
+        expect(stats.sessions).toBe(2);
+        expect(stats.tokensSaved).toBe(60000);
+        expect(stats.totalToolCalls).toBe(120);
+        expect(stats.avgEfficiency).toBe(67);
+    });
+    it("getWeeklyStats returns empty for fresh dir", () => {
+        const stats = getWeeklyStats(tempDir);
+        expect(stats.sessions).toBe(0);
+    });
+});
+describe("Task Token Display (T.12)", () => {
+    it("builds task cost summaries from intent groups", () => {
+        const groups = [
+            {
+                intentId: "i1",
+                prompt: "Add currency param",
+                toolCalls: 12,
+                tokensConsumed: 5000,
+                tokensSaved: 12000,
+                entitiesModified: ["processPayment"],
+                outcome: "completed",
+            },
+            {
+                intentId: "i2",
+                prompt: "Fix auth tests",
+                toolCalls: 8,
+                tokensConsumed: 3000,
+                tokensSaved: 6000,
+                entitiesModified: ["authService"],
+                outcome: "completed",
+            },
+            {
+                intentId: "i3",
+                prompt: "Update README",
+                toolCalls: 3,
+                tokensConsumed: 800,
+                tokensSaved: 400,
+                entitiesModified: [],
+                outcome: "completed",
+            },
+        ];
+        const result = buildTaskCostSummaries(groups);
+        expect(result.tasks).toHaveLength(3);
+        expect(result.totalCalls).toBe(23);
+        expect(result.formattedLines.length).toBeGreaterThan(0);
+        expect(result.formattedLines[0]).toContain("Tasks this session");
+    });
+    it("sorts by most expensive first", () => {
+        const groups = [
+            {
+                intentId: "i1",
+                prompt: "Cheap",
+                toolCalls: 2,
+                tokensConsumed: 100,
+                tokensSaved: 50,
+                entitiesModified: [],
+                outcome: "completed",
+            },
+            {
+                intentId: "i2",
+                prompt: "Expensive",
+                toolCalls: 20,
+                tokensConsumed: 50000,
+                tokensSaved: 30000,
+                entitiesModified: [],
+                outcome: "completed",
+            },
+        ];
+        const result = buildTaskCostSummaries(groups);
+        expect(result.tasks[0]?.taskDescription).toBe("Expensive");
+    });
+    it("computes efficiency correctly", () => {
+        const groups = [
+            {
+                intentId: "i1",
+                prompt: "Task",
+                toolCalls: 5,
+                tokensConsumed: 3000,
+                tokensSaved: 7000,
+                entitiesModified: [],
+                outcome: "completed",
+            },
+        ];
+        const result = buildTaskCostSummaries(groups);
+        expect(result.tasks[0]?.efficiency).toBe(70);
+    });
+    it("handles empty groups", () => {
+        const result = buildTaskCostSummaries([]);
+        expect(result.tasks).toHaveLength(0);
+        expect(result.totalCalls).toBe(0);
+    });
+});