Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

extensions/cost/__tests__/contract.test.ts

Raw
import {
	appendFileSync,
	mkdirSync,
	mkdtempSync,
	rmSync,
	statSync,
	utimesSync,
	writeFileSync,
} from "node:fs";
import { readdir, readFile, stat } from "node:fs/promises";
import { tmpdir } from "node:os";
import path from "node:path";
import { fileURLToPath } from "node:url";
import { fauxAssistantMessage } from "@earendil-works/pi-ai";
import type {
	ExtensionAPI,
	ExtensionContext,
} from "@earendil-works/pi-coding-agent";
import { afterEach, describe, expect, it, type MockInstance, vi } from "vitest";
import {
	createPiSession,
	type PiSession,
} from "../../../test/fixture/create-pi-session.ts";
import costExtension, { __test } from "../index.ts";

vi.mock("node:fs/promises", async (importOriginal) => {
	const actual = await importOriginal<typeof import("node:fs/promises")>();
	return {
		...actual,
		readFile: vi.fn(actual.readFile),
		readdir: vi.fn(actual.readdir),
		stat: vi.fn(actual.stat),
	};
});

const STATUS_ID = "cost";
const noModel = () => undefined;

/** Catalog lookup as the extension sees it: `ctx.modelRegistry.find`. */
async function registryFind(): Promise<{
	session: PiSession;
	find: ExtensionContext["modelRegistry"]["find"];
}> {
	let registry: ExtensionContext["modelRegistry"] | undefined;
	const probe = (pi: ExtensionAPI) => {
		pi.on("session_start", (_event, ctx) => {
			registry = ctx.modelRegistry;
		});
	};
	const s = await createPiSession({
		extensionFactories: [costExtension, probe],
	});
	await s.session.extensionRunner.emit({
		type: "session_start",
		reason: "startup",
	});
	if (!registry) throw new Error("probe never saw session_start");
	return { session: s, find: registry.find.bind(registry) };
}

function extensionPath(): string {
	return fileURLToPath(new URL("../index.ts", import.meta.url));
}

function costEntry(cost: number, timestamp = Date.now(), id?: string): string {
	return `${JSON.stringify({
		type: "message",
		...(id ? { id } : {}),
		timestamp: new Date(timestamp).toISOString(),
		message: { role: "assistant", timestamp, usage: { cost: { total: cost } } },
	})}\n`;
}

