muonroi-cli 1.8.1 → 1.8.4

package/dist/src/ui/utils/__tests__/format.test.js

@@ -1,50 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { buildToolGroupEntry, formatAnswerForLog } from "../format.js";
-describe("formatAnswerForLog", () => {
-    it("freetext: returns text verbatim (or '(empty)' for blank)", () => {
-        expect(formatAnswerForLog({ kind: "freetext", text: "hello" })).toBe("hello");
-        expect(formatAnswerForLog({ kind: "freetext", text: "" })).toBe("(empty)");
-    });
-    it("chat: returns placeholder", () => {
-        expect(formatAnswerForLog({ kind: "chat", text: "anything" })).toBe("[Chat about this]");
-    });
-    it("choice without context: bare verb (legacy behaviour)", () => {
-        expect(formatAnswerForLog({ kind: "choice", text: "accept" })).toBe("accept");
-        expect(formatAnswerForLog({ kind: "choice", text: "skip" })).toBe("skip");
-    });
-    it("choice with selectedOptionLabel: appends value", () => {
-        expect(formatAnswerForLog({ kind: "choice", text: "accept" }, { selectedOptionLabel: '"internal-tool"' })).toBe('accept · "internal-tool"');
-    });
-    it("choice with selectedOptionLabel + questionId: includes field name", () => {
-        expect(formatAnswerForLog({ kind: "choice", text: "accept" }, { selectedOptionLabel: '"internal-tool"', questionId: "productType" })).toBe('accept · productType="internal-tool"');
-    });
-    it("choice: strips rationale tail (everything after em-dash)", () => {
-        expect(formatAnswerForLog({ kind: "choice", text: "override" }, {
-            selectedOptionLabel: '"consumer-app" — Could be packaged as a standalone desktop app',
-            questionId: "productType",
-        })).toBe('override · productType="consumer-app"');
-    });
-    it("choice: when label === verb, no decoration (avoid 'accept · accept')", () => {
-        expect(formatAnswerForLog({ kind: "choice", text: "accept" }, { selectedOptionLabel: "accept" })).toBe("accept");
-    });
-    it("choice: empty/whitespace label is treated as missing", () => {
-        expect(formatAnswerForLog({ kind: "choice", text: "accept" }, { selectedOptionLabel: "   " })).toBe("accept");
-    });
-});
-describe("buildToolGroupEntry", () => {
-    it("creates an active group with a unique id and empty items list", () => {
-        const e1 = buildToolGroupEntry();
-        const e2 = buildToolGroupEntry();
-        expect(e1.type).toBe("tool_group");
-        expect(e1.toolGroup?.state).toBe("active");
-        expect(e1.toolGroup?.items).toEqual([]);
-        expect(e1.toolGroup?.id).not.toBe(e2.toolGroup?.id);
-        expect(typeof e1.toolGroup?.startedAt).toBe("number");
-    });
-    it("propagates partial ChatEntry overrides to the entry", () => {
-        const e = buildToolGroupEntry({ modeColor: "#ff0000", sourceLabel: "test-source" });
-        expect(e.modeColor).toBe("#ff0000");
-        expect(e.sourceLabel).toBe("test-source");
-    });
-});
-//# sourceMappingURL=format.test.js.map

package/dist/src/ui/utils/__tests__/tools.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/ui/utils/__tests__/tools.test.js

