@unerr-ai/unerr 0.1.6 → 0.1.7

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

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

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

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

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