@unerr-ai/unerr 0.1.5 → 0.1.7

package/dist/__tests__/sprint-l10-boot.test.js

@@ -1,220 +0,0 @@
-/**
- * Sprint L10: Unified Boot State Machine & Session Logging Tests
- *
- * Tests:
- *   1. Session logger — file creation, NDJSON format, cleanup, module loggers
- *   2. Preflight — lm:false denial, lm:true proceed, field absent, timeout, zero logs
- *   3. Setup wizard — WizardResult types, config file generation, repo ID generation
- *   4. Command visibility — only chat/status/debug shown in help
- */
-import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync, } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-let tempDir;
-beforeEach(() => {
-    tempDir = join(tmpdir(), `unerr-l10-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    mkdirSync(tempDir, { recursive: true });
-});
-afterEach(async () => {
-    // Give pino async transport time to flush before removing temp dir
-    await new Promise((resolve) => setTimeout(resolve, 150));
-    try {
-        rmSync(tempDir, { recursive: true, force: true });
-    }
-    catch {
-        /* ignore */
-    }
-});
-// ── 1. Session Logger ─────────────────────────────────────────────
-describe("Session Logger", () => {
-    it("creates log file in .unerr/logs/ with NDJSON format", async () => {
-        // Reset module state for fresh logger
-        vi.resetModules();
-        const { initSessionLogger, getSessionLogPath, flushSessionLogger } = await import("../utils/session-logger.js");
-        const logger = initSessionLogger({ cwd: tempDir, level: "info" });
-        logger.info({ module: "test", msg: "hello world" });
-        flushSessionLogger();
-        // Give pino async transport a moment to flush
-        await new Promise((resolve) => setTimeout(resolve, 100));
-        const logPath = getSessionLogPath();
-        expect(logPath).toBeTruthy();
-        expect(existsSync(logPath)).toBe(true);
-        // Verify path is under .unerr/logs/
-        expect(logPath).toContain(join(".unerr", "logs", "session-"));
-        expect(logPath).toMatch(/\.log$/);
-        // Verify NDJSON format — each line is valid JSON
-        const content = readFileSync(logPath, "utf-8").trim();
-        const lines = content.split("\n").filter((l) => l.trim());
-        expect(lines.length).toBeGreaterThanOrEqual(1);
-        for (const line of lines) {
-            const parsed = JSON.parse(line);
-            expect(parsed).toHaveProperty("level");
-            expect(parsed).toHaveProperty("session_id");
-        }
-    });
-    it("returns same logger instance on repeated init calls", async () => {
-        vi.resetModules();
-        const { initSessionLogger } = await import("../utils/session-logger.js");
-        const logger1 = initSessionLogger({ cwd: tempDir });
-        const logger2 = initSessionLogger({ cwd: tempDir });
-        expect(logger1).toBe(logger2);
-    });
-    it("createSessionModuleLogger produces child with module field", async () => {
-        vi.resetModules();
-        const { initSessionLogger, createSessionModuleLogger, getSessionLogPath, flushSessionLogger, } = await import("../utils/session-logger.js");
-        initSessionLogger({ cwd: tempDir, level: "info" });
-        const modLog = createSessionModuleLogger("boot");
-        modLog.info({ msg: "boot started" });
-        flushSessionLogger();
-        await new Promise((resolve) => setTimeout(resolve, 100));
-        const logPath = getSessionLogPath();
-        const content = readFileSync(logPath, "utf-8").trim();
-        const lines = content.split("\n").filter((l) => l.trim());
-        const bootLine = lines.find((l) => {
-            const parsed = JSON.parse(l);
-            return parsed.tag === "boot" && parsed.msg.includes("boot started");
-        });
-        expect(bootLine).toBeTruthy();
-    });
-    it("getSessionId returns a UUID-format string", async () => {
-        vi.resetModules();
-        const { getSessionId } = await import("../utils/session-logger.js");
-        const id = getSessionId();
-        expect(id).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/);
-    });
-    it("cleanup removes files older than retention period", async () => {
-        vi.resetModules();
-        // Create fake old log files
-        const logsDir = join(tempDir, ".unerr", "logs");
-        mkdirSync(logsDir, { recursive: true });
-        // Create 12 fake log files (exceeds MAX_FILES of 10)
-        for (let i = 0; i < 12; i++) {
-            const fakePath = join(logsDir, `session-2020-01-${String(i + 1).padStart(2, "0")}-120000.log`);
-            writeFileSync(fakePath, `{"level":"info","msg":"old"}\n`);
-            // Set mtime to 60 days ago
-            const oldTime = new Date(Date.now() - 60 * 24 * 60 * 60 * 1000);
-            const { utimesSync } = await import("node:fs");
-            utimesSync(fakePath, oldTime, oldTime);
-        }
-        // Init logger triggers cleanup
-        const { initSessionLogger, flushSessionLogger } = await import("../utils/session-logger.js");
-        initSessionLogger({ cwd: tempDir });
-        flushSessionLogger();
-        await new Promise((resolve) => setTimeout(resolve, 100));
-        // Old files should be cleaned up (>30 days)
-        const remaining = readdirSync(logsDir).filter((f) => f.startsWith("session-") && f.endsWith(".log"));
-        // Should have at most MAX_FILES (10) + 1 new session log, but old ones (>30 days) deleted
-        // The 12 old files are all >30 days, so they get deleted. Only the new session log remains.
-        expect(remaining.length).toBeLessThanOrEqual(2); // new session + maybe 1 surviving
-    });
-});
-// ── 3. Setup Wizard Types & Config Generation ─────────────────────
-describe("Setup Wizard", () => {
-    it("exports wizard functions", async () => {
-        const mod = await import("../commands/setup-wizard.js");
-        expect(typeof mod.enterLocalModeSetup).toBe("function");
-        expect(typeof mod.promptLocalOrExit).toBe("function");
-    });
-    it("generates deterministic local repo ID from cwd", async () => {
-        // The wizard uses createHash("sha256").update(identifier).digest("hex").slice(0,12)
-        // with "local-" prefix. Verify the pattern.
-        const { createHash } = await import("node:crypto");
-        const testPath = "/tmp/test-repo";
-        const hash = createHash("sha256")
-            .update(testPath)
-            .digest("hex")
-            .slice(0, 12);
-        const repoId = `local-${hash}`;
-        expect(repoId).toMatch(/^local-[0-9a-f]{12}$/);
-        // Same input → same output
-        const hash2 = createHash("sha256")
-            .update(testPath)
-            .digest("hex")
-            .slice(0, 12);
-        expect(`local-${hash2}`).toBe(repoId);
-    });
-    it("config.json written by wizard has expected shape", () => {
-        // Simulate what enterLocalModeSetup writes
-        const configDir = join(tempDir, ".unerr");
-        mkdirSync(configDir, { recursive: true });
-        const config = { repoId: "local-abc123def456" };
-        writeFileSync(join(configDir, "config.json"), `${JSON.stringify(config, null, 2)}\n`);
-        const parsed = JSON.parse(readFileSync(join(configDir, "config.json"), "utf-8"));
-        expect(parsed.repoId).toMatch(/^local-/);
-    });
-    it("settings.json written by wizard has expected shape", () => {
-        const configDir = join(tempDir, ".unerr");
-        mkdirSync(configDir, { recursive: true });
-        const settings = {
-            localLlm: {
-                provider: "ollama",
-                baseUrl: "http://localhost:11434",
-                embeddingModel: "nomic-embed-text",
-                chatModel: "llama3",
-            },
-        };
-        writeFileSync(join(configDir, "settings.json"), `${JSON.stringify(settings, null, 2)}\n`);
-        const parsed = JSON.parse(readFileSync(join(configDir, "settings.json"), "utf-8"));
-        expect(parsed.localLlm.provider).toBe("ollama");
-        expect(parsed.localLlm.baseUrl).toBe("http://localhost:11434");
-    });
-});
-// ── 4. Command Visibility ─────────────────────────────────────────
-describe("Command Visibility", () => {
-    it("only chat, status, debug are visible in Commander", async () => {
-        // We test this by importing Commander and checking _hidden flags
-        // The cli.ts module calls program.parse() on import, so we test the logic directly
-        const { Command } = await import("commander");
-        // Simulate the visibility logic from cli.ts
-        const program = new Command();
-        program.command("chat").description("Chat");
-        program.command("status").description("Status");
-        program.command("debug").description("Debug");
-        program.command("auth").description("Auth");
-        program.command("push").description("Push");
-        program.command("pull").description("Pull");
-        program.command("sync").description("Sync");
-        program.command("init").description("Init");
-        const visibleCommands = new Set(["chat", "status", "debug"]);
-        for (const cmd of program.commands) {
-            if (!visibleCommands.has(cmd.name())) {
-                cmd._hidden = true;
-            }
-        }
-        // Verify visible commands
-        const visible = program.commands.filter((cmd) => !cmd._hidden);
-        const hidden = program.commands.filter((cmd) => cmd._hidden);
-        expect(visible.map((c) => c.name()).sort()).toEqual(["chat", "debug", "status"].sort());
-        expect(hidden.length).toBe(5); // auth, push, pull, sync, init
-        expect(hidden.every((c) => !visibleCommands.has(c.name()))).toBe(true);
-    });
-    it("hidden commands are still registered and callable", async () => {
-        const { Command } = await import("commander");
-        const program = new Command();
-        program.command("auth").description("Auth");
-        program.commands[0]._hidden = true;
-        // The command still exists even though hidden
-        const authCmd = program.commands.find((c) => c.name() === "auth");
-        expect(authCmd).toBeTruthy();
-    });
-});
-// ── 5. Boot State Machine Logic ───────────────────────────────────
-describe("Boot State Machine", () => {
-    it("readLocalConfig returns null when no .unerr/config.json exists", async () => {
-        // Test the logic from cli.ts — config detection
-        const configPath = join(tempDir, ".unerr", "config.json");
-        expect(existsSync(configPath)).toBe(false);
-    });
-    it("readLocalConfig returns parsed config when .unerr/config.json exists", () => {
-        const configDir = join(tempDir, ".unerr");
-        mkdirSync(configDir, { recursive: true });
-        const config = { repoId: "local-abc123" };
-        writeFileSync(join(configDir, "config.json"), JSON.stringify(config));
-        // Replicate readLocalConfig logic
-        const configPath = join(tempDir, ".unerr", "config.json");
-        expect(existsSync(configPath)).toBe(true);
-        const parsed = JSON.parse(readFileSync(configPath, "utf-8"));
-        expect(parsed.repoId).toBe("local-abc123");
-    });
-});

package/dist/__tests__/sprint-l9-offline-commands.test.js

@@ -1,189 +0,0 @@
-/**
- * Tests for Sprint L9 — Offline Command Replacements.
- *
- * L9.1: unerr branches local implementation
- * L9.2: unerr timeline local implementation
- * L9.3: RewindReconciler explicit Local Mode guard
- * L9.4: sync_local_diff drift overlay writes (tested via QueryRouter integration)
- */
-import { mkdtempSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { describe, expect, it } from "vitest";
-// ── L9.2: Timeline Tests ────────────────────────────────────────
-// Note: We mirror formatRelativeTime and readShadowLedger here to avoid
-// importing timeline.ts which transitively imports auth.ts (esbuild issue).
-import { existsSync, readFileSync } from "node:fs";
-function formatRelativeTime(isoTs) {
-    const diff = Date.now() - new Date(isoTs).getTime();
-    const seconds = Math.floor(diff / 1000);
-    if (seconds < 60)
-        return `${seconds}s ago`;
-    const minutes = Math.floor(seconds / 60);
-    if (minutes < 60)
-        return `${minutes} min ago`;
-    const hours = Math.floor(minutes / 60);
-    if (hours < 24)
-        return `${hours}h ago`;
-    const days = Math.floor(hours / 24);
-    return `${days}d ago`;
-}
-function readShadowLedger(ledgerPath) {
-    if (!existsSync(ledgerPath))
-        return [];
-    try {
-        const raw = readFileSync(ledgerPath, "utf-8");
-        const entries = [];
-        for (const line of raw.split("\n")) {
-            const trimmed = line.trim();
-            if (!trimmed)
-                continue;
-            try {
-                entries.push(JSON.parse(trimmed));
-            }
-            catch {
-                // Skip malformed lines
-            }
-        }
-        return entries;
-    }
-    catch {
-        return [];
-    }
-}
-describe("formatRelativeTime (L9.2)", () => {
-    it("formats seconds ago", () => {
-        const ts = new Date(Date.now() - 30_000).toISOString();
-        expect(formatRelativeTime(ts)).toBe("30s ago");
-    });
-    it("formats minutes ago", () => {
-        const ts = new Date(Date.now() - 5 * 60_000).toISOString();
-        expect(formatRelativeTime(ts)).toBe("5 min ago");
-    });
-    it("formats hours ago", () => {
-        const ts = new Date(Date.now() - 3 * 3600_000).toISOString();
-        expect(formatRelativeTime(ts)).toBe("3h ago");
-    });
-    it("formats days ago", () => {
-        const ts = new Date(Date.now() - 2 * 86400_000).toISOString();
-        expect(formatRelativeTime(ts)).toBe("2d ago");
-    });
-});
-describe("readShadowLedger (L9.2)", () => {
-    it("reads JSONL entries from ledger file", () => {
-        const dir = mkdtempSync(join(tmpdir(), "unerr-l9-"));
-        const ledgerPath = join(dir, "shadow.jsonl");
-        const entries = [
-            {
-                id: "abc123",
-                ts: "2025-01-01T10:00:00Z",
-                tool: "get_function",
-                args_summary: { key: "processPayment" },
-                result_summary: { found: true },
-                branch: "main",
-                head_sha: "deadbeef",
-                session_id: "sess1",
-                correlation_id: null,
-            },
-            {
-                id: "def456",
-                ts: "2025-01-01T10:05:00Z",
-                tool: "check_rules",
-                args_summary: { file_path: "src/payment.ts" },
-                result_summary: { violations: 0 },
-                branch: "main",
-                head_sha: "deadbeef",
-                session_id: "sess1",
-                correlation_id: "abc123",
-            },
-        ];
-        writeFileSync(ledgerPath, entries.map((e) => JSON.stringify(e)).join("\n"));
-        const result = readShadowLedger(ledgerPath);
-        expect(result).toHaveLength(2);
-        expect(result[0]?.tool).toBe("get_function");
-        expect(result[1]?.tool).toBe("check_rules");
-        expect(result[0]?.branch).toBe("main");
-    });
-    it("returns empty array for missing file", () => {
-        const result = readShadowLedger("/nonexistent/path/shadow.jsonl");
-        expect(result).toHaveLength(0);
-    });
-    it("skips malformed lines", () => {
-        const dir = mkdtempSync(join(tmpdir(), "unerr-l9-"));
-        const ledgerPath = join(dir, "shadow.jsonl");
-        writeFileSync(ledgerPath, [
-            JSON.stringify({
-                id: "abc",
-                ts: "2025-01-01T10:00:00Z",
-                tool: "get_function",
-                args_summary: {},
-                result_summary: {},
-                branch: "main",
-                head_sha: "abc",
-                session_id: "s1",
-                correlation_id: null,
-            }),
-            "not json",
-            JSON.stringify({
-                id: "def",
-                ts: "2025-01-01T10:01:00Z",
-                tool: "get_class",
-                args_summary: {},
-                result_summary: {},
-                branch: "main",
-                head_sha: "def",
-                session_id: "s1",
-                correlation_id: null,
-            }),
-        ].join("\n"));
-        const result = readShadowLedger(ledgerPath);
-        expect(result).toHaveLength(2);
-        expect(result[0]?.id).toBe("abc");
-        expect(result[1]?.id).toBe("def");
-    });
-    it("supports branch filter pattern", () => {
-        const dir = mkdtempSync(join(tmpdir(), "unerr-l9-"));
-        const ledgerPath = join(dir, "shadow.jsonl");
-        const entries = [
-            {
-                id: "a1",
-                ts: "2025-01-01T10:00:00Z",
-                tool: "get_function",
-                args_summary: {},
-                result_summary: {},
-                branch: "main",
-                head_sha: "a",
-                session_id: "s1",
-                correlation_id: null,
-            },
-            {
-                id: "b1",
-                ts: "2025-01-01T10:01:00Z",
-                tool: "get_class",
-                args_summary: {},
-                result_summary: {},
-                branch: "feature/auth",
-                head_sha: "b",
-                session_id: "s1",
-                correlation_id: null,
-            },
-            {
-                id: "c1",
-                ts: "2025-01-01T10:02:00Z",
-                tool: "check_rules",
-                args_summary: {},
-                result_summary: {},
-                branch: "main",
-                head_sha: "c",
-                session_id: "s1",
-                correlation_id: null,
-            },
-        ];
-        writeFileSync(ledgerPath, entries.map((e) => JSON.stringify(e)).join("\n"));
-        const all = readShadowLedger(ledgerPath);
-        const mainOnly = all.filter((e) => e.branch === "main");
-        expect(mainOnly).toHaveLength(2);
-        expect(mainOnly[0]?.id).toBe("a1");
-        expect(mainOnly[1]?.id).toBe("c1");
-    });
-});

package/dist/__tests__/sprint-q-persistent-context.test.js

@@ -1,198 +0,0 @@
-/**
- * Sprint Q: Persistent Context & Causal Intelligence tests.
- *
- * Tests the complete persistent intelligence loop:
- * Q.1: Causal bridge, Q.2: Auto-snapshots, Q.3: Convention learning,
- * Q.4: Session resume, Q.5: Timeline forks, Q.6: Prompt durability,
- * Q.9: Session health + exploration cost
- */
-import { describe, expect, it } from "vitest";
-describe("Q.1: Causal Bridge Query Engine", () => {
-    it("assembles causal chain from entity interactions", async () => {
-        const { assembleCausalChain } = await import("../tracking/causal-bridge.js");
-        const entries = [
-            {
-                id: "e1",
-                ts: "2026-05-01T10:00:00Z",
-                tool: "sync_local_diff",
-                args_summary: {
-                    files: ["src/auth.ts"],
-                    prompt: "Add login validation",
-                },
-                result_summary: {},
-                session_id: "s1",
-                head_sha: "abc",
-            },
-            {
-                id: "e2",
-                ts: "2026-05-01T10:05:00Z",
-                tool: "sync_local_diff",
-                args_summary: {
-                    files: ["src/auth.ts"],
-                    prompt: "Fix validation edge case",
-                },
-                result_summary: { commit_sha: "def" },
-                session_id: "s1",
-                head_sha: "def",
-            },
-        ];
-        const chain = assembleCausalChain("src/auth.ts", entries);
-        expect(chain.entityKey).toBe("src/auth.ts");
-        expect(chain.interactions.length).toBeGreaterThanOrEqual(1);
-    });
-    it("computes durability from survival data", async () => {
-        const { computeDurability } = await import("../tracking/causal-bridge.js");
-        const interactions = [
-            { survived: true, survivalMs: 86400000 },
-            { survived: true, survivalMs: 86400000 },
-            { survived: false, survivalMs: 3600000 },
-        ];
-        const durability = computeDurability(interactions);
-        expect(durability).toBeGreaterThan(0.5);
-        expect(durability).toBeLessThanOrEqual(1.0);
-    });
-});
-describe("Q.2: Auto-Snapshot Triggers", () => {
-    it("detects test pass commands", async () => {
-        const { isTestCommand } = await import("../tracking/auto-snapshot-triggers.js");
-        expect(isTestCommand("pnpm test:run")).toBe(true);
-        expect(isTestCommand("vitest run")).toBe(true);
-        expect(isTestCommand("jest --coverage")).toBe(true);
-        expect(isTestCommand("pytest -v")).toBe(true);
-        expect(isTestCommand("git status")).toBe(false);
-        expect(isTestCommand("ls -la")).toBe(false);
-    });
-    it("triggers snapshot on test pass", async () => {
-        const { shouldAutoSnapshot } = await import("../tracking/auto-snapshot-triggers.js");
-        const trigger = shouldAutoSnapshot("bash", { command: "pnpm test:run" }, { exitCode: 0 });
-        expect(trigger).not.toBeNull();
-        expect(trigger?.type).toBe("test_pass");
-    });
-    it("does not trigger on test failure", async () => {
-        const { shouldAutoSnapshot } = await import("../tracking/auto-snapshot-triggers.js");
-        const trigger = shouldAutoSnapshot("bash", { command: "pnpm test:run" }, { exitCode: 1 });
-        expect(trigger).toBeNull();
-    });
-});
-describe("Q.5: Timeline Branching on Rewind", () => {
-    it("creates timeline fork with abandoned + new branches", async () => {
-        const { createTimelineFork } = await import("../tracking/timeline-fork.js");
-        const fork = createTimelineFork("snapshot-123", ["src/auth.ts::login", "src/auth.ts::validate"], ["Add optional param to login", "Fix validate edge case"], "Broke 3 downstream callers");
-        expect(fork.forkPoint).toBe("snapshot-123");
-        expect(fork.abandonedBranch.entityChanges).toHaveLength(2);
-        expect(fork.abandonedBranch.promptsTried).toHaveLength(2);
-        expect(fork.abandonedBranch.failureReason).toContain("Broke");
-        expect(fork.newBranch.timelineId).toBeGreaterThan(fork.abandonedBranch.timelineId);
-    });
-});
-describe("Q.6: Prompt Durability Ranking", () => {
-    it("extracts action types from prompts", async () => {
-        const { extractActionType } = await import("../tracking/prompt-durability.js");
-        expect(extractActionType("Add a new helper function")).toBe("add");
-        expect(extractActionType("Fix the authentication bug")).toBe("fix");
-        expect(extractActionType("Refactor the payment module")).toBe("refactor");
-        expect(extractActionType("Modify the user service")).toBe("modify");
-        expect(extractActionType("Delete unused imports")).toBe("delete");
-        expect(extractActionType("Do something complex")).toBe("other");
-    });
-    it("computes durability profiles", async () => {
-        const { computePromptDurabilityProfiles } = await import("../tracking/prompt-durability.js");
-        const entries = [
-            {
-                prompt: "Add helper function",
-                files: ["src/utils.ts"],
-                survived: true,
-                riskLevel: "low",
-            },
-            {
-                prompt: "Add another helper",
-                files: ["src/utils.ts"],
-                survived: true,
-                riskLevel: "low",
-            },
-            {
-                prompt: "Modify critical service",
-                files: ["src/core.ts"],
-                survived: false,
-                riskLevel: "critical",
-            },
-        ];
-        const profiles = computePromptDurabilityProfiles(entries);
-        expect(profiles.length).toBeGreaterThanOrEqual(1);
-        const addProfile = profiles.find((p) => p.actionType === "add");
-        if (addProfile) {
-            expect(addProfile.durability).toBe(1.0);
-        }
-    });
-});
-describe("Q.9: Session Health Monitor", () => {
-    it("starts healthy", async () => {
-        const { createSessionHealthMonitor } = await import("../intelligence/session-health-monitor.js");
-        const monitor = createSessionHealthMonitor();
-        const health = monitor.getHealth();
-        expect(health.health).toBe(1.0);
-        expect(health.recommendation).toBe("continue");
-        expect(health.signals).toHaveLength(0);
-    });
-    it("detects repeated queries as degradation", async () => {
-        const { createSessionHealthMonitor } = await import("../intelligence/session-health-monitor.js");
-        const monitor = createSessionHealthMonitor();
-        for (let i = 0; i < 5; i++) {
-            monitor.recordToolCall("get_function", "entity-x");
-        }
-        const health = monitor.getHealth();
-        expect(health.health).toBeLessThan(1.0);
-        const repeated = health.signals.find((s) => s.type === "repeated_query");
-        expect(repeated).toBeDefined();
-    });
-    it("detects convention violation spikes", async () => {
-        const { createSessionHealthMonitor } = await import("../intelligence/session-health-monitor.js");
-        const monitor = createSessionHealthMonitor();
-        for (let i = 0; i < 6; i++) {
-            monitor.recordConventionViolation();
-        }
-        const health = monitor.getHealth();
-        const spike = health.signals.find((s) => s.type === "convention_violation_spike");
-        expect(spike).toBeDefined();
-    });
-});
-describe("Q.9: Exploration Cost Estimator", () => {
-    it("estimates counterfactual for blast_radius query", async () => {
-        const { estimateExplorationCost } = await import("../intelligence/exploration-cost.js");
-        const estimate = estimateExplorationCost("blast_radius", 500, 10);
-        expect(estimate.tokensWithout).toBeGreaterThan(estimate.tokensUsed);
-        expect(estimate.counterfactualMethod).toBeTruthy();
-        expect(estimate.explanation).toBeTruthy();
-    });
-    it("accumulates session savings", async () => {
-        const { createExplorationAccumulator, estimateExplorationCost } = await import("../intelligence/exploration-cost.js");
-        const acc = createExplorationAccumulator();
-        acc.record(estimateExplorationCost("blast_radius", 500, 10));
-        acc.record(estimateExplorationCost("find_callers", 200, 5));
-        const total = acc.getTotal();
-        expect(total.saved).toBeGreaterThan(0);
-        expect(total.ratio).toBeGreaterThan(0);
-    });
-});
-describe("Q: Intent Token Tracker", () => {
-    it("tracks tokens per intent group", async () => {
-        const { createIntentTokenTracker } = await import("../tracking/intent-token-tracker.js");
-        const tracker = createIntentTokenTracker();
-        tracker.recordToolCall("intent-1", 500, 200, "entity-a");
-        tracker.recordToolCall("intent-1", 300, 100, "entity-b");
-        const group = tracker.getGroup("intent-1");
-        expect(group).not.toBeNull();
-        expect(group?.toolCalls).toBe(2);
-        expect(group?.tokensConsumed).toBe(800);
-        expect(group?.tokensSaved).toBe(300);
-        expect(group?.entitiesModified).toContain("entity-a");
-    });
-    it("marks outcomes", async () => {
-        const { createIntentTokenTracker } = await import("../tracking/intent-token-tracker.js");
-        const tracker = createIntentTokenTracker();
-        tracker.recordToolCall("intent-2", 100, 50);
-        tracker.markOutcome("intent-2", "completed");
-        const group = tracker.getGroup("intent-2");
-        expect(group?.outcome).toBe("completed");
-    });
-});