@@ -1,48 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { dominantVerb, verbForTool } from "../tools.js";
-describe("verbForTool", () => {
-    it("maps the common read tools to 'Reading'", () => {
-        expect(verbForTool("read_file")).toBe("Reading");
-        expect(verbForTool("read_multiple_files")).toBe("Reading");
-        expect(verbForTool("mcp_filesystem__read_text_file")).toBe("Reading");
-        expect(verbForTool("mcp__filesystem__read_file")).toBe("Reading");
-    });
-    it("maps shell to 'Running'", () => {
-        expect(verbForTool("bash")).toBe("Running");
-    });
-    it("maps grep / web search / file search to 'Searching'", () => {
-        expect(verbForTool("grep")).toBe("Searching");
-        expect(verbForTool("search_web")).toBe("Searching");
-        expect(verbForTool("search_x")).toBe("Searching");
-        expect(verbForTool("search_files")).toBe("Searching");
-        expect(verbForTool("mcp_filesystem__search_files")).toBe("Searching");
-    });
-    it("maps edit/write to 'Editing'", () => {
-        expect(verbForTool("edit_file")).toBe("Editing");
-        expect(verbForTool("write_file")).toBe("Editing");
-        expect(verbForTool("mcp__filesystem__edit_file")).toBe("Editing");
-    });
-    it("maps task / delegate to 'Exploring'", () => {
-        expect(verbForTool("task")).toBe("Exploring");
-        expect(verbForTool("delegate")).toBe("Exploring");
-    });
-    it("falls back to 'Working' for unknown tools", () => {
-        expect(verbForTool("zzz_unknown")).toBe("Working");
-    });
-});
-describe("dominantVerb", () => {
-    it("returns 'Working' for empty input", () => {
-        expect(dominantVerb([])).toBe("Working");
-    });
-    it("returns the verb of a single tool", () => {
-        expect(dominantVerb(["read_file"])).toBe("Reading");
-    });
-    it("picks the most-frequent verb across mixed tool names", () => {
-        // 3 reads, 1 bash → Reading wins
-        expect(dominantVerb(["read_file", "read_file", "read_file", "bash"])).toBe("Reading");
-    });
-    it("survives unknown tools by falling back to 'Working'", () => {
-        expect(dominantVerb(["zzz", "zzz"])).toBe("Working");
-    });
-});
-//# sourceMappingURL=tools.test.js.map

package/dist/src/ui/utils/relaunch.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/ui/utils/relaunch.test.js

