@foldrun/core 2.0.0 → 2.2.0

package/dist/src/store.d.ts

@@ -125,6 +125,11 @@ export declare function saveWorkspace(tenant: string, workspace: string, files:
  *  commit, which becomes the revision's id. */
 meta?: ChangeMeta & {
     commit?: string | null;
+    /** Keep every file that is not editable source — what an agent wrote
+     *  into its own folder at run time (a browser profile, a PDF it
+     *  downloaded). A restore sets it: history holds source, so a file it
+     *  never tracked is not one a restore may take away. */
+    keepUntracked?: boolean;
 }): {
     preserved: number;
 };
@@ -948,10 +953,7 @@ export interface StepAttempt {
      *  of its own (image slim), before the full go's. */
     status: "completed" | "failed" | "lost";
     costUsd: number | null;
-    tokens: {
-        input: number;
-        output: number;
-    } | null;
+    tokens: TokenUsage | null;
     computeSecs: number | null;
     startedAt: string;
     finishedAt: string;
@@ -967,6 +969,44 @@ export interface StepAttempt {
  *  attempt reported the figure — an in-process step rents no sandbox, and
  *  billing reads null as zero, not as "unknown, charge something". */
 export declare function sumAttempts(tries: StepAttempt[]): Pick<StepAttempt, "costUsd" | "tokens" | "computeSecs">;
+/**
+ * The token counts behind a step's cost. `input` is every input token the
+ * model saw; `cacheRead` and `cacheWrite` are the part of it the prompt
+ * cache served or stored — a read costs a tenth of fresh input, and a usage
+ * page wants to say how much of a step's context was re-read rather than
+ * re-sent. Steps recorded before 18 Oct 2026 have no cache fields: their
+ * `input` is the same total, but how much of it was cached is unknown.
+ */
+export interface TokenUsage {
+    input: number;
+    output: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+}
+/** The record's shape from what a step reports (ExecOutcome.usage). */
+export declare function tokensOf(usage: {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+} | null | undefined): TokenUsage | null;
+/** Field-by-field sum; the cache fields are present in the result whenever
+ *  any input had them, so a run of old and new steps still reads whole. */
+export declare function sumTokens(list: readonly TokenUsage[]): TokenUsage;
+/** The share of all input that the prompt cache served, 0–1; null when
+ *  there was no input, or the record predates the split and cannot say. */
+export declare function cacheHitRate(t: TokenUsage | null | undefined): number | null;
+/** The cache share over several counts, taking only those that report the
+ *  split: a step recorded before it holds its cache traffic inside `input`,
+ *  and counting that as uncached would understate the rate. The rule the
+ *  Usage page and the CLI's totals follow too. */
+export declare function measuredHitRate(list: readonly (TokenUsage | null | undefined)[]): number | null;
+/** A run's token counts, summed over its steps; null when no step reported any. */
+export declare function runTokens(run: {
+    steps: readonly {
+        tokens?: TokenUsage | null;
+    }[];
+}): TokenUsage | null;
 export interface StepRecord {
     agent: string;
     instruction: string;
@@ -1154,10 +1194,7 @@ export interface StepRecord {
     /** Token counts behind costUsd, kept so usage reports can say "how many"
      *  and not only "how much" — the price of a token changes, the count is
      *  the fact. Absent on steps recorded before this existed. */
-    tokens?: {
-        input: number;
-        output: number;
-    } | null;
+    tokens?: TokenUsage | null;
     /** What the sandbox actually touched, against what it reserved: CPU
      *  busy-seconds and peak memory from the pod's own cgroup, bytes on the
      *  wire from /proc/net/dev. Null per-field where the kernel interface
@@ -1319,10 +1356,7 @@ export interface RunSummaryStep {
     group: number;
     status: StepRecord["status"];
     costUsd: number | null;
-    tokens?: {
-        input: number;
-        output: number;
-    } | null;
+    tokens?: TokenUsage | null;
     computeSecs?: number | null;
     skipReason?: string;
     /** The last error event, for a failed step — what runFailure reads. */

package/dist/src/store.js

@@ -385,7 +385,6 @@ meta = {}) {
     // about it. Before this, every deploy silently erased everything the agents
     // had learned.
     const shipped = new Set(files.map((f) => path.normalize(f.path)));
-    const isAgentOwned = (rel) => keptOnDeploy(rel, shipped);
     // What is there now, for the revision: every editable file's content
     // before this save replaces the tree.
     const before = new Map();
@@ -399,6 +398,7 @@ meta = {}) {
             }
         }
     }
+    const isAgentOwned = (rel) => keptOnDeploy(rel, shipped) || (meta.keepUntracked === true && !before.has(rel) && !shipped.has(rel));
     const snapshot = fs.existsSync(dir) ? fs.mkdtempSync(path.join(dataRoot(), ".keep-")) : null;
     const preserved = [];
     if (snapshot) {
@@ -406,11 +406,15 @@ meta = {}) {
             const rel = String(entry).split(path.sep).join("/");
             const from = path.join(dir, rel);
             try {
-                if (!fs.statSync(from).isFile() || !isAgentOwned(rel))
+                // lstat, never stat: a link is never followed. An agent folder's link
+                // to a file outside the workspace was copied in as that file's
+                // contents — on a restore with keepUntracked, any such link
+                // (Codex, 18 Oct 2026).
+                if (!fs.lstatSync(from).isFile() || !isAgentOwned(rel))
                     continue;
             }
             catch {
-                continue; // a broken link or a file that vanished mid-deploy
+                continue; // a file that vanished mid-deploy
             }
             const to = path.join(snapshot, rel);
             fs.mkdirSync(path.dirname(to), { recursive: true });
@@ -2573,10 +2577,62 @@ export function sumAttempts(tries) {
     const secs = tries.map((t) => t.computeSecs).filter((c) => typeof c === "number");
     return {
         costUsd: costs.length ? costs.reduce((a, b) => a + b, 0) : null,
-        tokens: toks.length ? toks.reduce((a, b) => ({ input: a.input + b.input, output: a.output + b.output }), { input: 0, output: 0 }) : null,
+        tokens: toks.length ? sumTokens(toks) : null,
         computeSecs: secs.length ? secs.reduce((a, b) => a + b, 0) : null,
     };
 }
+/** The record's shape from what a step reports (ExecOutcome.usage). */
+export function tokensOf(usage) {
+    if (!usage)
+        return null;
+    return {
+        input: usage.inputTokens,
+        output: usage.outputTokens,
+        cacheRead: usage.cacheReadTokens ?? 0,
+        cacheWrite: usage.cacheWriteTokens ?? 0,
+    };
+}
+/** Field-by-field sum; the cache fields are present in the result whenever
+ *  any input had them, so a run of old and new steps still reads whole. */
+export function sumTokens(list) {
+    const out = { input: 0, output: 0 };
+    for (const t of list) {
+        out.input += t.input;
+        out.output += t.output;
+        if (t.cacheRead !== undefined || t.cacheWrite !== undefined) {
+            out.cacheRead = (out.cacheRead ?? 0) + (t.cacheRead ?? 0);
+            out.cacheWrite = (out.cacheWrite ?? 0) + (t.cacheWrite ?? 0);
+        }
+    }
+    return out;
+}
+/** The share of all input that the prompt cache served, 0–1; null when
+ *  there was no input, or the record predates the split and cannot say. */
+export function cacheHitRate(t) {
+    if (!t || t.cacheRead === undefined)
+        return null;
+    return t.input > 0 ? Math.min(1, t.cacheRead / t.input) : null;
+}
+/** The cache share over several counts, taking only those that report the
+ *  split: a step recorded before it holds its cache traffic inside `input`,
+ *  and counting that as uncached would understate the rate. The rule the
+ *  Usage page and the CLI's totals follow too. */
+export function measuredHitRate(list) {
+    let read = 0;
+    let all = 0;
+    for (const t of list) {
+        if (!t || t.cacheRead === undefined)
+            continue;
+        read += t.cacheRead;
+        all += t.input;
+    }
+    return all > 0 ? read / all : null;
+}
+/** A run's token counts, summed over its steps; null when no step reported any. */
+export function runTokens(run) {
+    const toks = run.steps.map((s) => s.tokens).filter((t) => !!t);
+    return toks.length ? sumTokens(toks) : null;
+}
 export function runFilePath(tenant, workspace, runId) {
     assertSafeName(runId, "run id");
     return path.join(workspaceDir(tenant, workspace), "runs", `${runId}.json`);

package/dist/src/tool-loop.d.ts

@@ -13,9 +13,12 @@ export interface LoopTool {
     run: (args: Record<string, string | undefined>) => Promise<string> | string;
 }
 export interface LoopUsage {
-    /** Everything sent, cache reads and writes included. */
+    /** Everything sent, cache reads and writes included; the two cache
+     *  fields say how much of it the prompt cache served or stored. */
     inputTokens: number;
     outputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
     costUsd: number;
 }
 export interface LoopResult {

package/dist/src/tool-loop.js

@@ -170,6 +170,8 @@ export async function runToolLoop(o) {
                 usage = {
                     inputTokens: models.reduce((n, m) => n + (m.inputTokens ?? 0) + (m.cacheReadInputTokens ?? 0) + (m.cacheCreationInputTokens ?? 0), 0),
                     outputTokens: models.reduce((n, m) => n + (m.outputTokens ?? 0), 0),
+                    cacheReadTokens: models.reduce((n, m) => n + (m.cacheReadInputTokens ?? 0), 0),
+                    cacheWriteTokens: models.reduce((n, m) => n + (m.cacheCreationInputTokens ?? 0), 0),
                     costUsd,
                 };
                 if (message.subtype === "success") {

package/dist/src/translator.d.ts

@@ -1,4 +1,16 @@
 type Json = Record<string, unknown>;
+/**
+ * An OpenAI-shaped usage object as Anthropic's: fresh input, cached input,
+ * output. Both OpenAI shapes count the cached part INSIDE the prompt total
+ * (Chat's prompt_tokens_details.cached_tokens, Responses'
+ * input_tokens_details.cached_tokens; DeepSeek says prompt_cache_hit_tokens),
+ * so it is taken out of input here or the step would count it twice.
+ */
+export declare function anthropicUsage(u: Json | undefined, wire: TranslatorWire): {
+    input: number;
+    cached: number;
+    output: number;
+};
 export type TranslatorWire = "chat" | "responses";
 export interface TranslatorSpec {
     /** The provider's base, e.g. https://api.openai.com/v1 — `/chat/completions`

package/dist/src/translator.js

@@ -22,7 +22,9 @@
 // and their results, streaming — and drops what a Chat-Completions endpoint
 // has no word for (cache_control, top_k, server-side tools, thinking on
 // endpoints that lack reasoning_effort). Anything dropped is said once in
-// the run trace. The translation is pure functions over JSON so the tests
+// the run trace. Those endpoints cache prompt prefixes on their own side;
+// the cached share they report comes back as cache_read_input_tokens, so a
+// step's record says how much of its context was re-read. The translation is pure functions over JSON so the tests
 // can drive every mapping without a network; the server around them is a
 // few dozen lines.
 import http from "node:http";
@@ -31,6 +33,33 @@ import { PROTECTED_PARAMS } from "./providers.js";
 import { viaEgress } from "./egress.js";
 import { trimSlashes } from "./paths.js";
 import { captureRefusalHeaders, isRefusalStatus, refusalLine } from "./refusal.js";
+/**
+ * An OpenAI-shaped usage object as Anthropic's: fresh input, cached input,
+ * output. Both OpenAI shapes count the cached part INSIDE the prompt total
+ * (Chat's prompt_tokens_details.cached_tokens, Responses'
+ * input_tokens_details.cached_tokens; DeepSeek says prompt_cache_hit_tokens),
+ * so it is taken out of input here or the step would count it twice.
+ */
+export function anthropicUsage(u, wire) {
+    if (!u)
+        return { input: 0, cached: 0, output: 0 };
+    const total = Number((wire === "chat" ? u.prompt_tokens : u.input_tokens) ?? 0);
+    const details = (wire === "chat" ? u.prompt_tokens_details : u.input_tokens_details);
+    const raw = Number(details?.cached_tokens ?? u.prompt_cache_hit_tokens ?? 0);
+    const cached = Number.isFinite(raw) ? Math.max(0, Math.min(raw, total)) : 0;
+    return {
+        input: total - cached,
+        cached,
+        output: Number((wire === "chat" ? u.completion_tokens : u.output_tokens) ?? 0),
+    };
+}
+function usageBlock(u) {
+    return {
+        input_tokens: u?.input ?? 0,
+        output_tokens: u?.output ?? 0,
+        ...(u && u.cached > 0 ? { cache_read_input_tokens: u.cached } : {}),
+    };
+}
 function dropped() {
     const seen = new Set();
     return {
@@ -466,10 +495,7 @@ export function fromChatCompletion(res, requestedModel, stopSequences) {
         content,
         stop_reason: stop.reason,
         stop_sequence: stop.sequence,
-        usage: {
-            input_tokens: Number(usage.prompt_tokens ?? 0),
-            output_tokens: Number(usage.completion_tokens ?? 0),
-        },
+        usage: usageBlock(anthropicUsage(usage, "chat")),
     };
 }
 /**
@@ -532,7 +558,7 @@ export class StreamTranslator {
         const out = this.start(chunk);
         const u = chunk.usage;
         if (u && (u.prompt_tokens !== undefined || u.completion_tokens !== undefined)) {
-            this.usage = { input: Number(u.prompt_tokens ?? 0), output: Number(u.completion_tokens ?? 0) };
+            this.usage = anthropicUsage(u, "chat");
         }
         const choice = (chunk.choices ?? [])[0];
         if (!choice)
@@ -609,7 +635,7 @@ export class StreamTranslator {
         out.push(this.event("message_delta", {
             type: "message_delta",
             delta: { stop_reason: stop.reason, stop_sequence: stop.sequence },
-            usage: { input_tokens: this.usage?.input ?? 0, output_tokens: this.usage?.output ?? 0 },
+            usage: usageBlock(this.usage),
         }));
         out.push(this.event("message_stop", { type: "message_stop" }));
         return out;
@@ -648,10 +674,7 @@ export function fromResponses(res, requestedModel) {
         content,
         stop_reason: stop,
         stop_sequence: null,
-        usage: {
-            input_tokens: Number(usage.input_tokens ?? 0),
-            output_tokens: Number(usage.output_tokens ?? 0),
-        },
+        usage: usageBlock(anthropicUsage(usage, "responses")),
     };
 }
 /**
@@ -768,7 +791,7 @@ export class ResponsesStreamTranslator {
             const r = ev.response ?? {};
             const u = r.usage;
             if (u)
-                this.usage = { input: Number(u.input_tokens ?? 0), output: Number(u.output_tokens ?? 0) };
+                this.usage = anthropicUsage(u, "responses");
             const reason = r.incomplete_details?.reason;
             if (typeof reason === "string")
                 this.incomplete = reason;
@@ -790,7 +813,7 @@ export class ResponsesStreamTranslator {
         out.push(this.event("message_delta", {
             type: "message_delta",
             delta: { stop_reason: reason, stop_sequence: null },
-            usage: { input_tokens: this.usage?.input ?? 0, output_tokens: this.usage?.output ?? 0 },
+            usage: usageBlock(this.usage),
         }));
         out.push(this.event("message_stop", { type: "message_stop" }));
         return out;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foldrun/core",
-  "version": "2.0.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)
@@ -245,13 +260,62 @@ export function clampEffort(
 export function catalogCost(
   catalog: Catalog | null,
   modelId: string,
-  usage: { inputTokens: number; outputTokens: number },
+  usage: { inputTokens: number; outputTokens: number; cacheReadTokens?: number; cacheWriteTokens?: number },
 ): number | null {
   const m = findModel(catalog, modelId);
   if (!m || m.promptPrice == null || m.completionPrice == null) return null;
-  return usage.inputTokens * m.promptPrice + usage.outputTokens * m.completionPrice;
+  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);
+  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. 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
  *  one capability that decides agent-worthiness. Tool-capable models first —
  *  on an agent platform they are almost always what the author wants. */

package/src/deploy.ts

@@ -26,6 +26,7 @@ import {
   keptOnDeploy,
   workspaceDir,
   listRunSummaries,
+  listWorkspaceFiles,
   parseFlow,
   parseToolDef,
   WORKSPACE_DIRS,
@@ -460,7 +461,7 @@ export function runsInFlight(tenant: string, workspace: string): string[] {
 }
 
 /** What a deploy would do, without doing it. */
-export function planDeploy(tenant: string, workspace: string, files: DeployFile[]): DeployPlan {
+export function planDeploy(tenant: string, workspace: string, files: DeployFile[], opts: { keepUntracked?: boolean } = {}): DeployPlan {
   const dir = workspaceDir(tenant, workspace);
   const shipped = new Map(files.map((f) => [path.normalize(f.path), f.content]));
 
@@ -498,7 +499,10 @@ export function planDeploy(tenant: string, workspace: string, files: DeployFile[
   // memory, the platform's own files. Reporting these as removals would be
   // a lie, and the alarming kind; one predicate serves both.
   const shippedPaths = new Set(shipped.keys());
-  const removed = [...present].filter((rel) => !shipped.has(rel) && !keptOnDeploy(rel, shippedPaths));
+  // keepUntracked (a restore): what is not editable source stays, as
+  // saveWorkspace keeps it — see its meta.keepUntracked.
+  const tracked = opts.keepUntracked ? new Set(listWorkspaceFiles(tenant, workspace)) : null;
+  const removed = [...present].filter((rel) => !shipped.has(rel) && !keptOnDeploy(rel, shippedPaths) && (!tracked || tracked.has(rel)));
 
   return {
     files,
@@ -528,6 +532,9 @@ export interface DeployOptions {
    * no window between the check and the swap. Absent: no check, as before.
    */
   expectRemoved?: string[];
+  /** Keep what is not editable source (planDeploy, saveWorkspace): a
+   *  restore takes history's tree, and history tracks source only. */
+  keepUntracked?: boolean;
 }
 
 /**
@@ -547,7 +554,7 @@ export function deployWorkspace(
   assertSafeName(tenant, "tenant");
   assertSafeName(workspace, "workspace");
 
-  const plan = planDeploy(tenant, workspace, files);
+  const plan = planDeploy(tenant, workspace, files, { keepUntracked: opts.keepUntracked });
   const blocked = plan.blockedBy.length > 0 && !opts.force;
   if (plan.issues.length > 0 || blocked) {
     return { ...plan, applied: false, commit: null, preserved: 0 };
@@ -560,7 +567,7 @@ export function deployWorkspace(
     }
   }
 
-  const { preserved } = saveWorkspace(tenant, workspace, files, { commit: opts.commit ?? null, by: opts.by ?? "deploy", message: opts.message });
+  const { preserved } = saveWorkspace(tenant, workspace, files, { commit: opts.commit ?? null, by: opts.by ?? "deploy", message: opts.message, keepUntracked: opts.keepUntracked });
   const commit = opts.commit ?? null;
   if (commit) writeDeployedCommit(tenant, workspace, commit);
   return { ...plan, applied: true, commit, preserved }; // saveWorkspace told the platform

package/src/model-credential.ts

@@ -75,7 +75,7 @@ export function credentialLine(c: ModelCredential): { type: "info" | "error"; te
 //
 // An account brings its own model key without writing a provider: block:
 // three secrets in the ACCOUNT vault (set from Settings → Model, the API's
-// /api/account/model, or `foldrun model set`). A provider: block at any
+// /api/account/model, or `foldrun account model set`). A provider: block at any
 // level still wins; this is what a step falls to when none names one, before
 // the platform's own credential.
 

package/src/model-env.ts

@@ -23,7 +23,7 @@ export class ModelKeyError extends Error {
 
 export const NO_MODEL_KEY =
   "no model key: this account runs on its own API key, and none is set — add one in Settings → Model " +
-  "(or `foldrun model set <provider> --key …`), or write a provider: block in AGENTS.md";
+  "(or `foldrun account model set <provider> --key …`), or write a provider: block in AGENTS.md";
 
 /**
  * `platform` is a function: the caller's own way to build the platform's env

package/src/run-container.ts

@@ -27,7 +27,8 @@ import { spawn, spawnSync } from "node:child_process";
 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 } from "./step-exec.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";
@@ -184,7 +185,7 @@ export interface ContainerStepOutcome {
   /** The parsed JSON of an `output: json` step, crossing back as a value. */
   data?: unknown;
   costUsd: number | null;
-  usage?: { inputTokens: number; outputTokens: number } | null;
+  usage?: ExecUsage | null;
   /** Every turn priced at its own model, when sub-agents ran on others —
    *  see ExecOutcome.turnsCostUsd. */
   turnsCostUsd?: number;
@@ -1216,7 +1217,14 @@ export function parseDriverLine(
           parsed.usage &&
           typeof parsed.usage.inputTokens === "number" &&
           typeof parsed.usage.outputTokens === "number"
-            ? { inputTokens: parsed.usage.inputTokens, outputTokens: parsed.usage.outputTokens }
+            ? {
+                inputTokens: parsed.usage.inputTokens,
+                outputTokens: parsed.usage.outputTokens,
+                // A driver from before the split sends neither; zero, not
+                // unknown, keeps the record's shape one thing.
+                cacheReadTokens: typeof parsed.usage.cacheReadTokens === "number" ? parsed.usage.cacheReadTokens : 0,
+                cacheWriteTokens: typeof parsed.usage.cacheWriteTokens === "number" ? parsed.usage.cacheWriteTokens : 0,
+              }
             : null,
         res:
           parsed.res && typeof parsed.res === "object"