@foldrun/core 2.1.0 → 2.2.0

package/dist/src/catalog.d.ts

@@ -8,6 +8,13 @@ export interface CatalogModel {
     promptPrice: number | null;
     /** USD per output token. */
     completionPrice: number | null;
+    /** USD per input token read from / written to the prompt cache, when the
+     *  gateway quotes them (OpenRouter's input_cache_read / input_cache_write).
+     *  Models discount their cache differently — GPT-4o reads at half the
+     *  input price, Claude at a tenth — so a quoted price beats any multiplier.
+     *  Absent on catalogues cached before 2.1.1. */
+    cacheReadPrice?: number | null;
+    cacheWritePrice?: number | null;
     /** Can this model make tool calls? Null when the gateway doesn't say. */
     tools: boolean | null;
     /** Does it take a reasoning-depth parameter? (What `effort:` needs.) */
@@ -23,6 +30,8 @@ export interface Catalog {
     fetchedAt: string;
     models: CatalogModel[];
 }
+/** The gateway's /models payload as entries. Exported for its tests. */
+export declare function parseModels(payload: unknown): CatalogModel[];
 /** The cache as it stands, however old — null only when nothing was ever
  *  fetched. Reading never touches the network. */
 export declare function readCatalog(baseUrl: string): Catalog | null;
@@ -86,9 +95,33 @@ export declare function catalogCost(catalog: Catalog | null, modelId: string, us
     cacheReadTokens?: number;
     cacheWriteTokens?: number;
 }): number | null;