@@ -1,133 +0,0 @@
-import { EventEmitter } from "node:events";
-import { describe, expect, it, vi } from "vitest";
-import { relaunchWithSession, sanitizeArgvForResume } from "./relaunch.js";
-describe("sanitizeArgvForResume", () => {
-    it("appends --session when no prior session flag exists", () => {
-        expect(sanitizeArgvForResume(["-m", "grok-build-0.1"], "abc-123")).toEqual([
-            "-m",
-            "grok-build-0.1",
-            "--session",
-            "abc-123",
-        ]);
-    });
-    it("strips an existing `-s <id>` and replaces it", () => {
-        expect(sanitizeArgvForResume(["-s", "old-id", "-m", "grok-build-0.1"], "new-id")).toEqual([
-            "-m",
-            "grok-build-0.1",
-            "--session",
-            "new-id",
-        ]);
-    });
-    it("strips an existing `--session <id>` (long form)", () => {
-        expect(sanitizeArgvForResume(["--session", "old-id", "-y"], "new-id")).toEqual(["-y", "--session", "new-id"]);
-    });
-    it("strips the combined `--session=<id>` form", () => {
-        expect(sanitizeArgvForResume(["--session=old-id", "-y"], "new-id")).toEqual(["-y", "--session", "new-id"]);
-    });
-    it("strips `--session` even when its value looks like another flag (treats value as missing)", () => {
-        // edge: user typed `--session --batch-api` — we don't eat the next flag
-        expect(sanitizeArgvForResume(["--session", "--batch-api", "-y"], "new-id")).toEqual([
-            "--batch-api",
-            "-y",
-            "--session",
-            "new-id",
-        ]);
-    });
-    it("removes multiple stray session flags (defensive — last wins)", () => {
-        expect(sanitizeArgvForResume(["-s", "a", "--session", "b", "--session=c"], "z")).toEqual(["--session", "z"]);
-    });
-    it("throws when sessionId is empty or whitespace", () => {
-        expect(() => sanitizeArgvForResume([], "")).toThrow(/sessionId is required/);
-        expect(() => sanitizeArgvForResume([], "  ")).toThrow(/sessionId is required/);
-    });
-    it("strips transient launch-mode flags (--agent-mode) so resume does not re-enter agent-mode", () => {
-        expect(sanitizeArgvForResume(["--agent-mode", "-m", "grok-build-0.1"], "new-id")).toEqual([
-            "-m",
-            "grok-build-0.1",
-            "--session",
-            "new-id",
-        ]);
-    });
-    it("strips `--mock-llm <dir>` and the combined form", () => {
-        expect(sanitizeArgvForResume(["--mock-llm", "/fix/dir", "-y"], "new-id")).toEqual(["-y", "--session", "new-id"]);
-        expect(sanitizeArgvForResume(["--mock-llm=/fix/dir", "-y"], "new-id")).toEqual(["-y", "--session", "new-id"]);
-    });
-    it("strips agent-mode + mock-llm together (harness-launched resume → clean user CLI)", () => {
-        expect(sanitizeArgvForResume(["--agent-mode", "--mock-llm", "/fx", "--session", "old"], "new")).toEqual([
-            "--session",
-            "new",
-        ]);
-    });
-});
-describe("relaunchWithSession", () => {
-    it("spawns the same executable with the sanitized argv + session id, then exits 0", () => {
-        const exitMock = vi.fn();
-        const child = new EventEmitter();
-        const spawnMock = vi.fn(() => child);
-        relaunchWithSession("sess-xyz", {
-            argv: ["/usr/local/bin/muonroi-cli", "-m", "grok-build-0.1"],
-            onExit: exitMock,
-            spawnFn: spawnMock,
-        });
-        expect(spawnMock).toHaveBeenCalledTimes(1);
-        expect(spawnMock).toHaveBeenCalledWith("/usr/local/bin/muonroi-cli", ["-m", "grok-build-0.1", "--session", "sess-xyz"], { stdio: "inherit", detached: false });
-        // exit fires on the child's "spawn" event
-        child.emit("spawn");
-        expect(exitMock).toHaveBeenCalledWith(0);
-    });
-    it("exits 1 if the child spawn errors before starting", () => {
-        const exitMock = vi.fn();
-        const errMock = vi.spyOn(console, "error").mockImplementation(() => { });
-        const child = new EventEmitter();
-        const spawnMock = vi.fn(() => child);
-        relaunchWithSession("sess-xyz", {
-            argv: ["/bin/muonroi", "-y"],
-            onExit: exitMock,
-            spawnFn: spawnMock,
-        });
-        child.emit("error", new Error("ENOENT"));
-        expect(exitMock).toHaveBeenCalledWith(1);
-        expect(errMock).toHaveBeenCalled();
-        errMock.mockRestore();
-    });
-    it("runs beforeSpawn teardown before spawning", () => {
-        const calls = [];
-        const child = new EventEmitter();
-        const spawnMock = vi.fn(() => {
-            calls.push("spawn");
-            return child;
-        });
-        relaunchWithSession("sess", {
-            argv: ["/bin/bun", "src/index.ts"],
-            onExit: () => { },
-            spawnFn: spawnMock,
-            beforeSpawn: () => calls.push("teardown"),
-        });
-        expect(calls).toEqual(["teardown", "spawn"]);
-    });
-    it("supervise: stays alive until the child exits, then propagates the exit code", () => {
-        const exitMock = vi.fn();
-        const child = new EventEmitter();
-        const spawnMock = vi.fn(() => child);
-        relaunchWithSession("sess", {
-            argv: ["/bin/bun", "src/index.ts"],
-            onExit: exitMock,
-            spawnFn: spawnMock,
-            supervise: true,
-        });
-        // Does NOT exit on spawn when supervising.
-        child.emit("spawn");
-        expect(exitMock).not.toHaveBeenCalled();
-        // Exits with the child's code when the child finally exits.
-        child.emit("exit", 3);
-        expect(exitMock).toHaveBeenCalledWith(3);
-    });
-    it("throws when argv[0] is missing (cannot relaunch without an executable)", () => {
-        expect(() => relaunchWithSession("sess", {
-            argv: [],
-            onExit: () => { },
-            spawnFn: (() => new EventEmitter()),
-        })).toThrow(/process\.argv\[0\] is empty/);
-    });
-});
-//# sourceMappingURL=relaunch.test.js.map

package/dist/src/ui/utils/text.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/ui/utils/text.test.js

