@os-eco/overstory-cli 0.7.7 → 0.7.9

package/src/commands/costs.test.ts

@@ -796,6 +796,7 @@ describe("costsCommand", () => {
 				cacheCreationTokens: 100,
 				estimatedCostUsd: 0.15,
 				modelUsed: "claude-sonnet-4-5",
+				runId: null,
 				createdAt: new Date().toISOString(),
 			});
 			metricsStore.close();
@@ -853,6 +854,7 @@ describe("costsCommand", () => {
 				cacheCreationTokens: 100,
 				estimatedCostUsd: 0.15,
 				modelUsed: "claude-sonnet-4-5",
+				runId: null,
 				createdAt: new Date().toISOString(),
 			});
 			metricsStore.close();
@@ -937,6 +939,7 @@ describe("costsCommand", () => {
 				cacheCreationTokens: 0,
 				estimatedCostUsd: 0.15,
 				modelUsed: "claude-sonnet-4-5",
+				runId: null,
 				createdAt: new Date().toISOString(),
 			});
 			metricsStore.recordSnapshot({
@@ -947,6 +950,7 @@ describe("costsCommand", () => {
 				cacheCreationTokens: 0,
 				estimatedCostUsd: 0.25,
 				modelUsed: "claude-sonnet-4-5",
+				runId: null,
 				createdAt: new Date().toISOString(),
 			});
 			metricsStore.close();
@@ -997,6 +1001,7 @@ describe("costsCommand", () => {
 				cacheCreationTokens: 0,
 				estimatedCostUsd: 0.3,
 				modelUsed: "claude-sonnet-4-5",
+				runId: null,
 				createdAt: new Date().toISOString(),
 			});
 			metricsStore.close();

package/src/commands/costs.ts

@@ -367,7 +367,7 @@ async function executeCosts(opts: CostsOpts): Promise<void> {
 		const { store: sessionStore } = openSessionStore(overstoryDir);
 
 		try {
-			const snapshots = metricsStore.getLatestSnapshots();
+			const snapshots = metricsStore.getLatestSnapshots(runId ?? undefined);
 			if (snapshots.length === 0) {
 				if (json) {
 					jsonOutput("costs", {

package/src/commands/init.test.ts

@@ -166,6 +166,7 @@ describe("initCommand: .overstory/.gitignore", () => {
 		expect(content).toContain("!hooks.json\n");
 		expect(content).toContain("!groups.json\n");
 		expect(content).toContain("!agent-defs/\n");
+		expect(content).toContain("!agent-defs/**\n");
 
 		// Verify it matches the exported constant
 		expect(content).toBe(OVERSTORY_GITIGNORE);

package/src/commands/init.ts

@@ -588,6 +588,7 @@ export const OVERSTORY_GITIGNORE = `# Wildcard+whitelist: ignore everything, whi
 !hooks.json
 !groups.json
 !agent-defs/
+!agent-defs/**
 !README.md
 `;
 

package/src/commands/log.ts

@@ -583,6 +583,7 @@ async function runLog(opts: {
 							const cost = estimateCost(usage);
 							const metricsDbPath = join(config.project.root, ".overstory", "metrics.db");
 							const metricsStore = createMetricsStore(metricsDbPath);
+							const agentSession = getAgentSession(config.project.root, opts.agent);
 							metricsStore.recordSnapshot({
 								agentName: opts.agent,
 								inputTokens: usage.inputTokens,
@@ -591,6 +592,7 @@ async function runLog(opts: {
 								cacheCreationTokens: usage.cacheCreationTokens,
 								estimatedCostUsd: cost,
 								modelUsed: usage.modelUsed,
+								runId: agentSession?.runId ?? null,
 								createdAt: new Date().toISOString(),
 							});
 							metricsStore.close();

package/src/commands/prime.test.ts

@@ -366,6 +366,7 @@ recentTasks: []
 !hooks.json
 !groups.json
 !agent-defs/
+!agent-defs/**
 !README.md
 `;
 

package/src/commands/sling.test.ts

@@ -1,8 +1,13 @@
-import { describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { realpathSync } from "node:fs";
+import { mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { resolveModel, resolveProviderEnv } from "../agents/manifest.ts";
 import { HierarchyError } from "../errors.ts";
 import { ClaudeRuntime } from "../runtimes/claude.ts";
 import { getRuntime } from "../runtimes/registry.ts";
+import { cleanupTempDir, createTempGitRepo } from "../test-helpers.ts";
 import type { AgentManifest, OverstoryConfig } from "../types.ts";
 import {
 	type AutoDispatchOptions,
@@ -15,6 +20,7 @@ import {
 	checkRunSessionLimit,
 	checkTaskLock,
 	extractMulchRecordIds,
+	getCurrentBranch,
 	inferDomainsFromFiles,
 	isRunningAsRoot,
 	parentHasScouts,
@@ -1274,3 +1280,59 @@ describe("extractMulchRecordIds", () => {
 		expect(result).toContainEqual({ id: "mx-2ce43d", domain: "typescript" });
 	});
 });
+
+describe("getCurrentBranch", () => {
+	let repoDir: string;
+
+	beforeEach(async () => {
+		repoDir = realpathSync(await createTempGitRepo());
+	});
+
+	afterEach(async () => {
+		await cleanupTempDir(repoDir);
+	});
+
+	test("returns the current branch name", async () => {
+		const branch = await getCurrentBranch(repoDir);
+		expect(branch).toMatch(/^(main|master)$/);
+	});
+
+	test("returns feature branch name after checkout", async () => {
+		const proc = Bun.spawn(["git", "checkout", "-b", "feature/test-branch"], {
+			cwd: repoDir,
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+		await proc.exited;
+		const branch = await getCurrentBranch(repoDir);
+		expect(branch).toBe("feature/test-branch");
+	});
+
+	test("returns null for detached HEAD", async () => {
+		const hashProc = Bun.spawn(["git", "rev-parse", "HEAD"], {
+			cwd: repoDir,
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+		const hash = (await new Response(hashProc.stdout).text()).trim();
+		await hashProc.exited;
+		const proc = Bun.spawn(["git", "checkout", hash], {
+			cwd: repoDir,
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+		await proc.exited;
+		const branch = await getCurrentBranch(repoDir);
+		expect(branch).toBeNull();
+	});
+
+	test("returns null for non-git directory", async () => {
+		const tmpDir = realpathSync(await mkdtemp(join(tmpdir(), "overstory-notgit-")));
+		try {
+			const branch = await getCurrentBranch(tmpDir);
+			expect(branch).toBeNull();
+		} finally {
+			await cleanupTempDir(tmpDir);
+		}
+	});
+});

package/src/commands/sling.ts

@@ -124,6 +124,7 @@ export interface SlingOptions {
 	dispatchMaxAgents?: string;
 	runtime?: string;
 	noScoutCheck?: boolean;
+	baseBranch?: string;
 }
 
 export interface AutoDispatchOptions {
@@ -389,6 +390,28 @@ export function extractMulchRecordIds(primeText: string): Array<{ id: string; do
 	return results;
 }
 
+/**
+ * Get the current git branch name for the repo at the given path.
+ *
+ * Returns null if in detached HEAD state, the directory is not a git repo,
+ * or git exits non-zero.
+ *
+ * @param repoRoot - Absolute path to the git repository root
+ */
+export async function getCurrentBranch(repoRoot: string): Promise<string | null> {
+	const proc = Bun.spawn(["git", "rev-parse", "--abbrev-ref", "HEAD"], {
+		cwd: repoRoot,
+		stdout: "pipe",
+		stderr: "pipe",
+	});
+	const [stdout, exitCode] = await Promise.all([new Response(proc.stdout).text(), proc.exited]);
+	if (exitCode !== 0) return null;
+	const branch = stdout.trim();
+	// "HEAD" is returned when in detached HEAD state
+	if (branch === "HEAD" || branch === "") return null;
+	return branch;
+}
+
 /**
  * Entry point for `ov sling <task-id> [flags]`.
  *
@@ -658,11 +681,17 @@ export async function slingCommand(taskId: string, opts: SlingOptions): Promise<
 		const worktreeBaseDir = join(config.project.root, config.worktrees.baseDir);
 		await mkdir(worktreeBaseDir, { recursive: true });
 
+		// Resolve base branch: --base-branch flag > current HEAD > config.project.canonicalBranch
+		const baseBranch =
+			opts.baseBranch ??
+			(await getCurrentBranch(config.project.root)) ??
+			config.project.canonicalBranch;
+
 		const { path: worktreePath, branch: branchName } = await createWorktree({
 			repoRoot: config.project.root,
 			baseDir: worktreeBaseDir,
 			agentName: name,
-			baseBranch: config.project.canonicalBranch,
+			baseBranch,
 			taskId: taskId,
 		});
 
@@ -862,7 +891,13 @@ export async function slingCommand(taskId: string, opts: SlingOptions): Promise<
 			runStore.close();
 		}
 
-		// 13b. Wait for Claude Code TUI to render before sending input.
+		// 13b. Give slow shells time to finish initializing before polling for TUI readiness.
+		const shellDelay = config.runtime?.shellInitDelayMs ?? 0;
+		if (shellDelay > 0) {
+			await Bun.sleep(shellDelay);
+		}
+
+		// Wait for Claude Code TUI to render before sending input.
 		// Polling capture-pane is more reliable than a fixed sleep because
 		// TUI init time varies by machine load and model state.
 		await waitForTuiReady(tmuxSessionName, (content) => runtime.detectReady(content));

package/src/config.test.ts

@@ -775,6 +775,74 @@ project:
 		await expect(loadConfig(tempDir)).rejects.toThrow(ValidationError);
 	});
 
+	test("resets negative shellInitDelayMs to 0 with warning", async () => {
+		await writeConfig("runtime:\n  shellInitDelayMs: -100\n");
+		const origWrite = process.stderr.write;
+		let capturedStderr = "";
+		process.stderr.write = ((s: string | Uint8Array) => {
+			if (typeof s === "string") capturedStderr += s;
+			return true;
+		}) as typeof process.stderr.write;
+		try {
+			const config = await loadConfig(tempDir);
+			expect(config.runtime?.shellInitDelayMs).toBe(0);
+		} finally {
+			process.stderr.write = origWrite;
+		}
+		expect(capturedStderr).toContain("WARNING: runtime.shellInitDelayMs");
+	});
+
+	test("resets Infinity shellInitDelayMs to 0 with warning", async () => {
+		await writeConfig("runtime:\n  shellInitDelayMs: .inf\n");
+		const origWrite = process.stderr.write;
+		let capturedStderr = "";
+		process.stderr.write = ((s: string | Uint8Array) => {
+			if (typeof s === "string") capturedStderr += s;
+			return true;
+		}) as typeof process.stderr.write;
+		try {
+			const config = await loadConfig(tempDir);
+			expect(config.runtime?.shellInitDelayMs).toBe(0);
+		} finally {
+			process.stderr.write = origWrite;
+		}
+		expect(capturedStderr).toContain("WARNING: runtime.shellInitDelayMs");
+	});
+
+	test("warns when shellInitDelayMs exceeds 30s", async () => {
+		await writeConfig("runtime:\n  shellInitDelayMs: 60000\n");
+		const origWrite = process.stderr.write;
+		let capturedStderr = "";
+		process.stderr.write = ((s: string | Uint8Array) => {
+			if (typeof s === "string") capturedStderr += s;
+			return true;
+		}) as typeof process.stderr.write;
+		try {
+			const config = await loadConfig(tempDir);
+			expect(config.runtime?.shellInitDelayMs).toBe(60000);
+		} finally {
+			process.stderr.write = origWrite;
+		}
+		expect(capturedStderr).toContain("WARNING: runtime.shellInitDelayMs is 60000ms");
+	});
+
+	test("accepts valid shellInitDelayMs without warning", async () => {
+		await writeConfig("runtime:\n  shellInitDelayMs: 2000\n");
+		const origWrite = process.stderr.write;
+		let capturedStderr = "";
+		process.stderr.write = ((s: string | Uint8Array) => {
+			if (typeof s === "string") capturedStderr += s;
+			return true;
+		}) as typeof process.stderr.write;
+		try {
+			const config = await loadConfig(tempDir);
+			expect(config.runtime?.shellInitDelayMs).toBe(2000);
+		} finally {
+			process.stderr.write = origWrite;
+		}
+		expect(capturedStderr).not.toContain("shellInitDelayMs");
+	});
+
 	test("rejects qualityGate with empty description", async () => {
 		await writeConfig(`
 project:

package/src/config.ts

@@ -64,6 +64,7 @@ export const DEFAULT_CONFIG: OverstoryConfig = {
 	},
 	runtime: {
 		default: "claude",
+		shellInitDelayMs: 0,
 		pi: {
 			provider: "anthropic",
 			modelMap: {
@@ -664,6 +665,21 @@ function validateConfig(config: OverstoryConfig): void {
 		}
 	}
 
+	// runtime.shellInitDelayMs: validate if present
+	if (config.runtime?.shellInitDelayMs !== undefined) {
+		const delay = config.runtime.shellInitDelayMs;
+		if (typeof delay !== "number" || delay < 0 || !Number.isFinite(delay)) {
+			process.stderr.write(
+				`[overstory] WARNING: runtime.shellInitDelayMs must be a non-negative number. Got: ${delay}. Using default (0).\n`,
+			);
+			config.runtime.shellInitDelayMs = 0;
+		} else if (delay > 30_000) {
+			process.stderr.write(
+				`[overstory] WARNING: runtime.shellInitDelayMs is ${delay}ms (>${30}s). This adds delay before every agent spawn. Consider a lower value.\n`,
+			);
+		}
+	}
+
 	// models: validate each value — accepts aliases and provider-prefixed refs
 	const validAliases = ["sonnet", "opus", "haiku"];
 	const toolHeavyRoles = ["builder", "scout"];

package/src/doctor/structure.test.ts

@@ -114,6 +114,7 @@ describe("checkStructure", () => {
 !hooks.json
 !groups.json
 !agent-defs/
+!agent-defs/**
 `,
 		);
 

package/src/doctor/structure.ts

@@ -111,6 +111,7 @@ export const checkStructure: DoctorCheckFn = async (
 		"!hooks.json",
 		"!groups.json",
 		"!agent-defs/",
+		"!agent-defs/**",
 	];
 
 	try {

package/src/index.ts

@@ -45,7 +45,7 @@ import { OverstoryError, WorktreeError } from "./errors.ts";
 import { jsonError } from "./json.ts";
 import { brand, chalk, muted, setQuiet } from "./logging/color.ts";
 
-export const VERSION = "0.7.7";
+export const VERSION = "0.7.9";
 
 const rawArgs = process.argv.slice(2);
 
@@ -267,6 +267,7 @@ program
 	.option("--no-scout-check", "Suppress the parentHasScouts scout-before-build warning")
 	.option("--dispatch-max-agents <n>", "Per-lead max agents ceiling (injected into overlay)")
 	.option("--runtime <name>", "Runtime adapter (default: config or claude)")
+	.option("--base-branch <branch>", "Base branch for worktree creation (default: current HEAD)")
 	.option("--json", "Output result as JSON")
 	.action(async (taskId, opts) => {
 		await slingCommand(taskId, opts);

package/src/metrics/pricing.test.ts

@@ -0,0 +1,258 @@
+import { describe, expect, test } from "bun:test";
+import { estimateCost, getPricingForModel } from "./pricing";
+
+describe("getPricingForModel()", () => {
+	describe("Claude tiers", () => {
+		test("matches opus by substring in full model ID", () => {
+			const result = getPricingForModel("claude-opus-4-20250514");
+			expect(result).not.toBeNull();
+			expect(result?.inputPerMTok).toBe(15);
+			expect(result?.outputPerMTok).toBe(75);
+		});
+
+		test("matches sonnet by substring in full model ID", () => {
+			const result = getPricingForModel("claude-sonnet-4-20250514");
+			expect(result).not.toBeNull();
+			expect(result?.inputPerMTok).toBe(3);
+			expect(result?.outputPerMTok).toBe(15);
+		});
+
+		test("matches haiku by substring in full model ID", () => {
+			const result = getPricingForModel("claude-haiku-3-5-20241022");
+			expect(result).not.toBeNull();
+			expect(result?.inputPerMTok).toBe(0.8);
+			expect(result?.outputPerMTok).toBe(4);
+		});
+	});
+
+	describe("OpenAI tiers", () => {
+		test("matches gpt-4o-mini", () => {
+			const result = getPricingForModel("gpt-4o-mini");
+			expect(result).not.toBeNull();
+			expect(result?.inputPerMTok).toBe(0.15);
+		});
+
+		test("matches gpt-4o", () => {
+			const result = getPricingForModel("gpt-4o");
+			expect(result).not.toBeNull();
+			expect(result?.inputPerMTok).toBe(2.5);
+		});
+
+		test("matches gpt-5", () => {
+			const result = getPricingForModel("gpt-5");
+			expect(result).not.toBeNull();
+			expect(result?.inputPerMTok).toBe(10);
+		});
+
+		test("matches o3", () => {
+			const result = getPricingForModel("o3");
+			expect(result).not.toBeNull();
+			expect(result?.inputPerMTok).toBe(10);
+			expect(result?.outputPerMTok).toBe(40);
+		});
+
+		test("matches o1", () => {
+			const result = getPricingForModel("o1");
+			expect(result).not.toBeNull();
+			expect(result?.inputPerMTok).toBe(15);
+			expect(result?.outputPerMTok).toBe(60);
+		});
+	});
+
+	describe("Priority ordering", () => {
+		test("gpt-4o-mini matches before gpt-4o (substring overlap)", () => {
+			const mini = getPricingForModel("gpt-4o-mini");
+			const full = getPricingForModel("gpt-4o");
+			expect(mini).not.toBeNull();
+			expect(full).not.toBeNull();
+			if (mini === null || full === null) return;
+			// gpt-4o-mini is cheaper
+			expect(mini.inputPerMTok).toBeLessThan(full.inputPerMTok);
+			// A model string "gpt-4o-mini" resolves to mini pricing, not gpt-4o
+			expect(mini.inputPerMTok).toBe(0.15);
+		});
+
+		test("o3 matches before o1 (o1 string contains o1, o3 does not contain o1)", () => {
+			const o3 = getPricingForModel("o3");
+			const o1 = getPricingForModel("o1");
+			expect(o3).not.toBeNull();
+			expect(o1).not.toBeNull();
+			if (o3 === null || o1 === null) return;
+			expect(o3.outputPerMTok).toBe(40);
+			expect(o1.outputPerMTok).toBe(60);
+		});
+	});
+
+	describe("Gemini tiers", () => {
+		test("matches gemini-flash by 'flash' substring", () => {
+			const result = getPricingForModel("gemini-flash-2.0");
+			expect(result).not.toBeNull();
+			expect(result?.inputPerMTok).toBe(0.1);
+			expect(result?.outputPerMTok).toBe(0.4);
+		});
+
+		test("matches gemini-pro by 'gemini' + 'pro' substrings", () => {
+			const result = getPricingForModel("gemini-2.0-pro-exp");
+			expect(result).not.toBeNull();
+			expect(result?.inputPerMTok).toBe(1.25);
+			expect(result?.outputPerMTok).toBe(5);
+		});
+	});
+
+	describe("Case insensitivity", () => {
+		test("Claude-OPUS-4 resolves correctly", () => {
+			const result = getPricingForModel("Claude-OPUS-4");
+			expect(result).not.toBeNull();
+			expect(result?.inputPerMTok).toBe(15);
+		});
+
+		test("SONNET resolves correctly", () => {
+			const result = getPricingForModel("SONNET");
+			expect(result).not.toBeNull();
+			expect(result?.inputPerMTok).toBe(3);
+		});
+
+		test("Haiku resolves correctly", () => {
+			const result = getPricingForModel("Haiku");
+			expect(result).not.toBeNull();
+			expect(result?.inputPerMTok).toBe(0.8);
+		});
+	});
+
+	describe("Unknown models", () => {
+		test("returns null for llama-3-70b", () => {
+			expect(getPricingForModel("llama-3-70b")).toBeNull();
+		});
+
+		test("returns null for empty string", () => {
+			expect(getPricingForModel("")).toBeNull();
+		});
+
+		test("returns null for random gibberish", () => {
+			expect(getPricingForModel("xyzzy-foo-bar-9000")).toBeNull();
+		});
+	});
+});
+
+describe("estimateCost()", () => {
+	test("Typical Claude Opus usage: 1M input, 100K output, 500K cacheRead, 200K cacheCreation → $24.00", () => {
+		const cost = estimateCost({
+			inputTokens: 1_000_000,
+			outputTokens: 100_000,
+			cacheReadTokens: 500_000,
+			cacheCreationTokens: 200_000,
+			modelUsed: "claude-opus-4-20250514",
+		});
+		// inputCost = 1 * 15 = 15.00
+		// outputCost = 0.1 * 75 = 7.50
+		// cacheReadCost = 0.5 * 1.5 = 0.75
+		// cacheCreationCost = 0.2 * 3.75 = 0.75
+		// total = 24.00
+		expect(cost).toBe(24.0);
+	});
+
+	test("Typical Claude Sonnet usage: 500K input, 50K output, 100K cacheRead, 50K cacheCreation", () => {
+		const cost = estimateCost({
+			inputTokens: 500_000,
+			outputTokens: 50_000,
+			cacheReadTokens: 100_000,
+			cacheCreationTokens: 50_000,
+			modelUsed: "claude-sonnet-4-20250514",
+		});
+		// inputCost = 0.5 * 3 = 1.50
+		// outputCost = 0.05 * 15 = 0.75
+		// cacheReadCost = 0.1 * 0.3 = 0.03
+		// cacheCreationCost = 0.05 * 0.75 = 0.0375
+		// total = 2.3175
+		expect(cost).toBeCloseTo(2.3175, 4);
+	});
+
+	test("Zero tokens returns 0 (not null)", () => {
+		const cost = estimateCost({
+			inputTokens: 0,
+			outputTokens: 0,
+			cacheReadTokens: 0,
+			cacheCreationTokens: 0,
+			modelUsed: "claude-opus-4",
+		});
+		expect(cost).toBe(0);
+	});
+
+	test("Null modelUsed returns null", () => {
+		const cost = estimateCost({
+			inputTokens: 1000,
+			outputTokens: 500,
+			cacheReadTokens: 0,
+			cacheCreationTokens: 0,
+			modelUsed: null,
+		});
+		expect(cost).toBeNull();
+	});
+
+	test("Unknown model returns null", () => {
+		const cost = estimateCost({
+			inputTokens: 1000,
+			outputTokens: 500,
+			cacheReadTokens: 0,
+			cacheCreationTokens: 0,
+			modelUsed: "llama-3-70b",
+		});
+		expect(cost).toBeNull();
+	});
+
+	test("Input-only usage: only inputTokens > 0, rest zero", () => {
+		const cost = estimateCost({
+			inputTokens: 1_000_000,
+			outputTokens: 0,
+			cacheReadTokens: 0,
+			cacheCreationTokens: 0,
+			modelUsed: "claude-sonnet-4",
+		});
+		// inputCost = 1 * 3 = 3.00
+		expect(cost).toBe(3.0);
+	});
+
+	test("Output-only usage: only outputTokens > 0, rest zero", () => {
+		const cost = estimateCost({
+			inputTokens: 0,
+			outputTokens: 1_000_000,
+			cacheReadTokens: 0,
+			cacheCreationTokens: 0,
+			modelUsed: "claude-sonnet-4",
+		});
+		// outputCost = 1 * 15 = 15.00
+		expect(cost).toBe(15.0);
+	});
+
+	test("Cache-heavy usage: large cacheRead + cacheCreation, verify math", () => {
+		const cost = estimateCost({
+			inputTokens: 0,
+			outputTokens: 0,
+			cacheReadTokens: 10_000_000,
+			cacheCreationTokens: 5_000_000,
+			modelUsed: "claude-opus-4",
+		});
+		// cacheReadCost = 10 * 1.5 = 15.00
+		// cacheCreationCost = 5 * 3.75 = 18.75
+		// total = 33.75
+		expect(cost).toBeCloseTo(33.75, 5);
+	});
+});
+
+describe("Cache pricing ratios", () => {
+	test("Claude cache read is 10% of input price (verified on opus)", () => {
+		const pricing = getPricingForModel("claude-opus-4");
+		expect(pricing).not.toBeNull();
+		if (pricing === null) return;
+		const ratio = pricing.cacheReadPerMTok / pricing.inputPerMTok;
+		expect(ratio).toBeCloseTo(0.1, 10);
+	});
+
+	test("Claude cache creation is 25% of input price (verified on sonnet)", () => {
+		const pricing = getPricingForModel("claude-sonnet-4");
+		expect(pricing).not.toBeNull();
+		if (pricing === null) return;
+		const ratio = pricing.cacheCreationPerMTok / pricing.inputPerMTok;
+		expect(ratio).toBeCloseTo(0.25, 10);
+	});
+});