+/** What a token costs on one model: input, output, and — when the gateway
+ *  quotes them — reads from and writes to the prompt cache. */
+export interface TokenPrice {
+    input: number;
+    output: number;
+    cacheRead?: number | null;
+    cacheWrite?: number | null;
+}
+/** A catalogue entry's prices, or null when it has no input/output price. */
+export declare function tokenPriceOf(m: CatalogModel | null | undefined): TokenPrice | null;
+/**
+ * The cost of a set of counts at a price. `inputTokens` is all input; the
+ * cache fields are parts of it. Cached input is priced at the model's own
+ * cache prices when the gateway quotes them, and only otherwise at
+ * Anthropic's multipliers over the input price. Before the counts were
+ * split (18 Oct 2026) every cached token was billed at the full rate.
+ */
+export declare function costOf(usage: {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+}, p: TokenPrice): number;
 /** Anthropic's cache multipliers over the input price: a write costs a
- *  quarter more than fresh input, a read a tenth of it. One source for the
- *  mid-step ceiling (priceTurn) and the record's repricing (catalogCost). */
+ *  quarter more than fresh input, a read a tenth of it. The fallback when a
+ *  gateway quotes no cache price — for the mid-step ceiling (priceTurn) and
+ *  the record's repricing (catalogCost) alike. */
 export declare const CACHE_WRITE_MULTIPLIER = 1.25;
 export declare const CACHE_READ_MULTIPLIER = 0.1;
 /** Catalogue entries as completion items: price per MTok, context, and the

package/dist/src/catalog.js

@@ -29,7 +29,8 @@ const TTL_MS = 24 * 60 * 60 * 1000;
 const cacheFile = (baseUrl) => path.join(dataRoot(), "catalog", 
 // One file per endpoint, named legibly: catalog/openrouter.ai.json.
 `${new URL(baseUrl).hostname.replace(/[^a-z0-9.-]/gi, "_")}.json`);
-function parseModels(payload) {
+/** The gateway's /models payload as entries. Exported for its tests. */
+export function parseModels(payload) {
     const data = payload?.data;
     if (!Array.isArray(data))
         return [];
@@ -44,8 +45,14 @@ function parseModels(payload) {
             ? m.supported_parameters.map(String)
             : null;
         const pricing = (m.pricing ?? {});
+        // Unquoted is unknown, not free: Number(null) and Number("") are 0, and
+        // a gateway answering `input_cache_read: null` would have made caching
+        // cost nothing. An explicit "0" stays 0.
         const price = (k) => {
-            const n = Number(pricing[k]);
+            const v = pricing[k];
+            if (v == null || (typeof v === "string" && v.trim() === ""))
+                return null;
+            const n = Number(v);
             return Number.isFinite(n) ? n : null;
         };
         out.push({
@@ -54,6 +61,8 @@ function parseModels(payload) {
             contextLength: Number.isFinite(Number(m.context_length)) ? Number(m.context_length) : null,
             promptPrice: price("prompt"),
             completionPrice: price("completion"),
+            cacheReadPrice: price("input_cache_read"),
+            cacheWritePrice: price("input_cache_write"),
             tools: supported ? supported.includes("tools") : null,
             reasoning: supported ? supported.includes("reasoning") : null,
             efforts: Array.isArray(m.reasoning?.supported_efforts)
@@ -200,21 +209,39 @@ export function catalogCost(catalog, modelId, usage) {
     const m = findModel(catalog, modelId);
     if (!m || m.promptPrice == null || m.completionPrice == null)
         return null;
-    // A catalogue quotes one input price; cache traffic is priced off it with
-    // the multipliers every gateway that bills for caching has copied from
-    // Anthropic. Before the counts were split (18 Oct 2026) every cached
-    // token was billed here at the full rate — a long cached step cost ten
-    // times its price on the ledger.
-    // inputTokens is all input; the cache fields are parts of it.
+    return costOf(usage, tokenPriceOf(m));
+}
+/** A catalogue entry's prices, or null when it has no input/output price. */
+export function tokenPriceOf(m) {
+    if (!m || m.promptPrice == null || m.completionPrice == null)
+        return null;
+    return {
+        input: m.promptPrice,
+        output: m.completionPrice,
+        ...(m.cacheReadPrice != null ? { cacheRead: m.cacheReadPrice } : {}),
+        ...(m.cacheWritePrice != null ? { cacheWrite: m.cacheWritePrice } : {}),
+    };
+}
+/**
+ * The cost of a set of counts at a price. `inputTokens` is all input; the
+ * cache fields are parts of it. Cached input is priced at the model's own
+ * cache prices when the gateway quotes them, and only otherwise at
+ * Anthropic's multipliers over the input price. Before the counts were
+ * split (18 Oct 2026) every cached token was billed at the full rate.
+ */
+export function costOf(usage, p) {
     const read = usage.cacheReadTokens ?? 0;
     const written = usage.cacheWriteTokens ?? 0;
     const fresh = Math.max(0, usage.inputTokens - read - written);
-    const input = fresh + written * CACHE_WRITE_MULTIPLIER + read * CACHE_READ_MULTIPLIER;
-    return input * m.promptPrice + usage.outputTokens * m.completionPrice;
+    return (fresh * p.input +
+        written * (p.cacheWrite ?? p.input * CACHE_WRITE_MULTIPLIER) +
+        read * (p.cacheRead ?? p.input * CACHE_READ_MULTIPLIER) +
+        usage.outputTokens * p.output);
 }
 /** Anthropic's cache multipliers over the input price: a write costs a
- *  quarter more than fresh input, a read a tenth of it. One source for the
- *  mid-step ceiling (priceTurn) and the record's repricing (catalogCost). */
+ *  quarter more than fresh input, a read a tenth of it. The fallback when a
+ *  gateway quotes no cache price — for the mid-step ceiling (priceTurn) and
+ *  the record's repricing (catalogCost) alike. */
 export const CACHE_WRITE_MULTIPLIER = 1.25;
 export const CACHE_READ_MULTIPLIER = 0.1;
 /** Catalogue entries as completion items: price per MTok, context, and the

package/dist/src/run-container.d.ts

@@ -2,6 +2,7 @@ import { type HookRecord } from "./hooks.ts";
 import type { McpServerConfig } from "@anthropic-ai/claude-agent-sdk";
 import { type ApiSpec, type Effort } from "./store.ts";
 import type { EventExtra, ExecUsage } from "./step-exec.ts";
+import type { TokenPrice } from "./catalog.ts";
 import { type RuntimeSpec } from "./runtime.ts";
 import { type NetworkLevel } from "./network.ts";
 import type { ScriptSpec } from "./script-tools.ts";
@@ -41,10 +42,7 @@ export interface ContainerStepInput {
      *  step-exec.ts. Values, so the driver can enforce them in the pod. */
     budgetUsd?: number | null;
     budgetNote?: string;
-    price?: {
-        input: number;
-        output: number;
-    } | null;
+    price?: TokenPrice | null;
     verify?: string;
     /** `output: json` — checked inside, where the reply is. */
     output?: "json";

package/dist/src/runner.js

@@ -34,7 +34,7 @@ import { sendPlainNotification } from "./notify.js";
 import { TOOL_MAP, BUILTIN_TOOLS, ownToolNames, toolRefs, legacyUseNames, legacyUseError, retiredToolNames, retiredToolError } from "./tool-names.js";
 import { refNames } from "./refs.js";
 import { accountDir, workspaceDir, buildMemoryIndex, workspaceMemoryIndex, knowledgeIndex, workspaceKnowledgeIndex, workspaceTools, brokenToolReport, listWorkspaces, listTenants, listRuns, liveRuns, syncBundleFor, parseToolDef, readFlow, markerPresent, whenRowsPath, parseApis, resolveModel, parseProvider, providerEnvFor, resolveEffort, isEffortWord, EFFORT_LEVELS, checkFormatVersion, readRun, writeRun, runSummary, verdictOf, sumAttempts, tokensOf, parseSchemaText, STORAGE_DIR, adoptLegacyVersionKey, listAgents, } from "./store.js";
-import { loadCatalog, checkModel, clampEffort, catalogCost, findModel } from "./catalog.js";
+import { loadCatalog, checkModel, clampEffort, catalogCost, findModel, tokenPriceOf } from "./catalog.js";
 import { resolveSecrets, getSecret, materializeSecrets, secretSites } from "./secrets.js";
 import { resolveNetwork, networkLine, proxyEnv, EGRESS_CA_ENV } from "./network.js";
 import { materializeFileSecrets, cleanupFileSecrets } from "./secret-files.js";
@@ -2002,10 +2002,7 @@ stepIndex) {
             const verdict = checkModel(catalog, wireModel, { tools: needsTools });
             // Also what a token costs here, so a step can count its own spend
             // turn by turn against its ceiling instead of learning at the end.
-            const priced = findModel(catalog, wireModel);
-            if (priced && priced.promptPrice != null && priced.completionPrice != null) {
-                tokenPrice = { input: priced.promptPrice, output: priced.completionPrice };
-            }
+            tokenPrice = tokenPriceOf(findModel(catalog, wireModel));
             if (!verdict.ok) {
                 push("error", verdict.reason);
                 step.status = "failed";

package/dist/src/step-exec.d.ts

@@ -1,6 +1,7 @@
 import { type HookDef, type HookRecord } from "./hooks.ts";
 import type { McpServerConfig } from "@anthropic-ai/claude-agent-sdk";
 import type { Effort } from "./store.ts";
+import { type TokenPrice } from "./catalog.ts";
 import type { TestEffect } from "./test-mode.ts";
 import type { OperatorEvent } from "./operator.ts";
 import { type SubagentSpec } from "./subagents.ts";
@@ -89,10 +90,7 @@ export interface ExecOptions {
     /** Price per token for the model, when the catalogue knows it, so spend
      *  can be counted turn by turn instead of learned at the end. Without it
      *  the step prices its turns from the SDK's own running total. */
-    price?: {
-        input: number;
-        output: number;
-    } | null;
+    price?: TokenPrice | null;
     /** A check the step must pass to count as done: a shell command that must
      *  exit 0, or an eval-style assertion (`contains: x`, `not-contains: x`,
      *  `matches: re`, `file: path`, `judge: sentence`) — see checkVerify. */
@@ -190,21 +188,19 @@ export declare function knownPrice(model: string | undefined): {
 /**
  * What one assistant turn cost, from the usage the SDK reports. Pure.
  *
- * Cache reads and writes are priced at Anthropic's multipliers
- * (catalog.ts). Counting both at the full input rate — as this did —
+ * Cache reads and writes are priced at the model's own cache prices when
+ * the catalogue quotes them, else at Anthropic's multipliers (costOf in
+ * catalog.ts, the same arithmetic the record is repriced with). Counting
+ * both at the full input rate — as this did —
  * makes a long cached prompt read about ten times its price, which on a
  * ceiling is not "the honest direction to be wrong in", it is a step
  * killed for spending money it never spent.
  *
- * A gateway whose cache is priced differently is over- or under-counted
- * here by that difference alone; the run record's own cost is repriced
- * from the catalogue afterwards and stays the authority on the bill. This
- * number exists to stop a runaway step mid-turn, and wants to be close.
+ * The run record's own cost is repriced from the catalogue afterwards and
+ * stays the authority on the bill. This number exists to stop a runaway
+ * step mid-turn, and wants to be close.
  */
-export declare function priceTurn(u: Record<string, number | undefined>, price: {
-    input: number;
-    output: number;
-} | null): number;
+export declare function priceTurn(u: Record<string, number | undefined>, price: TokenPrice | null): number;
 /**
  * Each step launched together gets an equal share of what is left of the
  * run's budget: the shares sum to the remainder, so a group cannot end

package/dist/src/step-exec.js

@@ -12,7 +12,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { query } from "@anthropic-ai/claude-agent-sdk";
-import { CACHE_READ_MULTIPLIER, CACHE_WRITE_MULTIPLIER } from "./catalog.js";
+import { costOf } from "./catalog.js";
 import { spawn } from "node:child_process";
 import { checkPaths, checkBash, isFilesystemTool, linkWorkspace, workspaceLinkEnv, resolveAgentPath, isWithin } from "./confine.js";
 import { DELEGATE_TOOLS, subagentGuard, toAgentDefinitions } from "./subagents.js";
@@ -81,27 +81,20 @@ export function knownPrice(model) {
 /**
  * What one assistant turn cost, from the usage the SDK reports. Pure.
  *
- * Cache reads and writes are priced at Anthropic's multipliers
- * (catalog.ts). Counting both at the full input rate — as this did —
+ * Cache reads and writes are priced at the model's own cache prices when
+ * the catalogue quotes them, else at Anthropic's multipliers (costOf in
+ * catalog.ts, the same arithmetic the record is repriced with). Counting
+ * both at the full input rate — as this did —
  * makes a long cached prompt read about ten times its price, which on a
  * ceiling is not "the honest direction to be wrong in", it is a step
  * killed for spending money it never spent.
  *
- * A gateway whose cache is priced differently is over- or under-counted
- * here by that difference alone; the run record's own cost is repriced
- * from the catalogue afterwards and stays the authority on the bill. This
- * number exists to stop a runaway step mid-turn, and wants to be close.
+ * The run record's own cost is repriced from the catalogue afterwards and
+ * stays the authority on the bill. This number exists to stop a runaway
+ * step mid-turn, and wants to be close.
  */
 export function priceTurn(u, price) {
-    const p = price ?? FALLBACK_PRICE;
-    const fresh = u.input_tokens ?? 0;
-    const written = u.cache_creation_input_tokens ?? 0;
-    const read = u.cache_read_input_tokens ?? 0;
-    const outTok = u.output_tokens ?? 0;
-    return (fresh * p.input +
-        written * p.input * CACHE_WRITE_MULTIPLIER +
-        read * p.input * CACHE_READ_MULTIPLIER +
-        outTok * p.output);
+    return costOf(usageFromSdk(u), price ?? FALLBACK_PRICE);
 }
 /**
  * Each step launched together gets an equal share of what is left of the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foldrun/core",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "Agents are just folders. The format, the runner, the checks.",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",

package/src/catalog.ts

@@ -34,6 +34,13 @@ export interface CatalogModel {
   promptPrice: number | null;
   /** USD per output token. */
   completionPrice: number | null;
+  /** USD per input token read from / written to the prompt cache, when the
+   *  gateway quotes them (OpenRouter's input_cache_read / input_cache_write).
+   *  Models discount their cache differently — GPT-4o reads at half the
+   *  input price, Claude at a tenth — so a quoted price beats any multiplier.
+   *  Absent on catalogues cached before 2.1.1. */
+  cacheReadPrice?: number | null;
+  cacheWritePrice?: number | null;
   /** Can this model make tool calls? Null when the gateway doesn't say. */
   tools: boolean | null;
   /** Does it take a reasoning-depth parameter? (What `effort:` needs.) */
@@ -63,7 +70,8 @@ const cacheFile = (baseUrl: string) =>
     `${new URL(baseUrl).hostname.replace(/[^a-z0-9.-]/gi, "_")}.json`,
   );
 
-function parseModels(payload: unknown): CatalogModel[] {
+/** The gateway's /models payload as entries. Exported for its tests. */
+export function parseModels(payload: unknown): CatalogModel[] {
   const data = (payload as { data?: unknown[] })?.data;
   if (!Array.isArray(data)) return [];
   const out: CatalogModel[] = [];
@@ -75,8 +83,13 @@ function parseModels(payload: unknown): CatalogModel[] {
       ? m.supported_parameters.map(String)
       : null;
     const pricing = (m.pricing ?? {}) as Record<string, unknown>;
+    // Unquoted is unknown, not free: Number(null) and Number("") are 0, and
+    // a gateway answering `input_cache_read: null` would have made caching
+    // cost nothing. An explicit "0" stays 0.
     const price = (k: string) => {
-      const n = Number(pricing[k]);
+      const v = pricing[k];
+      if (v == null || (typeof v === "string" && v.trim() === "")) return null;
+      const n = Number(v);
       return Number.isFinite(n) ? n : null;
     };
     out.push({
@@ -85,6 +98,8 @@ function parseModels(payload: unknown): CatalogModel[] {
       contextLength: Number.isFinite(Number(m.context_length)) ? Number(m.context_length) : null,
       promptPrice: price("prompt"),
       completionPrice: price("completion"),
+      cacheReadPrice: price("input_cache_read"),
+      cacheWritePrice: price("input_cache_write"),
       tools: supported ? supported.includes("tools") : null,
       reasoning: supported ? supported.includes("reasoning") : null,
       efforts: Array.isArray((m.reasoning as Record<string, unknown> | undefined)?.supported_efforts)
@@ -249,22 +264,55 @@ export function catalogCost(
 ): number | null {
   const m = findModel(catalog, modelId);
   if (!m || m.promptPrice == null || m.completionPrice == null) return null;
-  // A catalogue quotes one input price; cache traffic is priced off it with
-  // the multipliers every gateway that bills for caching has copied from
-  // Anthropic. Before the counts were split (18 Oct 2026) every cached
-  // token was billed here at the full rate — a long cached step cost ten
-  // times its price on the ledger.
-  // inputTokens is all input; the cache fields are parts of it.
+  return costOf(usage, tokenPriceOf(m)!);
+}
+
+/** What a token costs on one model: input, output, and — when the gateway
+ *  quotes them — reads from and writes to the prompt cache. */
+export interface TokenPrice {
+  input: number;
+  output: number;
+  cacheRead?: number | null;
+  cacheWrite?: number | null;
+}
+
+/** A catalogue entry's prices, or null when it has no input/output price. */
+export function tokenPriceOf(m: CatalogModel | null | undefined): TokenPrice | null {
+  if (!m || m.promptPrice == null || m.completionPrice == null) return null;
+  return {
+    input: m.promptPrice,
+    output: m.completionPrice,
+    ...(m.cacheReadPrice != null ? { cacheRead: m.cacheReadPrice } : {}),
+    ...(m.cacheWritePrice != null ? { cacheWrite: m.cacheWritePrice } : {}),
+  };
+}
+
+/**
+ * The cost of a set of counts at a price. `inputTokens` is all input; the
+ * cache fields are parts of it. Cached input is priced at the model's own
+ * cache prices when the gateway quotes them, and only otherwise at
+ * Anthropic's multipliers over the input price. Before the counts were
+ * split (18 Oct 2026) every cached token was billed at the full rate.
+ */
+export function costOf(
+  usage: { inputTokens: number; outputTokens: number; cacheReadTokens?: number; cacheWriteTokens?: number },
+  p: TokenPrice,
+): number {
   const read = usage.cacheReadTokens ?? 0;
   const written = usage.cacheWriteTokens ?? 0;
   const fresh = Math.max(0, usage.inputTokens - read - written);
-  const input = fresh + written * CACHE_WRITE_MULTIPLIER + read * CACHE_READ_MULTIPLIER;
-  return input * m.promptPrice + usage.outputTokens * m.completionPrice;
+  return (
+    fresh * p.input +
+    written * (p.cacheWrite ?? p.input * CACHE_WRITE_MULTIPLIER) +
+    read * (p.cacheRead ?? p.input * CACHE_READ_MULTIPLIER) +
+    usage.outputTokens * p.output
+  );
 }
 
 /** Anthropic's cache multipliers over the input price: a write costs a
- *  quarter more than fresh input, a read a tenth of it. One source for the
- *  mid-step ceiling (priceTurn) and the record's repricing (catalogCost). */
+ *  quarter more than fresh input, a read a tenth of it. The fallback when a
+ *  gateway quotes no cache price — for the mid-step ceiling (priceTurn) and
+ *  the record's repricing (catalogCost) alike. */
 export const CACHE_WRITE_MULTIPLIER = 1.25;
 export const CACHE_READ_MULTIPLIER = 0.1;
 

package/src/run-container.ts

@@ -28,6 +28,7 @@ import type { McpServerConfig } from "@anthropic-ai/claude-agent-sdk";
 import { isPlatformPath, type ApiSpec, type Effort } from "./store.ts";
 import { divertedSummary, isDivertedPath, overlayTestWrites } from "./test-mode.ts";
 import type { EventExtra, ExecUsage } from "./step-exec.ts";
+import type { TokenPrice } from "./catalog.ts";
 import { isFileValue, fileContent } from "./secrets.ts";
 import { safeTenantSegment, systemInstallSh, SYSTEM_FROM_INPUT_SH, INSTALL_SOCKET, type RuntimeSpec } from "./runtime.ts";
 import { egressCaSh, type NetworkLevel } from "./network.ts";
@@ -69,7 +70,7 @@ export interface ContainerStepInput {
    *  step-exec.ts. Values, so the driver can enforce them in the pod. */
   budgetUsd?: number | null;
   budgetNote?: string;
-  price?: { input: number; output: number } | null;
+  price?: TokenPrice | null;
   verify?: string;
   /** `output: json` — checked inside, where the reply is. */
   output?: "json";

package/src/runner.ts

@@ -82,7 +82,7 @@ import {
   listAgents,
   runCost,
 } from "./store.ts";
-import { loadCatalog, checkModel, clampEffort, catalogCost, findModel, type Catalog } from "./catalog.ts";
+import { loadCatalog, checkModel, clampEffort, catalogCost, findModel, tokenPriceOf, type Catalog, type TokenPrice } from "./catalog.ts";
 import { resolveSecrets, getSecret, materializeSecrets, secretSites } from "./secrets.ts";
 import { resolveNetwork, networkLine, proxyEnv, EGRESS_CA_ENV } from "./network.ts";
 import { materializeFileSecrets, cleanupFileSecrets } from "./secret-files.ts";
@@ -2171,7 +2171,7 @@ async function runStep(
     // step on knowledge; unknown ids, presets and offline all pass through
     // to the model call, which stays the authority of last resort.
     let catalog: Catalog | null = null;
-    let tokenPrice: { input: number; output: number } | null = null;
+    let tokenPrice: TokenPrice | null = null;
     // The env this run's model calls actually ride: the workspace's own
     // provider block when one is declared, otherwise the platform's — the
     // "models included" path, where the host env points every run at the
@@ -2197,10 +2197,7 @@ async function runStep(
       const verdict = checkModel(catalog, wireModel, { tools: needsTools });
       // Also what a token costs here, so a step can count its own spend
       // turn by turn against its ceiling instead of learning at the end.
-      const priced = findModel(catalog, wireModel);
-      if (priced && priced.promptPrice != null && priced.completionPrice != null) {
-        tokenPrice = { input: priced.promptPrice, output: priced.completionPrice };
-      }
+      tokenPrice = tokenPriceOf(findModel(catalog, wireModel));
       if (!verdict.ok) {
         push("error", verdict.reason!);
         step.status = "failed";

package/src/step-exec.ts

@@ -15,7 +15,7 @@ import path from "node:path";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 import type { HookInput, McpServerConfig, SDKMessage } from "@anthropic-ai/claude-agent-sdk";
 import type { Effort } from "./store.ts";
-import { CACHE_READ_MULTIPLIER, CACHE_WRITE_MULTIPLIER } from "./catalog.ts";
+import { costOf, type TokenPrice } from "./catalog.ts";
 import type { TestEffect } from "./test-mode.ts";
 import type { OperatorEvent } from "./operator.ts";
 import { spawn } from "node:child_process";
@@ -119,7 +119,7 @@ export interface ExecOptions {
   /** Price per token for the model, when the catalogue knows it, so spend
    *  can be counted turn by turn instead of learned at the end. Without it
    *  the step prices its turns from the SDK's own running total. */
-  price?: { input: number; output: number } | null;
+  price?: TokenPrice | null;
   /** A check the step must pass to count as done: a shell command that must
    *  exit 0, or an eval-style assertion (`contains: x`, `not-contains: x`,
    *  `matches: re`, `file: path`, `judge: sentence`) — see checkVerify. */
@@ -229,29 +229,20 @@ export function knownPrice(model: string | undefined): { input: number; output:
 /**
  * What one assistant turn cost, from the usage the SDK reports. Pure.
  *
- * Cache reads and writes are priced at Anthropic's multipliers
- * (catalog.ts). Counting both at the full input rate — as this did —
+ * Cache reads and writes are priced at the model's own cache prices when
+ * the catalogue quotes them, else at Anthropic's multipliers (costOf in
+ * catalog.ts, the same arithmetic the record is repriced with). Counting
+ * both at the full input rate — as this did —
  * makes a long cached prompt read about ten times its price, which on a
  * ceiling is not "the honest direction to be wrong in", it is a step
  * killed for spending money it never spent.
  *
- * A gateway whose cache is priced differently is over- or under-counted
- * here by that difference alone; the run record's own cost is repriced
- * from the catalogue afterwards and stays the authority on the bill. This
- * number exists to stop a runaway step mid-turn, and wants to be close.
+ * The run record's own cost is repriced from the catalogue afterwards and
+ * stays the authority on the bill. This number exists to stop a runaway
+ * step mid-turn, and wants to be close.
  */
-export function priceTurn(u: Record<string, number | undefined>, price: { input: number; output: number } | null): number {
-  const p = price ?? FALLBACK_PRICE;
-  const fresh = u.input_tokens ?? 0;
-  const written = u.cache_creation_input_tokens ?? 0;
-  const read = u.cache_read_input_tokens ?? 0;
-  const outTok = u.output_tokens ?? 0;
-  return (
-    fresh * p.input +
-    written * p.input * CACHE_WRITE_MULTIPLIER +
-    read * p.input * CACHE_READ_MULTIPLIER +
-    outTok * p.output
-  );
+export function priceTurn(u: Record<string, number | undefined>, price: TokenPrice | null): number {
+  return costOf(usageFromSdk(u), price ?? FALLBACK_PRICE);
 }
 
 /**
@@ -633,10 +624,10 @@ async function executeStepInner(opts: ExecOptions, runQuery: QueryFn): Promise<E
   // runs its turns on that model, and pricing them at the parent's put a
   // max sub-agent under a fast parent at a fifth of its cost — against the
   // ceiling and on the bill.
-  const turns = new Map<string, { u: Record<string, number | undefined>; price: { input: number; output: number } | null }>();
+  const turns = new Map<string, { u: Record<string, number | undefined>; price: TokenPrice | null }>();
   let anonymousTurns = 0;
   const specByName = new Map((subagents ?? []).map((s) => [s.name, s]));
-  const priceOf = (message: unknown): { input: number; output: number } | null => {
+  const priceOf = (message: unknown): TokenPrice | null => {
     const parent = (message as { parent_tool_use_id?: string | null }).parent_tool_use_id;
     if (!parent) return opts.price ?? null;
     const declared = specByName.get(delegations.get(parent) ?? "")?.model;