@@ -1,47 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { stripInvisibleChars, stripStrayModelMacros } from "./text.js";
-describe("stripStrayModelMacros", () => {
-    it("strips a trailing \\confidence{NN} macro and the blank line before it", () => {
-        const input = "Root cause: parseInt radix.\n\nFix: use radix 10.\n\n\\confidence{85}";
-        expect(stripStrayModelMacros(input)).toBe("Root cause: parseInt radix.\n\nFix: use radix 10.");
-    });
-    it("strips a mid-text \\confidence macro too", () => {
-        expect(stripStrayModelMacros("answer \\confidence{90} continues")).toBe("answer  continues");
-    });
-    it("is a no-op when no macro is present (fast path)", () => {
-        const clean = "A normal answer with `\\frac{a}{b}` LaTeX that must survive.";
-        expect(stripStrayModelMacros(clean)).toBe(clean);
-    });
-    it("does not touch other backslash macros (conservative)", () => {
-        const latex = "Use \\frac{1}{2} and \\sum_{i}.";
-        expect(stripStrayModelMacros(latex)).toBe(latex);
-    });
-    it("handles empty / falsy input", () => {
-        expect(stripStrayModelMacros("")).toBe("");
-    });
-});
-describe("stripInvisibleChars", () => {
-    it("strips zero-width spaces (U+200B)", () => {
-        expect(stripInvisibleChars("hello\u200Bworld")).toBe("helloworld");
-    });
-    it("strips soft hyphen (U+00AD)", () => {
-        expect(stripInvisibleChars("hy\u00ADphen")).toBe("hyphen");
-    });
-    it("strips BOM (U+FEFF)", () => {
-        expect(stripInvisibleChars("\uFEFFHello")).toBe("Hello");
-    });
-    it("strips BiDi overrides (U+202E)", () => {
-        expect(stripInvisibleChars("abc\u202Edef")).toBe("abcdef");
-    });
-    it("strips C0 controls except \\t \\n \\r", () => {
-        expect(stripInvisibleChars("a\u0001b\rc\td")).toBe("ab\rc\td");
-    });
-    it("keeps normal text unchanged (fast path)", () => {
-        const normal = "Hello world, how are you?";
-        expect(stripInvisibleChars(normal)).toBe(normal);
-    });
-    it("handles empty string", () => {
-        expect(stripInvisibleChars("")).toBe("");
-    });
-});
-//# sourceMappingURL=text.test.js.map

package/dist/src/usage/__tests__/product-ledger.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/usage/__tests__/product-ledger.test.js

