@unerr-ai/unerr 0.1.0 → 0.1.1

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

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

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

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