@basein/runner 0.3.25 → 0.3.27

package/dist/replay/plan.js

@@ -132,6 +132,47 @@ function clipReasoning(reasoning) {
     const first = (reasoning ?? "").trim().split(/\r?\n/, 1)[0]?.trim() ?? "";
     return first.length > MAX_REASONING_CHARS ? `${first.slice(0, MAX_REASONING_CHARS)}…` : first;
 }
+// ── the recording's values in a directive's text (B2 is11.md) ────────────────
+/**
+ * A recorded value as a text may name it: a string or a number at least this
+ * long — a one-character sample ("5", "a") is found in too many words — and
+ * no longer than a name or a title is.
+ */
+const RECORDED_VALUE_MIN = 2;
+const RECORDED_VALUE_MAX = 200;
+/** One of this request's values, as a directive shows it: this long at most. */
+const SHOWN_VALUE_MAX = 60;
+/** This many of this request's values at most on a direct directive's values line… */
+const SHOWN_VALUES = 4;
+/** …and this long at most, all of them. */
+const SHOWN_VALUES_CHARS = 200;
+/** The recorded value `value` as a text may name it, or undefined. */
+function recordedText(value) {
+    const text = typeof value === "number" && Number.isFinite(value)
+        ? String(value)
+        : typeof value === "string"
+            ? value.trim()
+            : undefined;
+    return text !== undefined && text.length >= RECORDED_VALUE_MIN && text.length <= RECORDED_VALUE_MAX ? text : undefined;
+}
+/** A value of this request's as plain text — never a mark — or undefined. */
+function valueText(value) {
+    let text;
+    if (typeof value === "boolean")
+        text = String(value);
+    else if (typeof value === "number" && Number.isFinite(value))
+        text = String(value);
+    else if (typeof value === "string")
+        text = value.replace(/\s+/g, " ").trim();
+    if (!text || markedKey(text) !== undefined)
+        return undefined;
+    return text;
+}
+const clipValue = (text) => text.length > SHOWN_VALUE_MAX ? `${text.slice(0, SHOWN_VALUE_MAX)}…` : text;
+const sameText = (a, b) => a.toLowerCase() === b.toLowerCase();
+const escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/** A parameter's role, for a value a text must not name: `assignee_name` → `<assignee name>`. */
+const roleOf = (key) => `<${key.replace(/[_-]+/g, " ").trim() || key}>`;
 /** A step's computed arguments, as a steer directive shows them: this long at most. */
 const MAX_DIRECTIVE_ARGS_CHARS = 240;
 /**
@@ -854,6 +895,120 @@ export class ScenarioReplayPlan {
         }
         return out;
     }
+    /**
+     * This request's value of `key`, as a directive may show it, or undefined
+     * (B2 is11.md): once the reading has settled, a plain value the reading
+     * took from the request — never a mark, and never a value a step works out
+     * (`from: "step"`): before the run nobody has that one, and the recorded one
+     * is another request's (issue 1212).
+     */
+    shownValueOf(key, p) {
+        if (!this.paramsSettled || p?.from === "step")
+            return undefined;
+        return valueText(this.derivedParams[key]);
+    }
+    /**
+     * A text written from the recording — the intent, a step's reasoning — put
+     * right for this request, for a directive to show (B2 is11.md).
+     *
+     * Both name the recording's values: "set Olga up", "moves each lead to
+     * Olga". Shown beside a request for Carlos, the name tells the model the
+     * plan is for someone else. A careful model then checks before it runs
+     * anything, and a direct plan's first call that was not `run_scenario`
+     * retired it — so the replay was lost on exactly the turn replay is for: the
+     * same task with a new value. The steps never read the text: they take
+     * Carlos from the request.
+     *
+     * Each recorded value of a parameter found in the text, as a whole word, is
+     * replaced by this request's own value where the plan has one it may show
+     * ({@link shownValueOf}), and else by the parameter's role (`<assignee
+     * name>`): a target the request did not name, a value a step works out, or
+     * any value while the reading has not settled. A value the same as the
+     * recorded one stays as it is. One pass, longest value first, so nothing put
+     * in is replaced again.
+     */
+    forThisRequest(text) {
+        return this.rewriter()(text);
+    }
+    /** {@link forThisRequest} as one function, built once for a directive's many texts. */
+    rewriter() {
+        const schema = this.scenario.paramsObject;
+        if (!schema || typeof schema !== "object")
+            return (text) => text;
+        /** Recorded value (lower case) → what goes in its place; null where it stays. */
+        const swaps = new Map();
+        for (const [key, p] of Object.entries(schema)) {
+            const recorded = recordedText(p?.sampleValue);
+            if (!recorded)
+                continue;
+            const now = this.shownValueOf(key, p);
+            const swap = now !== undefined && sameText(now, recorded) ? null : now !== undefined ? clipValue(now) : roleOf(key);
+            const k = recorded.toLowerCase();
+            // Two parameters recorded with one value: a change wins over "stays".
+            if (!swaps.has(k) || swaps.get(k) === null)
+                swaps.set(k, swap);
+        }
+        const found = [...swaps.entries()].filter(([, swap]) => swap !== null).map(([k]) => k);
+        if (found.length === 0)
+            return (text) => text;
+        found.sort((a, b) => b.length - a.length);
+        let pattern;
+        try {
+            pattern = new RegExp(`(?<![\\p{L}\\p{N}_])(?:${found.map(escapeRegExp).join("|")})(?![\\p{L}\\p{N}_])`, "giu");
+        }
+        catch {
+            return (text) => text;
+        }
+        return (text) => (text ? text.replace(pattern, (m) => swaps.get(m.toLowerCase()) ?? m) : text);
+    }
+    /**
+     * This request's own values, for the direct directive's line that says the
+     * steps take them (B2 is11.md): what the reading took from the request.
+     * The values the request names in words come first — a name, a title: what
+     * a reader holds the note against — those unlike the recording's first;
+     * then the values worked out from the day ("tomorrow" as a date). Targets
+     * only: never a setting, never a value a step works out, never a mark.
+     * Undefined until the reading has settled, or when it named none.
+     */
+    requestValues() {
+        if (!this.paramsSettled)
+            return undefined;
+        const schema = this.scenario.paramsObject;
+        if (!schema || typeof schema !== "object")
+            return undefined;
+        const items = [];
+        let order = 0;
+        for (const [key, p] of Object.entries(schema)) {
+            order += 1;
+            if (p?.kind === "setting")
+                continue;
+            const now = this.shownValueOf(key, p);
+            if (now === undefined)
+                continue;
+            const recorded = recordedText(p?.sampleValue);
+            items.push({
+                key,
+                text: clipValue(now),
+                // Named in the request's own words; an older service sends no `from`.
+                said: p?.from === undefined || p.from === "prompt",
+                differs: recorded !== undefined && !sameText(now, recorded),
+                order,
+            });
+        }
+        items.sort((a, b) => Number(b.said) - Number(a.said) || Number(b.differs) - Number(a.differs) || a.order - b.order);
+        const parts = [];
+        let chars = 0;
+        for (const item of items) {
+            if (parts.length >= SHOWN_VALUES)
+                break;
+            const part = `${item.key} ${JSON.stringify(item.text)}`;
+            if (parts.length > 0 && chars + part.length > SHOWN_VALUES_CHARS)
+                break;
+            parts.push(part);
+            chars += part.length + 2;
+        }
+        return parts.length > 0 ? parts.join(", ") : undefined;
+    }
     /**
      * The directive injected via `UserPromptSubmit`'s `additionalContext`.
      *
@@ -880,9 +1035,14 @@ export class ScenarioReplayPlan {
         // A sub-task plan (armed mid-task) never tells the agent to stop calling
         // tools: the steps below are a part of the task it is already doing.
         const subTask = opts?.subTask ?? this.subTask;
+        // The intent and each step's reasoning were written from the recording,
+        // so they name its values ("set Olga up"); shown here, they say this
+        // request's — or the value's role — never another request's (B2 is11.md).
+        const fix = this.rewriter();
         // The intent is a paragraph the analyser wrote; it is context, not an
         // instruction, so it is clipped rather than dumped whole into the prompt.
-        const intent = this.intent.length > 240 ? `${this.intent.slice(0, 240)}…` : this.intent;
+        const written = fix(this.intent);
+        const intent = written.length > 240 ? `${written.slice(0, 240)}…` : written;
         if (this.mode === "direct") {
             // The steps are not listed. The model does not call them, and what the
             // tool returns names every call and says whether the run was whole or
@@ -890,9 +1050,17 @@ export class ScenarioReplayPlan {
             // cost the agent up to 2,000 characters in the first call of every turn
             // a plan was armed for (docs/calculatedReplay.md, "How a bundle reads"),
             // and the tool's result shows an operator watching the session what ran.
+            //
+            // One line says where the steps' values come from, with this request's
+            // own: a model that met another request's value in the note used to
+            // stop to check, and its check retired the plan (B2 is11.md).
+            const values = this.requestValues();
             return [
                 "[BaseInstRunner calculated replay] A known-good tool sequence was recorded",
-                `for this request${intent ? ` (intent: ${intent})` : ""}.`,
+                `for a request like this one${intent ? ` (intent: ${intent})` : ""}.`,
+                values
+                    ? `Its steps take this request's values, not the recording's: ${values}.`
+                    : "Its steps take this request's values, not the recording's.",
                 "",
                 `Call ${directToolName} once, with no arguments, before any other tool. It runs the`,
                 "sequence and returns what each call did.",
@@ -924,7 +1092,7 @@ export class ScenarioReplayPlan {
             return ` (only when ${t.text ?? "this request needs it"})`;
         };
         const listing = (withWhy, argsBefore) => planned.map((s, i) => {
-            const why = withWhy ? clipReasoning(s.reasoning) : "";
+            const why = withWhy ? clipReasoning(fix(s.reasoning ?? "")) : "";
             const head = `  ${i + 1}. ${s.toolName}${onlyWhen(i)}${why ? ` — ${why}` : ""}`;
             const shown = i < argsBefore ? args[i] : undefined;
             return shown ? `${head}\n     ${shown}` : head;

package/dist/replay/pricing.d.ts

@@ -15,27 +15,77 @@
  * numbers are comparable. For that row, right now, they are not.
  *
  * Bump the version — on **every** side — whenever a row changes.
+ *
+ * WHAT A PRICE DEPENDS ON BESIDE THE MODEL (Anthropic's pricing page, read
+ * 2026-11-11). Until this version a turn was priced from four token counts per
+ * model, and three things the bill reads were not looked at:
+ *
+ * - WHICH CACHE WAS WRITTEN. A 5-minute cache write bills at 1.25x input, a
+ *   1-hour one at 2x. Claude Code writes the 1-hour cache: in the transcripts
+ *   this was checked against, every cache write was a 1-hour one, and each was
+ *   priced 37.5% too low.
+ * - THE REQUEST'S OWN PROMPT LENGTH, on Claude Haiku 5.5: a request whose prompt
+ *   (input, cache reads and cache writes together) is over 100,000 tokens pays
+ *   five times the price. Each request is priced on its own.
+ * - HOW THE REQUEST RAN: fast mode bills at twice the standard prices, and
+ *   US-only inference at 1.1x.
+ *
+ * So a usage now says these of itself ({@link TokenUsage}), and whoever folds
+ * requests into totals keeps the requests that are priced differently apart
+ * ({@link requestRates}).
  */
 /** Identifies {@link MODEL_PRICING}. Must equal the service's constant. */