@@ -1,60 +0,0 @@
-import { promises as fs } from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { appendProductLedger, getProductSpentUsd, readProductLedger } from "../product-ledger.js";
-// Module-level variable set fresh in beforeEach so each test gets an isolated directory.
-let TEST_HOME;
-describe("product-ledger", () => {
-    beforeEach(async () => {
-        TEST_HOME = await fs.mkdtemp(path.join(os.tmpdir(), "muonroi-ledger-test-"));
-    });
-    afterEach(async () => {
-        await fs.rm(TEST_HOME, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-    });
-    it("appends and reads entries", async () => {
-        const runId = "test-run";
-        const entry1 = { ts: 1000, productRunId: runId, reservationId: "r1", actualUsd: 0.1, model: "m1", provider: "p1" };
-        const entry2 = { ts: 1001, productRunId: runId, reservationId: "r2", actualUsd: 0.2, model: "m1", provider: "p1" };
-        await appendProductLedger(runId, entry1, TEST_HOME);
-        await appendProductLedger(runId, entry2, TEST_HOME);
-        const entries = await readProductLedger(runId, TEST_HOME);
-        expect(entries).toHaveLength(2);
-        expect(entries[0]).toEqual(entry1);
-        expect(entries[1]).toEqual(entry2);
-    });
-    it("calculates spent USD correctly", async () => {
-        const runId = "test-run-spent";
-        await appendProductLedger(runId, { ts: 1, productRunId: runId, reservationId: "r1", actualUsd: 0.1, model: "m", provider: "p" }, TEST_HOME);
-        await appendProductLedger(runId, { ts: 2, productRunId: runId, reservationId: "r2", actualUsd: 0.2, model: "m", provider: "p" }, TEST_HOME);
-        const spent = await getProductSpentUsd(runId, TEST_HOME);
-        expect(spent).toBeCloseTo(0.3);
-    });
-    it("handles missing files gracefully", async () => {
-        const entries = await readProductLedger("non-existent", TEST_HOME);
-        expect(entries).toEqual([]);
-        const spent = await getProductSpentUsd("non-existent", TEST_HOME);
-        expect(spent).toBe(0);
-    });
-    it("handles concurrent appends", { retry: 2 }, async () => {
-        const runId = "concurrent-run";
-        const count = 10;
-        const promises = [];
-        for (let i = 0; i < count; i++) {
-            promises.push(appendProductLedger(runId, {
-                ts: Date.now(),
-                productRunId: runId,
-                reservationId: `r${i}`,
-                actualUsd: 0.01,
-                model: "m",
-                provider: "p",
-            }, TEST_HOME));
-        }
-        await Promise.all(promises);
-        const entries = await readProductLedger(runId, TEST_HOME);
-        expect(entries).toHaveLength(count);
-        const spent = await getProductSpentUsd(runId, TEST_HOME);
-        expect(spent).toBeCloseTo(count * 0.01);
-    });
-});
-//# sourceMappingURL=product-ledger.test.js.map

package/dist/src/usage/downgrade.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/usage/downgrade.test.js

@@ -1,70 +0,0 @@
-import { beforeAll, describe, expect, it } from "vitest";
-import { loadCatalog } from "../models/registry.js";
-import { downgradeChain, emitDowngrade, getDowngradeChain, subscribeDowngrade, } from "./downgrade.js";
-beforeAll(async () => {
-    await loadCatalog();
-});
-describe("getDowngradeChain()", () => {
-    it("ends with HALT", () => {
-        const chain = getDowngradeChain();
-        expect(chain[chain.length - 1]).toBe("HALT");
-    });
-    it("has at least one model before HALT", () => {
-        const chain = getDowngradeChain();
-        expect(chain.length).toBeGreaterThanOrEqual(2);
-    });
-    it("contains no duplicates (except HALT)", () => {
-        const chain = getDowngradeChain();
-        const models = chain.filter((m) => m !== "HALT");
-        expect(new Set(models).size).toBe(models.length);
-    });
-});
-describe("downgradeChain()", () => {
-    it("from first model yields second model", () => {
-        const chain = getDowngradeChain();
-        if (chain.length < 3)
-            return; // need at least 2 models + HALT
-        const step = downgradeChain(chain[0], 80);
-        expect(step.next).toBe(chain[1]);
-        expect(step.isHalt).toBe(false);
-        expect(step.eventLabel).toContain("switching");
-    });
-    it("from last model before HALT yields HALT", () => {
-        const chain = getDowngradeChain();
-        const lastModel = chain[chain.length - 2];
-        const step = downgradeChain(lastModel, 100);
-        expect(step.next).toBe("HALT");
-        expect(step.isHalt).toBe(true);
-        expect(step.eventLabel).toContain("halting");
-    });
-    it("unknown model treated as top of chain", () => {
-        const chain = getDowngradeChain();
-        const step = downgradeChain("some-unknown-model", 90);
-        expect(step.next).toBe(chain[1] ?? "HALT");
-        expect(step.isHalt).toBe(step.next === "HALT");
-    });
-});
-describe("subscribeDowngrade()", () => {
-    it("fires listener on emitDowngrade and stops after unsub", () => {
-        const chain = getDowngradeChain();
-        const events = [];
-        const unsub = subscribeDowngrade((e) => events.push(e));
-        emitDowngrade({
-            fromModel: chain[0],
-            toModel: chain[1] ?? "HALT",
-            pct: 82,
-            atMs: Date.now(),
-        });
-        expect(events).toHaveLength(1);
-        expect(events[0].fromModel).toBe(chain[0]);
-        unsub();
-        emitDowngrade({
-            fromModel: chain[0],
-            toModel: chain[1] ?? "HALT",
-            pct: 95,
-            atMs: Date.now(),
-        });
-        expect(events).toHaveLength(1);
-    });
-});
-//# sourceMappingURL=downgrade.test.js.map

package/dist/src/usage/estimator.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/usage/estimator.test.js

@@ -1,38 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { estimateTokensFromChars, projectCostUSD } from "./estimator.js";
-describe("estimator", () => {
-    describe("projectCostUSD", () => {
-        it("computes cost for known anthropic model", () => {
-            // claude-3-5-sonnet-latest: $3/M input, $15/M output
-            // 1M input + 1M output = $3 + $15 = $18
-            const cost = projectCostUSD("anthropic", "claude-3-5-sonnet-latest", 1_000_000, 1_000_000);
-            expect(cost).toBeCloseTo(18.0, 4);
-        });
-        it("returns 0 for unknown model", () => {
-            const cost = projectCostUSD("anthropic", "nonexistent-model", 1_000_000, 1_000_000);
-            expect(cost).toBe(0);
-        });
-        it("returns 0 for unknown provider", () => {
-            const cost = projectCostUSD("unknown-provider", "gpt-4o", 1_000_000, 1_000_000);
-            expect(cost).toBe(0);
-        });
-        it("ollama wildcard returns 0 cost", () => {
-            const cost = projectCostUSD("ollama", "llama3.2", 1_000_000, 1_000_000);
-            expect(cost).toBe(0);
-        });
-        it("computes haiku cost correctly", () => {
-            // claude-3-5-haiku-latest: $0.80/M input, $4.00/M output
-            // 100k input + 25k output = 0.08 + 0.10 = 0.18
-            const cost = projectCostUSD("anthropic", "claude-3-5-haiku-latest", 100_000, 25_000);
-            expect(cost).toBeCloseTo(0.18, 4);
-        });
-    });
-    describe("estimateTokensFromChars", () => {
-        it("divides chars by 4 and rounds up", () => {
-            expect(estimateTokensFromChars(100)).toBe(25);
-            expect(estimateTokensFromChars(101)).toBe(26);
-            expect(estimateTokensFromChars(0)).toBe(0);
-        });
-    });
-});
-//# sourceMappingURL=estimator.test.js.map

package/dist/src/usage/ledger.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/usage/ledger.test.js

@@ -1,171 +0,0 @@
-import * as fs from "node:fs/promises";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { atomicReadJSON } from "../storage/atomic-io.js";
-import { commit, release, reserve } from "./ledger.js";
-import { subscribeThresholds } from "./thresholds.js";
-import { CapBreachError } from "./types.js";
-async function makeTmpHome(capUsd = 15) {
-    const home = await fs.mkdtemp(path.join(os.tmpdir(), "muonroi-ledger-"));
-    await fs.writeFile(path.join(home, "config.json"), JSON.stringify({ cap: { monthly_usd: capUsd } }));
-    return home;
-}
-async function readUsage(home) {
-    return atomicReadJSON(path.join(home, "usage.json"));
-}
-describe("ledger", () => {
-    let home;
-    beforeEach(async () => {
-        home = await makeTmpHome(1.0); // $1.00 cap for easy math
-    });
-    describe("reserve()", () => {
-        it("returns ReservationToken when projection < cap", async () => {
-            const result = await reserve({
-                provider: "anthropic",
-                model: "claude-3-5-haiku-latest",
-                estInputTokens: 1000,
-                estOutputTokens: 500,
-                homeOverride: home,
-            });
-            expect(result).not.toBeInstanceOf(CapBreachError);
-            const tok = result;
-            expect(tok.id).toBeTruthy();
-            expect(tok.model).toBe("claude-3-5-haiku-latest");
-            expect(tok.provider).toBe("anthropic");
-            expect(tok.projected_usd).toBeGreaterThan(0);
-            // usage.json should have a reservation
-            const state = await readUsage(home);
-            expect(state.reservations).toHaveLength(1);
-            expect(state.reservations[0].id).toBe(tok.id);
-        });
-        it("returns CapBreachError when projection would exceed cap", async () => {
-            // claude-3-5-sonnet-latest: $3/M in + $15/M out
-            // 1M input = $3 + 1M output = $15 = $18 total >> $1.00 cap
-            const result = await reserve({
-                provider: "anthropic",
-                model: "claude-3-5-sonnet-latest",
-                estInputTokens: 1_000_000,
-                estOutputTokens: 1_000_000,
-                homeOverride: home,
-            });
-            expect(result).toBeInstanceOf(CapBreachError);
-            // usage.json should be unchanged (no reservation added)
-            const state = await readUsage(home);
-            expect(state.reservations).toHaveLength(0);
-        });
-    });
-    describe("commit()", () => {
-        it("removes reservation and increments current_usd by actual cost", async () => {
-            const tok = (await reserve({
-                provider: "anthropic",
-                model: "claude-3-5-haiku-latest",
-                estInputTokens: 10_000,
-                estOutputTokens: 5_000,
-                homeOverride: home,
-            }));
-            await commit(tok, 8_000, 4_000, home);
-            const state = await readUsage(home);
-            expect(state.reservations).toHaveLength(0);
-            expect(state.current_usd).toBeGreaterThan(0);
-        });
-        it("is idempotent -- second commit on same token is a no-op", async () => {
-            const tok = (await reserve({
-                provider: "anthropic",
-                model: "claude-3-5-haiku-latest",
-                estInputTokens: 10_000,
-                estOutputTokens: 5_000,
-                homeOverride: home,
-            }));
-            await commit(tok, 8_000, 4_000, home);
-            const stateAfterFirst = await readUsage(home);
-            await commit(tok, 8_000, 4_000, home);
-            const stateAfterSecond = await readUsage(home);
-            expect(stateAfterSecond.current_usd).toBe(stateAfterFirst.current_usd);
-        });
-    });
-    describe("release()", () => {
-        it("removes reservation without committing actual cost", async () => {
-            const tok = (await reserve({
-                provider: "anthropic",
-                model: "claude-3-5-haiku-latest",
-                estInputTokens: 10_000,
-                estOutputTokens: 5_000,
-                homeOverride: home,
-            }));
-            await release(tok, home);
-            const state = await readUsage(home);
-            expect(state.reservations).toHaveLength(0);
-            expect(state.current_usd).toBe(0);
-        });
-    });
-    describe("Pitfall 5: try/finally release pattern", () => {
-        it("reserve -> throw -> finally release cleans up reservation", async () => {
-            let tok;
-            try {
-                tok = (await reserve({
-                    provider: "anthropic",
-                    model: "claude-3-5-haiku-latest",
-                    estInputTokens: 10_000,
-                    estOutputTokens: 5_000,
-                    homeOverride: home,
-                }));
-                // Simulate an abort
-                throw new Error("stream aborted");
-            }
-            catch {
-                // expected
-            }
-            finally {
-                if (tok)
-                    await release(tok, home);
-            }
-            const state = await readUsage(home);
-            expect(state.reservations).toHaveLength(0);
-            expect(state.current_usd).toBe(0);
-        });
-    });
-    describe("subscribeThresholds integration", () => {
-        let unsub;
-        afterEach(() => {
-            if (unsub)
-                unsub();
-        });
-        it("fires 80% threshold event when commit pushes past boundary", async () => {
-            // Use a very small cap so haiku costs are meaningful
-            home = await makeTmpHome(0.01); // $0.01 cap
-            const events = [];
-            unsub = subscribeThresholds((e) => events.push(e));
-            // Reserve with haiku: 100k input + 25k output ~ $0.18 >> $0.01 cap
-            // Use smaller tokens to stay under cap for reservation
-            const tok = (await reserve({
-                provider: "anthropic",
-                model: "claude-3-5-haiku-latest",
-                estInputTokens: 1_000,
-                estOutputTokens: 500,
-                homeOverride: home,
-            }));
-            // Commit with actual tokens that push past 50% and 80%
-            // haiku: $0.80/M input, $4.00/M output
-            // 1000 in + 500 out = $0.0008 + $0.002 = $0.0028
-            // $0.0028 / $0.01 = 28% -- not enough for 50%
-            // Let's use a bigger cap scenario
-            await release(tok, home);
-            // Re-create home with better numbers
-            home = await makeTmpHome(0.005); // $0.005 cap
-            const tok2 = (await reserve({
-                provider: "anthropic",
-                model: "claude-3-5-haiku-latest",
-                estInputTokens: 1_000,
-                estOutputTokens: 500,
-                homeOverride: home,
-            }));
-            // Commit: 1000 in + 500 out = $0.0028
-            // $0.0028 / $0.005 = 56% -- should fire 50% threshold
-            await commit(tok2, 1_000, 500, home);
-            expect(events.length).toBeGreaterThanOrEqual(1);
-            expect(events.some((e) => e.level === 50)).toBe(true);
-        });
-    });
-});
-//# sourceMappingURL=ledger.test.js.map

package/dist/src/usage/midstream.test.d.ts

@@ -1 +0,0 @@
-export {};