function monthKey(): string {
	const now = new Date();
	return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}`;
}

describe("cost contract", () => {
	let session: PiSession | undefined;
	let root: string | undefined;
	let statusSpy: MockInstance | undefined;

	afterEach(async () => {
		await session?.dispose();
		if (root) rmSync(root, { recursive: true, force: true });
		session = undefined;
		root = undefined;
		statusSpy = undefined;
		vi.restoreAllMocks();
		vi.clearAllMocks();
		vi.useRealTimers();
		vi.unstubAllEnvs();
	});

	function sessionDirectory(): string {
		root = mkdtempSync(path.join(tmpdir(), "pi-cost-test-"));
		const dir = path.join(root, "project");
		mkdirSync(dir);
		return dir;
	}

	function sessionFile(dir: string, name: string, cost: number): string {
		const file = path.join(dir, `${monthKey()}-${name}.jsonl`);
		writeFileSync(file, costEntry(cost), "utf8");
		return file;
	}

	async function start(dir: string): Promise<PiSession> {
		session = await createPiSession({ extensionFactories: [costExtension] });
		const runner = session.session.extensionRunner;
		const ui = { ...runner.getUIContext() };
		statusSpy = vi.spyOn(ui, "setStatus");
		runner.setUIContext(ui, "print");
		vi.spyOn(session.session.sessionManager, "getSessionDir").mockReturnValue(
			dir,
		);
		await runner.emit({ type: "session_start", reason: "startup" });
		return session;
	}

	function statusCalls(): Array<[string, unknown?]> {
		return (statusSpy?.mock.calls ?? []) as Array<[string, unknown?]>;
	}

	function status(): string | undefined {
		return statusCalls()
			.filter((call) => call[0] === STATUS_ID)
			.at(-1)?.[1] as string | undefined;
	}

	it("loads in real Pi extension runtime", async () => {
		session = await createPiSession({ extensionPaths: [extensionPath()] });
		expect(session.extensions).toHaveLength(1);
	});

	it("scans every project of the default store but only the configured flat store", async () => {
		const dir = sessionDirectory();
		vi.stubEnv("PI_CODING_AGENT_DIR", root!);
		const store = path.join(root!, "sessions");
		const project = path.join(store, "project-a");
		const sibling = path.join(store, "project-b");
		mkdirSync(project, { recursive: true });
		mkdirSync(sibling);
		sessionFile(project, "session", 1.25);
		sessionFile(sibling, "sibling", 2);
		sessionFile(store, "loose", 50);

		sessionFile(dir, "session", 3);
		sessionFile(path.dirname(dir), "foreign", 4);
		const nested = path.join(dir, "nested");
		mkdirSync(nested);
		sessionFile(nested, "ignored", 100);
		writeFileSync(
			path.join(dir, "2000-01-old.jsonl"),
			costEntry(100, new Date(2000, 0, 1).getTime()),
		);
		writeFileSync(path.join(dir, `${monthKey()}-ignored.txt`), costEntry(100));

		await expect(__test.calculateMonthlyCost(project, noModel)).resolves.toBe(
			3.25,
		);
		await expect(__test.calculateMonthlyCost(dir, noModel)).resolves.toBe(3);
		vi.mocked(readdir).mockClear();
		await expect(
			__test.calculateMonthlyCost(dir, noModel, () => false),
		).resolves.toBeUndefined();
		expect(readdir).not.toHaveBeenCalled();
	});

	it("marks an empty month as estimated", async () => {
		const dir = sessionDirectory();
		const provenance = vi.fn();
		await expect(
			__test.calculateMonthlyCost(
				dir,
				noModel,
				() => true,
				new Map(),
				provenance,
			),
		).resolves.toBe(0);
		expect(provenance).toHaveBeenCalledWith(false);
	});

	it("ignores user entries when deciding cost provenance", () => {
		expect(
			__test.plainLabel({
				usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
				turnCost: 0,
				sessionCost: 0,
				monthlyCost: 0,
				sessionTotalFromProvider: __test.allCostsFromProvider?.([
					{ type: "message", message: { role: "user" } },
				]),
			}),
		).not.toContain("≈");
	});

	it("buckets usage by response time, not the session filename", async () => {
		vi.useFakeTimers({ toFake: ["Date"] });
		vi.setSystemTime(new Date(2026, 1, 10, 12));
		const dir = sessionDirectory();
		const jan = new Date(2026, 0, 31, 23, 59).getTime();
		const feb = new Date(2026, 1, 1, 0, 0).getTime();
		writeFileSync(
			path.join(dir, "2026-01-old-session.jsonl"),
			costEntry(8, jan) + costEntry(2, feb),
		);
		writeFileSync(
			path.join(dir, "2026-02-new-session.jsonl"),
			costEntry(20, jan),
		);
		writeFileSync(path.join(dir, "custom-name.jsonl"), costEntry(3, feb));
		await expect(__test.calculateMonthlyCost(dir, noModel)).resolves.toBe(5);
	});

	it("recalculates an unchanged cross-month file at calendar rollover", async () => {
		vi.useFakeTimers({ toFake: ["Date"] });
		vi.setSystemTime(new Date(2026, 0, 31, 12));
		const dir = sessionDirectory();
		const file = path.join(dir, "2026-01-long-session.jsonl");
		writeFileSync(
			file,
			costEntry(8, new Date(2026, 0, 31, 10).getTime()) +
				costEntry(2, new Date(2026, 1, 1, 10).getTime()),
		);
		const cache = new Map();
		await expect(
			__test.calculateMonthlyCost(dir, noModel, () => true, cache),
		).resolves.toBe(8);
		vi.setSystemTime(new Date(2026, 1, 1, 12));
		await expect(
			__test.calculateMonthlyCost(dir, noModel, () => true, cache),
		).resolves.toBe(2);
	});

	it("counts copied assistant records once without merging separate responses", async () => {
		const dir = sessionDirectory();
		const copied = costEntry(2, Date.now(), "shared-entry");
		writeFileSync(
			path.join(dir, "original.jsonl"),
			copied + costEntry(3, Date.now(), "different-entry"),
		);
		writeFileSync(path.join(dir, "fork.jsonl"), copied);
		const cache = new Map();
		for (let scan = 0; scan < 2; scan++) {
			await expect(
				__test.calculateMonthlyCost(dir, noModel, () => true, cache),
			).resolves.toBe(5);
		}
	});

	it("includes every persisted native usage record once", async () => {
		const dir = sessionDirectory();
		const timestamp = new Date().toISOString();
		const media = {
			type: "message",
			id: "media",
			timestamp,
			message: {
				role: "toolResult",
				toolCallId: "media-call",
				toolName: "media_generate",
				usage: { input: 2, cost: { total: 2, totalFromProvider: false } },
			},
		};
		writeFileSync(
			path.join(dir, "parent.jsonl"),
			[
				{
					type: "message",
					id: "assistant",
					timestamp,
					message: {
						role: "assistant",
						provider: "provider-a",
						model: "model-a",
						timestamp: Date.now(),
						usage: { cost: { total: 1, totalFromProvider: true } },
					},
				},
				media,
				{
					type: "usage",
					id: "standalone",
					timestamp,
					kind: "speech",
					provider: "minimax",
					model: "speech-2.6-hd",
					usage: { input: 3, cost: { total: 3, totalFromProvider: false } },
				},
				{
					type: "compaction",
					id: "compaction",
					timestamp,
					usage: { input: 4, cost: { total: 4, totalFromProvider: false } },
				},
				{
					type: "branch_summary",
					id: "summary",
					timestamp,
					usage: { input: 5, cost: { total: 5, totalFromProvider: false } },
				},
			]
				.map((entry) => JSON.stringify(entry))
				.join("\n"),
		);
		writeFileSync(
			path.join(dir, "child.jsonl"),
			costEntry(20, Date.now(), "child-assistant"),
		);
		writeFileSync(
			path.join(dir, "fork.jsonl"),
			JSON.stringify({ ...media, parentId: "rewritten-by-fork" }),
		);

		const provenance = vi.fn();
		await expect(
			__test.calculateMonthlyCost(
				dir,
				noModel,
				() => true,
				new Map(),
				provenance,
			),
		).resolves.toBe(35);
		expect(provenance).toHaveBeenLastCalledWith(false);
	});

	it("reuses unchanged subtotals and rereads only new or changed files", async () => {
		const dir = sessionDirectory();
		const file = sessionFile(dir, "parent", 1);
		sessionFile(dir, "child", 2);
		const cache = new Map();
		const refresh = () =>
			__test.calculateMonthlyCost(dir, noModel, () => true, cache);
		await expect(refresh()).resolves.toBe(3);
		expect(readFile).toHaveBeenCalledTimes(2);

		vi.mocked(readFile).mockClear();
		await expect(refresh()).resolves.toBe(3);
		expect(readFile).not.toHaveBeenCalled();

		// Same-size rewrite: modification time must invalidate the subtotal.
		const before = statSync(file);
		writeFileSync(file, costEntry(4));
		utimesSync(file, before.atime, new Date(before.mtimeMs + 2000));
		await expect(refresh()).resolves.toBe(6);
		expect(readFile).toHaveBeenCalledExactlyOnceWith(file, "utf-8");

		// Changed size with unchanged mtime must also invalidate it.
		vi.mocked(readFile).mockClear();
		const modified = statSync(file);
		appendFileSync(file, costEntry(5));
		utimesSync(file, modified.atime, modified.mtime);
		sessionFile(dir, "new-child", 3);
		await expect(refresh()).resolves.toBe(14);
		expect(readFile).toHaveBeenCalledTimes(2);

		vi.mocked(readFile).mockClear();
		rmSync(file);
		await expect(refresh()).resolves.toBe(5);
		expect(cache.has(file)).toBe(false);
		expect(readFile).not.toHaveBeenCalled();
	});

	it("excludes previous-month response costs on rollover", async () => {
		vi.useFakeTimers({ toFake: ["Date"] });
		vi.setSystemTime(new Date(2026, 0, 31, 12));
		const dir = sessionDirectory();
		const old = sessionFile(dir, "old", 8);
		const cache = new Map();
		await expect(
			__test.calculateMonthlyCost(dir, noModel, () => true, cache),
		).resolves.toBe(8);
		vi.setSystemTime(new Date(2026, 1, 1, 12));
		const next = sessionFile(dir, "new", 2);
		await expect(
			__test.calculateMonthlyCost(dir, noModel, () => true, cache),
		).resolves.toBe(2);
		expect(readFile).toHaveBeenCalledWith(old, "utf-8");
		expect(readFile).toHaveBeenCalledWith(next, "utf-8");
	});

	it("does not cache failed reads or stats, and retries next refresh", async () => {
		const dir = sessionDirectory();
		sessionFile(dir, "session", 2);
		const cache = new Map();
		const refresh = () =>
			__test.calculateMonthlyCost(dir, noModel, () => true, cache);
		vi.mocked(readFile).mockRejectedValueOnce(new Error("unreadable"));
		await expect(refresh()).resolves.toBe(0);
		expect(cache.size).toBe(0);
		await expect(refresh()).resolves.toBe(2);
		vi.mocked(stat).mockRejectedValueOnce(new Error("removed during scan"));
		await expect(refresh()).resolves.toBe(0);
		expect(cache.size).toBe(0);
		await expect(refresh()).resolves.toBe(2);
	});

	it("does not commit a scan invalidated during a file read", async () => {
		const dir = sessionDirectory();
		const file = sessionFile(dir, "session", 2);
		const cache = new Map();
		await __test.calculateMonthlyCost(dir, noModel, () => true, cache);
		const original = cache.get(file);
		appendFileSync(file, costEntry(3));
		let current = true;
		vi.mocked(readFile).mockImplementationOnce(async () => {
			current = false;
			return costEntry(5);
		});
		await expect(
			__test.calculateMonthlyCost(dir, noModel, () => current, cache),
		).resolves.toBeUndefined();
		expect(cache.get(file)).toBe(original);
	});

	it("refreshes persisted child costs after agent_end without rereading unchanged files", async () => {
		const dir = sessionDirectory();
		sessionFile(dir, "parent", 1);
		const s = await start(dir);
		await vi.waitFor(() => expect(status()).toContain("$1.00"));
		vi.mocked(readFile).mockClear();
		const child = sessionFile(dir, "child", 2);

		await s.session.extensionRunner.emit({
			type: "agent_end",
			messages: [],
		});
		await vi.waitFor(() => expect(status()).toContain("$3.00"));
		expect(readFile).toHaveBeenCalledExactlyOnceWith(child, "utf-8");
	});

	it("coalesces requests during a blocked scan without blocking agent_end", async () => {
		const dir = sessionDirectory();
		sessionFile(dir, "parent", 1);
		const s = await start(dir);
		let release!: () => void;
		const gate = new Promise<void>((resolve) => {
			release = resolve;
		});
		vi.mocked(readFile).mockClear();
		vi.mocked(readFile).mockImplementationOnce(async () => {
			await gate;
			return costEntry(1);
		});
		try {
			await vi.waitFor(() => expect(readFile).toHaveBeenCalledOnce());
			vi.mocked(readdir).mockClear();
			sessionFile(dir, "child", 2);
			for (let i = 0; i < 3; i++) {
				await s.session.extensionRunner.emit({
					type: "agent_end",
					messages: [],
				});
			}
			expect(readdir).not.toHaveBeenCalled();
		} finally {
			release();
		}
		await vi.waitFor(() => expect(status()).toContain("$3.00"));
		expect(readFile).toHaveBeenCalledTimes(2);
		// One follow-up scan of the configured flat store.
		expect(readdir).toHaveBeenCalledOnce();
	});

	it.each(["shutdown", "replacement"])(
		"discards an in-flight monthly result on session %s",
		async (event) => {
			const dir = sessionDirectory();
			sessionFile(dir, "parent", 9);
			const s = await start(dir);
			let release!: () => void;
			const gate = new Promise<void>((resolve) => {
				release = resolve;
			});
			vi.mocked(readFile).mockClear();
			vi.mocked(readFile).mockImplementationOnce(async () => {
				await gate;
				return costEntry(9);
			});
			let callsAfterShutdown = 0;
			try {
				await vi.waitFor(() => expect(readFile).toHaveBeenCalledOnce());
				await s.session.extensionRunner.emit({
					type: "session_shutdown",
					reason: "quit",
				});
				callsAfterShutdown = statusCalls().length;
				if (event === "replacement") {
					const nextDir = path.join(dir, "separate-root", "project");
					mkdirSync(nextDir, { recursive: true });
					sessionFile(nextDir, "replacement", 2);
					vi.spyOn(s.session.sessionManager, "getSessionDir").mockReturnValue(
						nextDir,
					);
					await s.session.extensionRunner.emit({
						type: "session_start",
						reason: "reload",
					});
				}
			} finally {
				release();
			}
			if (event === "replacement") {
				await vi.waitFor(() => expect(status()).toContain("$2.00"));
			} else {
				await new Promise((resolve) => setTimeout(resolve, 20));
				expect(statusCalls()).toHaveLength(callsAfterShutdown);
			}
			expect(
				statusCalls().some((call) => String(call[1]).includes("$9.00")),
			).toBe(false);
		},
	);

	it("keeps full-session spending after switching to an earlier branch", async () => {
		const dir = sessionDirectory();
		const s = await start(dir);
		const manager = s.session.sessionManager;
		const response = (cost: number) => ({
			...fauxAssistantMessage("response"),
			usage: {
				input: 10,
				output: 2,
				cacheRead: 0,
				cacheWrite: 0,
				totalTokens: 12,
				cost: {
					input: cost,
					output: 0,
					cacheRead: 0,
					cacheWrite: 0,
					total: cost,
				},
			},
		});
		const first = manager.appendMessage(response(1));
		manager.appendMessage(response(2));
		manager.appendUsage("cache_warm", "fixture", "model", response(3).usage);
		manager.branch(first);
		await s.session.extensionRunner.emit({ type: "agent_end", messages: [] });
		expect(status()).toContain("session ≈$6.00");
	});

	it("shows a nonzero calendar-month figure even when lifetime session cost is higher", () => {
		const label = __test.plainLabel({
			usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
			turnCost: 0,
			sessionCost: 8,
			monthlyCost: 2,
		});
		expect(label).toContain("session ≈$8.00");
		expect(label).toContain("month ≈$2.00");
	});

	it.each([
		{ flag: true, estimated: false },
		{ flag: false, estimated: true },
		{ flag: undefined, estimated: true },
	])(
		"preserves session and monthly provenance with historical flag $flag",
		async ({ flag, estimated }) => {
			const dir = sessionDirectory();
			const s = await start(dir);
			const manager = s.session.sessionManager;
			const response = (
				total: number,
				totalFromProvider: boolean | undefined,
			) => ({
				...fauxAssistantMessage("response"),
				usage: {
					input: 1,
					output: 1,
					cacheRead: 0,
					cacheWrite: 0,
					totalTokens: 2,
					cost: {
						input: 99,
						output: 99,
						cacheRead: 0,
						cacheWrite: 0,
						total,
						...(totalFromProvider === undefined ? {} : { totalFromProvider }),
					},
				},
			});
			manager.appendMessage(response(1, true));
			manager.appendMessage(response(2, flag));
			writeFileSync(
				path.join(dir, "provenance.jsonl"),
				[response(1, true), response(3, flag)]
					.map((message) =>
						JSON.stringify({
							type: "message",
							timestamp: new Date().toISOString(),
							message,
						}),
					)
					.join("\n"),
			);
			await s.session.extensionRunner.emit({ type: "agent_end", messages: [] });
			expect(status()).toContain(`session ${estimated ? "≈" : ""}$3.00`);
			await vi.waitFor(() =>
				expect(status()).toContain(`month ${estimated ? "≈" : ""}$4.00`),
			);
			const provenance = vi.fn();
			const cache = new Map();
			await expect(
				__test.calculateMonthlyCost(
					dir,
					noModel,
					() => true,
					cache,
					provenance,
				),
			).resolves.toBe(4);
			expect(provenance).toHaveBeenLastCalledWith(!estimated);
			await expect(
				__test.calculateMonthlyCost(
					dir,
					noModel,
					() => true,
					cache,
					provenance,
				),
			).resolves.toBe(4);
			expect(provenance).toHaveBeenLastCalledWith(!estimated);
		},
	);

	it("counts zero-cost historical native usage as estimated without contaminating assistant-only monthly totals", async () => {
		const dir = sessionDirectory();
		const s = await start(dir);
		const assistant = {
			...fauxAssistantMessage("billed"),
			usage: {
				input: 1,
				output: 1,
				cacheRead: 0,
				cacheWrite: 0,
				totalTokens: 2,
				cost: {
					input: 100,
					output: 100,
					cacheRead: 0,
					cacheWrite: 0,
					total: 2,
					totalFromProvider: true,
				},
			},
		};
		const manager = s.session.sessionManager;
		manager.appendMessage(assistant);
		manager.appendUsage("cache_warm", "fixture", "model", {
			...assistant.usage,
			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
		});
		writeFileSync(
			path.join(dir, "assistant.jsonl"),
			JSON.stringify({
				type: "message",
				timestamp: new Date().toISOString(),
				message: assistant,
			}),
		);
		await s.session.extensionRunner.emit({ type: "agent_end", messages: [] });
		expect(status()).toContain("session ≈$2.00");
		const provenance = vi.fn();
		await expect(
			__test.calculateMonthlyCost(
				dir,
				noModel,
				() => true,
				new Map(),
				provenance,
			),
		).resolves.toBe(2);
		expect(provenance).toHaveBeenCalledWith(true);
	});

	it("honors provider-reported zero without losing unbilled catalog fallback", async () => {
		const probe = await registryFind();
		session = probe.session;
		const lookup = vi.fn(probe.find);
		const entry = (totalFromProvider?: boolean) => ({
			type: "message",
			message: {
				role: "assistant",
				provider: "zai",
				model: "glm-4.7",
				usage: { input: 1_000_000, cost: { total: 0, totalFromProvider } },
			},
		});
		expect(__test.sumMessageCosts([entry(true)], lookup)).toBe(0);
		expect(lookup).not.toHaveBeenCalled();
		expect(__test.sumMessageCosts([entry(false)], lookup)).toBeGreaterThan(0);
		expect(__test.sumMessageCosts([entry()], lookup)).toBeGreaterThan(0);
	});

	it("prices concrete responders before requested models without overriding recorded billing", async () => {
		const probe = await registryFind();
		session = probe.session;
		const base = probe.find("zai", "glm-4.7")!;
		const lookup = vi.fn((_provider: string, id: string) =>
			id === "concrete" || id === "requested"
				? {
						...base,
						id,
						cost: {
							input: id === "concrete" ? 2 : 7,
							output: 0,
							cacheRead: 0,
							cacheWrite: 0,
						},
					}
				: undefined,
		);
		const entry = (
			responseModel?: string,
			total = 0,
			totalFromProvider?: boolean,
		) => ({
			type: "message",
			message: {
				role: "assistant",
				provider: "router",
				model: "requested",
				responseModel,
				usage: { input: 1_000_000, cost: { total, totalFromProvider } },
			},
		});
		expect(__test.sumMessageCosts([entry("concrete")], lookup)).toBe(2);
		expect(__test.sumMessageCosts([entry("unknown")], lookup)).toBe(7);
		expect(__test.sumMessageCosts([entry()], lookup)).toBe(7);
		expect(__test.sumMessageCosts([entry("")], lookup)).toBe(7);
		lookup.mockClear();
		expect(__test.sumMessageCosts([entry("concrete", 0, true)], lookup)).toBe(
			0,
		);
		expect(__test.sumMessageCosts([entry("concrete", 3)], lookup)).toBe(3);
		expect(lookup).not.toHaveBeenCalled();
		expect(__test.sumMessageCosts([entry("unknown")], noModel)).toBe(0);

		const dir = sessionDirectory();
		writeFileSync(
			path.join(dir, "routed.jsonl"),
			[
				entry("concrete"),
				entry("unknown"),
				entry("concrete", 0, true),
				{
					type: "usage",
					provider: "router",
					model: "requested",
					kind: "cache_warm",
					usage: { input: 5, cost: { total: 4, totalFromProvider: true } },
				},
			]
				.map((row) =>
					JSON.stringify({ ...row, timestamp: new Date().toISOString() }),
				)
				.join("\n"),
		);
		await expect(__test.calculateMonthlyCost(dir, lookup)).resolves.toBe(13);
	});

	it("prices zero-cost assistant messages from the model catalog", async () => {
		const probe = await registryFind();
		session = probe.session;
		const findModel = probe.find;
		const model = findModel("zai", "glm-4.7");
		expect(model?.cost.input).toBeGreaterThan(0);
		const usage = { input: 1_000_000, output: 0, cacheRead: 0, cacheWrite: 0 };
		const entries = [
			{
				type: "message",
				message: {
					role: "assistant",
					provider: "zai",
					model: "glm-4.7",
					usage,
				},
			},
			{
				type: "message",
				message: {
					role: "assistant",
					provider: "nobody",
					model: "unknown",
					usage,
				},
			},
			{
				type: "message",
				message: {
					role: "assistant",
					provider: "zai",
					model: "glm-4.7",
					usage: { ...usage, cost: { total: 0.5 } },
				},
			},
		];
		expect(__test.sumMessageCosts(entries, findModel)).toBeCloseTo(
			(model?.cost.input ?? Number.NaN) + 0.5,
		);
		expect(__test.sumMessageCosts(entries, noModel)).toBe(0.5);
	});

	it("publishes native tool and standalone usage in the footer", async () => {
		const dir = sessionDirectory();
		const s = await start(dir);
		const manager = s.session.sessionManager;
		const usage = {
			input: 1,
			output: 0,
			cacheRead: 0,
			cacheWrite: 0,
			totalTokens: 1,
			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 1 },
		};
		manager.appendMessage({
			role: "toolResult",
			toolCallId: "media",
			toolName: "media_generate",
			content: [],
			isError: false,
			timestamp: Date.now(),
			usage,
		});
		manager.appendUsage("speech", "minimax", "speech-2.6-hd", {
			...usage,
			cost: { ...usage.cost, total: 2 },
		});
		manager.appendCompaction("summary", null, 0, undefined, false, {
			...usage,
			cost: { ...usage.cost, total: 3 },
		});

		await s.session.extensionRunner.emit({ type: "agent_end", messages: [] });
		expect(status()).toContain("session ≈$6.00");
	});

	it("includes every native usage-bearing entry in session costs and tokens", () => {
		const entries = [
			{
				type: "message",
				message: { role: "assistant", usage: { input: 1, cost: { total: 1 } } },
			},
			{
				type: "message",
				message: {
					role: "toolResult",
					usage: { input: 2, cost: { total: 2 } },
				},
			},
			{ type: "compaction", usage: { input: 3, cost: { total: 3 } } },
			{ type: "branch_summary", usage: { input: 4, cost: { total: 4 } } },
			{
				type: "usage",
				kind: "future-kind",
				usage: { input: 5, cost: { total: 5 } },
			},
			{
				type: "message",
				message: { role: "user", usage: { input: 99, cost: { total: 99 } } },
			},
		];
		expect(__test.sumMessageCosts(entries, noModel)).toBe(15);
		expect(__test.sessionUsage(entries).input).toBe(15);
	});

	it("charges cache writes through the catalog", async () => {
		const probe = await registryFind();
		session = probe.session;
		const findModel = probe.find;
		const model = findModel("anthropic", "claude-haiku-4-5");
		expect(model?.cost.cacheWrite).toBeGreaterThan(0);
		const entries = [
			{
				type: "message",
				message: {
					role: "assistant",
					provider: "anthropic",
					model: "claude-haiku-4-5",
					usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 1_000_000 },
				},
			},
		];
		expect(__test.sumMessageCosts(entries, findModel)).toBeCloseTo(
			model?.cost.cacheWrite ?? Number.NaN,
		);
	});

	it("sums session usage from native usage-bearing entries", () => {
		expect(
			__test.sessionUsage([
				{
					type: "message",
					message: {
						role: "assistant",
						usage: { input: 100, output: 20, cacheRead: 300 },
					},
				},
				{
					type: "message",
					message: { role: "toolResult", usage: { input: 10, output: 5 } },
				},
				{ type: "compaction", usage: { input: 50, cacheWrite: 40 } },
				{ type: "branch_summary", usage: { output: 7 } },
				{ type: "message", message: { role: "user", usage: { input: 999 } } },
			]),
		).toEqual({ input: 160, output: 32, cacheRead: 300, cacheWrite: 40 });
	});

	it("uses the latest assistant prompt for cache hit rate", () => {
		expect(
			__test.latestAssistantCacheHitRate([
				{
					type: "message",
					message: { role: "assistant", usage: { input: 90, cacheRead: 10 } },
				},
				{
					type: "message",
					message: {
						role: "assistant",
						usage: { input: 10, cacheRead: 80, cacheWrite: 10 },
					},
				},
			]),
		).toBe(80);
	});

	it("shows only input, output, and cache hit rate in the tui label", () => {
		expect(
			__test.tokenLabel(
				{
					input: 1100,
					output: 978,
					cacheRead: 108900,
					cacheWrite: 2100,
				},
				98,
			),
		).toBe("↑1.1k ↓978  98%");
	});

	it("scales large token counts into millions", () => {
		expect(
			__test.tokenLabel(
				{ input: 1_618_000, output: 448_000, cacheRead: 0, cacheWrite: 0 },
				100,
			),
		).toBe("↑1.6M ↓448k  100%");
	});

	it("spells out the non-tui label without glyphs", () => {
		expect(
			__test.plainLabel({
				usage: {
					input: 1_618_000,
					output: 448_000,
					cacheRead: 121_527_000,
					cacheWrite: 1_381_000,
				},
				cacheHitRate: 100,
				turnCost: 0.16,
				sessionCost: 70.7,
				monthlyCost: 3146.2,
			}),
		).toBe(
			"in 1.6M, out 448k, cache hit 100%, turn ≈$0.16, session ≈$70.7, month ≈$3.1k",
		);
	});
});