-export declare const PRICING_VERSION = "2026-09-24";
-/**
- * Tolerate provider prefixes (`anthropic/`, `us.anthropic.`), date snapshots and
- * unseen version bumps by falling back to the longest matching family, so a new
- * snapshot never silently prices at $0.
- */
-export declare function resolveModelPricing(model: string): {
+export declare const PRICING_VERSION = "2026-11-11";
+/** One rate card, in $/million tokens. */
+export interface ModelRates {
     input: number;
     output: number;
     cacheRead: number;
+    /** A write to the 5-minute cache. */
     cacheWrite: number;
-} | undefined;
-export declare function hasModelPricing(model: string): boolean;
-export interface TokenUsage {
+    /** A write to the 1-hour cache. */
+    cacheWrite1h: number;
+}
+/**
+ * A model's rate card, or undefined when the table has no row for it. With
+ * `longPrompt`, the card of a request over the model's prompt-length
+ * threshold, for a model that has one.
+ */
+export declare function resolveModelPricing(name: string, opts?: {
+    longPrompt?: boolean;
+}): ModelRates | undefined;
+export declare function hasModelPricing(name: string): boolean;
+/** What of a request, beside its model and its token counts, sets its prices. */
+export interface RateFlags {
+    /** Its prompt was over the model's long-prompt threshold (Haiku 5.5: 100,000 tokens). */
+    longPrompt?: boolean;
+    /** It ran in fast mode. */
+    fast?: boolean;
+    /** It ran on US-only inference. */
+    usOnly?: boolean;
+}
+export interface TokenUsage extends RateFlags {
     inputTokens: number;
     outputTokens: number;
     cacheReadTokens?: number;
+    /** Every cache write, the 1-hour ones among them. */
     cacheCreationTokens?: number;
+    /** Of {@link cacheCreationTokens}, the tokens written to the 1-hour cache. */
+    cacheCreation1hTokens?: number;
 }
+/**
+ * The flags of ONE request, from its own `usage` as the API reports it: its
+ * prompt length (input, cache reads and cache writes together), its `speed`
+ * and its `inference_geo`. Only what is so is set, so two requests priced
+ * alike give equal flags — and {@link rateKey} the same key.
+ */
+export declare function requestRates(name: string, request: {
+    promptTokens: number;
+    speed?: unknown;
+    inferenceGeo?: unknown;
+}): RateFlags;
+/** A short text that is equal for two sets of flags exactly when they price alike. "" for none. */
+export declare function rateKey(flags: RateFlags): string;
 /** Cost in USD. An unpriced model yields 0 — the caller reports `measured: false`. */
-export declare function calculateCostUsd(model: string, usage: TokenUsage): number;
+export declare function calculateCostUsd(name: string, usage: TokenUsage): number;
 //# sourceMappingURL=pricing.d.ts.map

package/dist/replay/pricing.js

@@ -15,70 +15,163 @@
  * numbers are comparable. For that row, right now, they are not.
  *
  * Bump the version — on **every** side — whenever a row changes.
+ *
+ * WHAT A PRICE DEPENDS ON BESIDE THE MODEL (Anthropic's pricing page, read
+ * 2026-11-11). Until this version a turn was priced from four token counts per
+ * model, and three things the bill reads were not looked at:
+ *
+ * - WHICH CACHE WAS WRITTEN. A 5-minute cache write bills at 1.25x input, a
+ *   1-hour one at 2x. Claude Code writes the 1-hour cache: in the transcripts
+ *   this was checked against, every cache write was a 1-hour one, and each was
+ *   priced 37.5% too low.
+ * - THE REQUEST'S OWN PROMPT LENGTH, on Claude Haiku 5.5: a request whose prompt
+ *   (input, cache reads and cache writes together) is over 100,000 tokens pays
+ *   five times the price. Each request is priced on its own.
+ * - HOW THE REQUEST RAN: fast mode bills at twice the standard prices, and
+ *   US-only inference at 1.1x.
+ *
+ * So a usage now says these of itself ({@link TokenUsage}), and whoever folds
+ * requests into totals keeps the requests that are priced differently apart
+ * ({@link requestRates}).
  */
 /** Identifies {@link MODEL_PRICING}. Must equal the service's constant. */
-export const PRICING_VERSION = "2026-09-24";
+export const PRICING_VERSION = "2026-11-11";
 /**
- * A 5-minute cache write bills at 1.25x input. Cache reads bill at 0.1x input,
- * except on models whose list price says otherwise (Opus 5.5, Fable 5.1), which
- * pass their read price in dollars.
+ * A rate card from its list prices. A 5-minute cache write bills at 1.25x
+ * input and a 1-hour one at 2x, on every model. A cache read bills at 0.1x
+ * input, except on the models whose list price says otherwise (0.05x on Opus
+ * 5.5 and Sonnet 5.5; 0.025x on Fable and Mythos 5.1 and 5.2), which pass
+ * their read price in dollars.
  */
 const priced = (input, output, cacheRead = input * 0.1) => ({
     input,
     output,
     cacheRead,
     cacheWrite: input * 1.25,
+    cacheWrite1h: input * 2,
 });
-const MODEL_PRICING = {
-    "claude-haiku-4-5": priced(1.0, 5.0),
-    "claude-haiku-4-5-20251001": priced(1.0, 5.0),
-    "claude-sonnet-4-5": priced(3.0, 15.0),
-    "claude-sonnet-4-6": priced(3.0, 15.0),
-    "claude-sonnet-5": priced(2.0, 10.0),
-    "claude-opus-4-5": priced(5.0, 25.0),
-    "claude-opus-4-6": priced(5.0, 25.0),
-    "claude-opus-4-7": priced(5.0, 25.0),
-    "claude-opus-4-8": priced(5.0, 25.0),
-    "claude-opus-5": priced(5.0, 25.0),
-    "claude-opus-5-5": priced(4.0, 20.0, 0.2),
-    "claude-fable-5": priced(10.0, 50.0),
-    "claude-fable-5-1": priced(10.0, 50.0, 0.25),
-};
+const model = (rates, longPrompt) => longPrompt ? { rates, longPrompt } : { rates };
+/**
+ * A Map, not an object: a model's name comes from a transcript or from another
+ * host's payload, and `table["constructor"]` on an object is a function, which
+ * priced a turn at NaN.
+ */
+const MODEL_PRICING = new Map([
+    ["claude-haiku-4-5", model(priced(1.0, 5.0))],
+    // Priced by prompt length: up to 100,000 tokens, and over.
+    ["claude-haiku-5-5", model(priced(0.1, 0.5), { overTokens: 100_000, rates: priced(0.5, 2.5) })],
+    ["claude-sonnet-4", model(priced(3.0, 15.0))],
+    ["claude-sonnet-4-0", model(priced(3.0, 15.0))],
+    ["claude-sonnet-4-5", model(priced(3.0, 15.0))],
+    ["claude-sonnet-4-6", model(priced(3.0, 15.0))],
+    ["claude-sonnet-5", model(priced(2.0, 10.0))],
+    ["claude-sonnet-5-5", model(priced(2.0, 10.0, 0.1))],
+    ["claude-opus-4", model(priced(15.0, 75.0))],
+    ["claude-opus-4-0", model(priced(15.0, 75.0))],
+    ["claude-opus-4-1", model(priced(15.0, 75.0))],
+    ["claude-opus-4-5", model(priced(5.0, 25.0))],
+    ["claude-opus-4-6", model(priced(5.0, 25.0))],
+    ["claude-opus-4-7", model(priced(5.0, 25.0))],
+    ["claude-opus-4-8", model(priced(5.0, 25.0))],
+    ["claude-opus-5", model(priced(5.0, 25.0))],
+    ["claude-opus-5-5", model(priced(4.0, 20.0, 0.2))],
+    ["claude-fable-5", model(priced(10.0, 50.0))],
+    ["claude-fable-5-1", model(priced(10.0, 50.0, 0.25))],
+    ["claude-fable-5-2", model(priced(8.0, 40.0, 0.2))],
+    ["claude-mythos-5", model(priced(10.0, 50.0))],
+    ["claude-mythos-5-1", model(priced(10.0, 50.0, 0.25))],
+    ["claude-mythos-5-2", model(priced(8.0, 40.0, 0.2))],
+]);
+/** Fast mode bills every kind of token at twice the standard price. */
+const FAST_FACTOR = 2;
+/** US-only inference (`inference_geo: "us"`) bills every kind of token at 1.1x. */
+const US_ONLY_FACTOR = 1.1;
+/**
+ * What may follow a model's name and still be that model: a dated snapshot
+ * (`-20251001`, `@20251001`), a cloud's version tag (`-v1:0`), `-latest`.
+ */
+const SNAPSHOT_SUFFIX = /^(?:[-@]\d{8})?(?:-v\d+(?::\d+)?)?(?:-latest)?$/;
 /**
- * Tolerate provider prefixes (`anthropic/`, `us.anthropic.`), date snapshots and
- * unseen version bumps by falling back to the longest matching family, so a new
- * snapshot never silently prices at $0.
+ * The table's row for a name: the name itself, or the name with a provider
+ * prefix (`anthropic/`, `us.anthropic.`), a host's tag (`[1m]`) or a snapshot
+ * suffix taken off.
+ *
+ * NEVER A NEWER VERSION PRICED AS AN OLDER ONE. This used to take the longest
+ * row that prefixed the name, "so a new snapshot never silently prices at $0".
+ * A new *version* is not a snapshot: `claude-opus-5-5` was priced as Opus 5
+ * until its row came, and `claude-fable-5-2` as Fable 5 — a quarter too dear
+ * on input and output, five times on cache reads — and each such turn was
+ * reported as measured. A version with no row has no price: the turn is
+ * reported unmeasured, and says which model to add (`run.unmeasured`).
  */
-export function resolveModelPricing(model) {
-    const exact = MODEL_PRICING[model];
+function pricedModel(name) {
+    const exact = MODEL_PRICING.get(name);
     if (exact)
         return exact;
-    // Strip a provider prefix: "us.anthropic.claude-haiku-4-5-v1:0" → "claude-haiku-4-5-v1:0".
-    const idx = model.indexOf("claude-");
-    const bare = idx >= 0 ? model.slice(idx) : model;
-    if (MODEL_PRICING[bare])
-        return MODEL_PRICING[bare];
-    // Longest declared family that prefixes the name — so a dated snapshot of a
-    // known model prices as that model rather than as nothing.
+    const at = name.indexOf("claude-");
+    const bare = (at >= 0 ? name.slice(at) : name).replace(/\[[^\]]*\]$/, "");
+    const known = MODEL_PRICING.get(bare);
+    if (known)
+        return known;
     let best;
-    for (const key of Object.keys(MODEL_PRICING)) {
-        if (bare.startsWith(key) && (!best || key.length > best.length))
+    for (const key of MODEL_PRICING.keys()) {
+        if (!bare.startsWith(key) || !SNAPSHOT_SUFFIX.test(bare.slice(key.length)))
+            continue;
+        if (!best || key.length > best.length)
             best = key;
     }
-    return best ? MODEL_PRICING[best] : undefined;
+    return best ? MODEL_PRICING.get(best) : undefined;
+}
+/**
+ * A model's rate card, or undefined when the table has no row for it. With
+ * `longPrompt`, the card of a request over the model's prompt-length
+ * threshold, for a model that has one.
+ */
+export function resolveModelPricing(name, opts = {}) {
+    const row = pricedModel(name);
+    if (!row)
+        return undefined;
+    return opts.longPrompt && row.longPrompt ? row.longPrompt.rates : row.rates;
+}
+export function hasModelPricing(name) {
+    return pricedModel(name) !== undefined;
+}
+/**
+ * The flags of ONE request, from its own `usage` as the API reports it: its
+ * prompt length (input, cache reads and cache writes together), its `speed`
+ * and its `inference_geo`. Only what is so is set, so two requests priced
+ * alike give equal flags — and {@link rateKey} the same key.
+ */
+export function requestRates(name, request) {
+    const flags = {};
+    const over = pricedModel(name)?.longPrompt?.overTokens;
+    if (over !== undefined && request.promptTokens > over)
+        flags.longPrompt = true;
+    if (request.speed === "fast")
+        flags.fast = true;
+    if (request.inferenceGeo === "us")
+        flags.usOnly = true;
+    return flags;
 }
-export function hasModelPricing(model) {
-    return resolveModelPricing(model) !== undefined;
+/** A short text that is equal for two sets of flags exactly when they price alike. "" for none. */
+export function rateKey(flags) {
+    return `${flags.longPrompt ? "|long" : ""}${flags.fast ? "|fast" : ""}${flags.usOnly ? "|us" : ""}`;
 }
 /** Cost in USD. An unpriced model yields 0 — the caller reports `measured: false`. */
-export function calculateCostUsd(model, usage) {
-    const p = resolveModelPricing(model);
+export function calculateCostUsd(name, usage) {
+    const p = resolveModelPricing(name, usage);
     if (!p)
         return 0;
+    const writes = Math.max(0, usage.cacheCreationTokens ?? 0);
+    const writes1h = Math.min(writes, Math.max(0, usage.cacheCreation1hTokens ?? 0));
+    const factor = (usage.fast ? FAST_FACTOR : 1) * (usage.usOnly ? US_ONLY_FACTOR : 1);
     const perToken = 1e-6;
-    return (usage.inputTokens * p.input * perToken +
-        usage.outputTokens * p.output * perToken +
-        (usage.cacheReadTokens ?? 0) * p.cacheRead * perToken +
-        (usage.cacheCreationTokens ?? 0) * p.cacheWrite * perToken);
+    return (factor *
+        perToken *
+        (usage.inputTokens * p.input +
+            usage.outputTokens * p.output +
+            (usage.cacheReadTokens ?? 0) * p.cacheRead +
+            (writes - writes1h) * p.cacheWrite +
+            writes1h * p.cacheWrite1h));
 }
 //# sourceMappingURL=pricing.js.map

package/dist/replay/reads-only.d.ts

@@ -0,0 +1,48 @@
+/**
+ * reads-only — whether one call of the agent's only looks, and changes nothing.
+ *
+ * WHY THE RUNNER ASKS (B2 is11.md, 2026-11-11). A direct plan is announced
+ * with "call run_scenario before any other tool", and a first call that is
+ * not `run_scenario` used to retire it on the spot (control/server.ts). The
+ * rule is there for one danger: a model that has no `run_scenario` makes its
+ * own calls, and a divergence would then run every step, writes included,
+ * inside a hook nobody approves. But the call that retired the plan in is11
+ * was the agent reading its own notes file: it had seen another person's name
+ * in the note (Olga, the recording's; the request said Carlos) and checked
+ * first. The plan would have done the task right — its steps take the person
+ * from the request — and the turn cost a full agent run.
+ *
+ * So a call that only looks no longer retires a direct plan: it runs as the
+ * agent wrote it, and the plan waits, still announced, for `run_scenario`.
+ * The first call that may change something still retires it, running nothing
+ * (and nothing ever runs in a hook in its place): a plan run after the agent
+ * changed something itself could do the same work twice.
+ *
+ * WHEN IN DOUBT, IT IS A CHANGE. A call judged "only looks" that does change
+ * something leaves a plan armed that could then repeat that change; a change
+ * judged a change only ends a replay early, as every call did before. So:
+ *
+ *  - Claude Code's built-ins by name: the reading ones only look, every other
+ *    built-in (a sub-agent, an edit, an unknown new tool) is a change;
+ *  - `Bash` by its command ({@link commandReadsOnly}), and `PowerShell` never;
+ *  - an MCP tool by what its own server says of it (`annotations`), else by
+ *    its name: a reading word and no writing word.
+ *
+ * The same rule as the service's `readsOnly` (correctionCheck.ts, AC13), kept
+ * in step by hand, stricter where a wrong "only looks" costs more here: a
+ * command substitution, a process substitution or an `awk` `system(` makes a
+ * command a change.
+ */
+import type { ToolAnnotations } from "../record/recorder.js";
+/**
+ * Whether this call only looks. `toolInput` is the hook's `tool_input` (only a
+ * `Bash` call's `command` is read from it); `hints` is what the tool's own
+ * server listed for it, when it listed anything.
+ */
+export declare function readsOnlyCall(toolName: string, toolInput?: unknown, hints?: ToolAnnotations): boolean;
+/**
+ * Whether a shell command only looks: every part of it is a looking command,
+ * nothing is written to a file, and nothing runs code it does not show.
+ */
+export declare function commandReadsOnly(command: string): boolean;
+//# sourceMappingURL=reads-only.d.ts.map