@basein/runner 0.1.0

package/dist/replay/logic.js

@@ -0,0 +1,50 @@
+/**
+ * logic — the four stored-JS evaluators (docs/calculatedReplay.md §9).
+ *
+ * A calculated scenario carries JavaScript function *bodies*, one per hook
+ * point, each ending in `return { … }`. They are compiled with `new Function`
+ * and run here.
+ *
+ * PORTED FROM THE SERVICE, DELIBERATELY. BaseIn's `src/scenarios/logic.ts` is
+ * the copy the service itself evaluates in a dry replay, so it is the one that
+ * defines what a scenario *means*. Porting RRepeat's near-identical copy instead
+ * would let a scenario behave one way under `bir scenario replay --dry` and
+ * another way here — an untestable difference. Argument order and the
+ * plain-object guard both match the service exactly.
+ *
+ * THERE IS NO SANDBOX, and the doc says so plainly (§13.1). A `new Function`
+ * body gets its declared arguments and the global scope: `require`/`import` are
+ * unreachable under ESM, but `fetch`, `process` and `globalThis` are not. What
+ * makes this acceptable is provenance, not containment — the payload arrives
+ * only in an authenticated response from the configured `BIR_AUTH_URL`,
+ * describing the caller's own recorded runs — and replay is opt-in for exactly
+ * this reason.
+ */
+/** Every logic body must return a plain object; anything else is a bug upstream. */
+function assertPlainObject(result, label) {
+    if (typeof result !== "object" || result === null || Array.isArray(result)) {
+        throw new Error(`${label} must return a plain object`);
+    }
+    return result;
+}
+/** Transform the derived parameters once, before any step runs. */
+export function evalParamsLogic(code, parameters, intent) {
+    const fn = new Function("parameters", "intent", code);
+    return assertPlainObject(fn(parameters, intent), "paramsLogic");
+}
+/** Derive one step's tool input from params, intent and the accumulated respParams. */
+export function evalToolInputLogic(code, parameters, intent, respParams = {}) {
+    const fn = new Function("parameters", "intent", "respParams", code);
+    return assertPlainObject(fn(parameters, intent, respParams), "toolInputLogic");
+}
+/** Extract keys from a step's real output, to merge into respParams for later steps. */
+export function evalToolOutputLogic(code, toolOutput, parameters, intent, respParams = {}) {
+    const fn = new Function("toolOutput", "parameters", "intent", "respParams", code);
+    return assertPlainObject(fn(toolOutput, parameters, intent, respParams), "toolOutputLogic");
+}
+/** Build the final response model from everything the steps accumulated. */
+export function evalResponseParamsLogic(code, respParams, parameters, intent) {
+    const fn = new Function("respParams", "parameters", "intent", code);
+    return assertPlainObject(fn(respParams, parameters, intent), "responseParamsLogic");
+}
+//# sourceMappingURL=logic.js.map

package/dist/replay/plan.d.ts

@@ -0,0 +1,181 @@
+/**
+ * ScenarioReplayPlan — the stateful driver for one matched turn
+ * (docs/calculatedReplay.md §9).
+ *
+ * In `direct` mode the whole plan runs inside one loop. In `steer` mode the same
+ * state is split across *separate HTTP requests* — `PreToolUse` computes step
+ * N's input, `PostToolUse` threads step N's output — which is why the plan is an
+ * object with a cursor rather than a function with a loop.
+ *
+ * THREE DIFFERENCES FROM RRepeat's `ScenarioReplayPlan`, each deliberate:
+ *
+ *   1. **Lifetime is a run, not a session.** The plan hangs off `RunState`. Here
+ *      a run *is* a turn (`UserPromptSubmit → Stop`), which is exactly the plan's
+ *      lifetime, so a second prompt cannot inherit a stale plan.
+ *   2. **`params` are a promise.** Arming must not wait on the derivation call —
+ *      the prompt hook has a budget to keep (§10). `ready()` is what the first
+ *      `PreToolUse` (or `/scenario/run`) awaits, and `paramsLogic` is applied
+ *      once, there.
+ *   3. **`execute` takes a step, not a tool name.** The executor must see the
+ *      step to know its reach, so it can choose between the proxy, a recorded
+ *      output, and skipping.
+ */
+import type { ReplayMode } from "./coverage.js";
+import type { ExecutionStage, SerializedScenario, SerializedScenarioStep } from "./types.js";
+/**
+ * Runs one step's tool and returns its output as a string.
+ *
+ * Resolving with a failure message is a *result* — a tool that ran and failed.
+ * Rejecting means the step could not be **run here at all**, which is the only
+ * case a recorded output may stand in for.
+ */
+export type ExecuteStep = (step: SerializedScenarioStep, input: Record<string, unknown>) => Promise<string>;
+/** Supplies a step's recorded output when its tool cannot run here (§8.1). */
+export type RecordedOutputFor = (step: SerializedScenarioStep) => Promise<string | undefined>;
+/**
+ * What one step did, told to the caller as it happens.
+ *
+ * `executed` / `recorded` / `skipped` describe where the *output* came from —
+ * the tool, the source run, or nowhere. `failed` is the different kind of news:
+ * the step's work did not happen. Either the scenario's **own logic** threw —
+ * emitted immediately before the throw propagates, the only moment anything
+ * knows which step it belonged to — or the tool ran and reported an error
+ * (stage `tool_call`), in which case the chain carries on, threading the error
+ * like any other output, but nothing may call the plan a success.
+ */
+export interface StepInfo {
+    step: SerializedScenarioStep;
+    input: Record<string, unknown>;
+    outcome: "executed" | "recorded" | "skipped" | "failed";
+    /** Which part of the step broke. Only set for `failed`. */
+    stage?: ExecutionStage;
+    error?: string;
+    derivedKeys?: string[];
+    ms: number;
+}
+export type StepObserver = (info: StepInfo) => void;
+export interface ComposeResult {
+    text: string;
+    executed: number;
+    recorded: number;
+    skipped: number;
+    /**
+     * Of `executed`, how many tools ran and reported an error. Counted separately
+     * because the tool *did* run — the step is in the bundle, its output threaded —
+     * and yet the work did not happen, and an outcome must not say it did.
+     */
+    errored: number;
+}
+export interface PlanOptions {
+    scenario: SerializedScenario;
+    /** Resolves with the derived parameters. Rejection degrades to `{}`. */
+    params: Promise<Record<string, unknown>>;
+    mode: ReplayMode;
+    respParamsInit?: Record<string, unknown>;
+}
+export declare class ScenarioReplayPlan {
+    readonly scenarioId: string;
+    readonly runId: string;
+    readonly mode: ReplayMode;
+    readonly intent: string;
+    private readonly scenario;
+    private readonly steps;
+    private readonly paramsPromise;
+    private params;
+    private respParams;
+    private stepIndex;
+    private readyPromise?;
+    constructor(opts: PlanOptions);
+    /**
+     * Await the derivation, then apply `paramsLogic` — once, however many callers
+     * race here. A rejected derivation resolves to `{}` rather than throwing: the
+     * caller decided long ago that a replay with fallback parameters beats no
+     * replay, and a throw here would abort a turn the user is waiting on.
+     */
+    ready(): Promise<void>;
+    /** 0-based index of the step awaiting execution (== completed step count). */
+    get currentStepIndex(): number;
+    get stepCount(): number;
+    /** The parameters in force. Empty until {@link ready} resolves. */
+    get parameters(): Readonly<Record<string, unknown>>;
+    /** Everything the steps have accumulated so far. */
+    get accumulated(): Readonly<Record<string, unknown>>;
+    /** The step awaiting execution, or undefined when the plan is done. */
+    currentStep(): SerializedScenarioStep | undefined;
+    /** The tool the current step expects, or undefined when done. */
+    expectedTool(): string | undefined;
+    /** True once every step has been applied — the plan should be retired. */
+    isDone(): boolean;
+    /** Every step in order — for the directive, and for coverage reporting. */
+    allSteps(): readonly SerializedScenarioStep[];
+    /**
+     * True when `toolName` is one of this scenario's own tools.
+     *
+     * The question "is this call part of the plan?" is not the same as "is this
+     * the call I expected next", and conflating them is what made a plan die on
+     * `ToolSearch`. A host has housekeeping tools of its own — tool search, todo
+     * lists, file reads while it thinks — and none of them mean the model has
+     * abandoned the sequence.
+     */
+    usesTool(toolName: string): boolean;
+    /**
+     * Compute the pinned input for the current step. Throws when there is no
+     * current step, or when the step's `toolInputLogic` fails — the caller treats
+     * a throw as divergence.
+     */
+    toolInputForCurrentStep(): Record<string, unknown>;
+    /**
+     * Thread a real tool output into `respParams` and advance.
+     *
+     * `realOutput` must be serialized the way the step's output was **recorded** —
+     * for a wrapped MCP step that is the proxy's whole `CallToolResult`, not the
+     * host's rendering of it (§7.2). Returns the keys derived, for the audit line.
+     * Throws when `toolOutputLogic` fails; the caller aborts to a normal turn.
+     */
+    applyOutput(realOutput: string): string[];
+    /** Build the final response model from everything the steps accumulated. */
+    responseModel(): Record<string, unknown>;
+    /**
+     * The directive injected via `UserPromptSubmit`'s `additionalContext`.
+     *
+     * In `direct` mode it asks for one call to the first-party tool, which runs the
+     * whole sequence server-side. In `steer` mode it names the sequence so the
+     * model initiates the expected calls — the arguments are supplied by the
+     * system, so the model need not compute them.
+     */
+    steeringDirective(directToolName?: string): string;
+    /**
+     * Execute every **remaining** step and lay the results out as one bundle.
+     *
+     * Iteration starts at {@link currentStepIndex}, not at 0: in a steered turn the
+     * live session already ran — with side effects — every step before the one it
+     * diverged on, so re-running them would be wrong.
+     *
+     * There is no try/catch around the input or output logic: a throw there
+     * propagates out, and the caller abandons the whole bundle rather than
+     * shipping a half-computed one. The tool call itself is the exception — a
+     * rejection means the step could not be run *here*, and then a recorded output
+     * is not a shortcut past a real result, it is the only result that exists.
+     * Skipping instead would drop the step *and* stop threading `respParams`, so
+     * every later step reading from it fails too.
+     */
+    composeBundle(maxChars: number, execute: ExecuteStep, recordedOutputFor?: RecordedOutputFor, onStep?: StepObserver): Promise<ComposeResult>;
+    /**
+     * Run the whole plan from the current cursor, advancing it as it goes.
+     *
+     * This is `direct` mode's driver, and unlike {@link composeBundle} it mutates
+     * the plan — the steps really did run, so the cursor and `respParams` must say
+     * so, which is what lets the outcome be `steered_full` and `stepsPinned` be
+     * truthful. A step that cannot run at all still advances the cursor: the plan
+     * is spent either way, and stalling it would leave a retired turn looking live.
+     *
+     * `maxChars` caps the bundle exactly as a divergence bundle is capped. The
+     * direct path once passed `Number.MAX_SAFE_INTEGER` here — fine at 10 KB, and
+     * an unbounded payload into the model's context for a scenario whose tools
+     * answer in megabytes (docs/mcpmark.md §12).
+     */
+    runToCompletion(execute: ExecuteStep, recordedOutputFor?: RecordedOutputFor, onStep?: StepObserver, deadline?: number, maxChars?: number): Promise<ComposeResult & {
+        partial: boolean;
+    }>;
+}
+//# sourceMappingURL=plan.d.ts.map

package/dist/replay/plan.js

@@ -0,0 +1,397 @@
+/**
+ * ScenarioReplayPlan — the stateful driver for one matched turn
+ * (docs/calculatedReplay.md §9).
+ *
+ * In `direct` mode the whole plan runs inside one loop. In `steer` mode the same
+ * state is split across *separate HTTP requests* — `PreToolUse` computes step
+ * N's input, `PostToolUse` threads step N's output — which is why the plan is an
+ * object with a cursor rather than a function with a loop.
+ *
+ * THREE DIFFERENCES FROM RRepeat's `ScenarioReplayPlan`, each deliberate:
+ *
+ *   1. **Lifetime is a run, not a session.** The plan hangs off `RunState`. Here
+ *      a run *is* a turn (`UserPromptSubmit → Stop`), which is exactly the plan's
+ *      lifetime, so a second prompt cannot inherit a stale plan.
+ *   2. **`params` are a promise.** Arming must not wait on the derivation call —
+ *      the prompt hook has a budget to keep (§10). `ready()` is what the first
+ *      `PreToolUse` (or `/scenario/run`) awaits, and `paramsLogic` is applied
+ *      once, there.
+ *   3. **`execute` takes a step, not a tool name.** The executor must see the
+ *      step to know its reach, so it can choose between the proxy, a recorded
+ *      output, and skipping.
+ */
+import { evalParamsLogic, evalResponseParamsLogic, evalToolInputLogic, evalToolOutputLogic, } from "./logic.js";
+import { assembleBundle, bundleInput, MAX_REPLAY_REASON } from "./bundle.js";
+import { toolResultError } from "./tool-error.js";
+/**
+ * Evaluate one of the scenario's logic bodies, naming the step and the stage to
+ * the observer if it throws — then rethrow, unchanged and uncaught.
+ *
+ * The rethrow is the point. The caller's contract is unaltered: a logic failure
+ * still abandons the whole bundle rather than shipping a half-computed one. All
+ * this adds is that the failure is now *attributable* — "step 2's tool input
+ * logic", rather than a stack trace the console cannot line up against a chain.
+ */
+function reportingStage(onStep, step, stage, input, startedAt, fn) {
+    try {
+        return fn();
+    }
+    catch (err) {
+        onStep?.({
+            step,
+            input,
+            outcome: "failed",
+            stage,
+            error: err instanceof Error ? err.message : String(err),
+            ms: Date.now() - startedAt,
+        });
+        throw err;
+    }
+}
+export class ScenarioReplayPlan {
+    scenarioId;
+    runId;
+    mode;
+    intent;
+    scenario;
+    steps;
+    paramsPromise;
+    params = {};
+    respParams;
+    stepIndex = 0;
+    readyPromise;
+    constructor(opts) {
+        this.scenario = opts.scenario;
+        this.scenarioId = opts.scenario.id;
+        this.runId = opts.scenario.runId;
+        this.intent = opts.scenario.intent ?? "";
+        this.steps = opts.scenario.steps ?? [];
+        this.mode = opts.mode;
+        this.paramsPromise = opts.params;
+        this.respParams = { ...(opts.respParamsInit ?? {}) };
+    }
+    /**
+     * Await the derivation, then apply `paramsLogic` — once, however many callers
+     * race here. A rejected derivation resolves to `{}` rather than throwing: the
+     * caller decided long ago that a replay with fallback parameters beats no
+     * replay, and a throw here would abort a turn the user is waiting on.
+     */
+    ready() {
+        if (!this.readyPromise) {
+            this.readyPromise = this.paramsPromise
+                .catch(() => ({}))
+                .then((derived) => {
+                let params = { ...derived };
+                if (this.scenario.paramsLogic) {
+                    // A throw here is real: the scenario's own logic is broken, and the
+                    // caller must abort rather than run steps with unprocessed params.
+                    params = evalParamsLogic(this.scenario.paramsLogic, params, this.intent);
+                }
+                this.params = params;
+            });
+        }
+        return this.readyPromise;
+    }
+    /** 0-based index of the step awaiting execution (== completed step count). */
+    get currentStepIndex() {
+        return this.stepIndex;
+    }
+    get stepCount() {
+        return this.steps.length;
+    }
+    /** The parameters in force. Empty until {@link ready} resolves. */
+    get parameters() {
+        return this.params;
+    }
+    /** Everything the steps have accumulated so far. */
+    get accumulated() {
+        return this.respParams;
+    }
+    /** The step awaiting execution, or undefined when the plan is done. */
+    currentStep() {
+        return this.steps[this.stepIndex];
+    }
+    /** The tool the current step expects, or undefined when done. */
+    expectedTool() {
+        return this.steps[this.stepIndex]?.toolName;
+    }
+    /** True once every step has been applied — the plan should be retired. */
+    isDone() {
+        return this.stepIndex >= this.steps.length;
+    }
+    /** Every step in order — for the directive, and for coverage reporting. */
+    allSteps() {
+        return this.steps;
+    }
+    /**
+     * True when `toolName` is one of this scenario's own tools.
+     *
+     * The question "is this call part of the plan?" is not the same as "is this
+     * the call I expected next", and conflating them is what made a plan die on
+     * `ToolSearch`. A host has housekeeping tools of its own — tool search, todo
+     * lists, file reads while it thinks — and none of them mean the model has
+     * abandoned the sequence.
+     */
+    usesTool(toolName) {
+        return this.steps.some((s) => s.toolName === toolName);
+    }
+    /**
+     * Compute the pinned input for the current step. Throws when there is no
+     * current step, or when the step's `toolInputLogic` fails — the caller treats
+     * a throw as divergence.
+     */
+    toolInputForCurrentStep() {
+        const step = this.steps[this.stepIndex];
+        if (!step)
+            throw new Error("no current step to compute input for");
+        return evalToolInputLogic(step.toolInputLogic, this.params, this.intent, this.respParams);
+    }
+    /**
+     * Thread a real tool output into `respParams` and advance.
+     *
+     * `realOutput` must be serialized the way the step's output was **recorded** —
+     * for a wrapped MCP step that is the proxy's whole `CallToolResult`, not the
+     * host's rendering of it (§7.2). Returns the keys derived, for the audit line.
+     * Throws when `toolOutputLogic` fails; the caller aborts to a normal turn.
+     */
+    applyOutput(realOutput) {
+        const step = this.steps[this.stepIndex];
+        if (!step)
+            return [];
+        let derivedKeys = [];
+        if (step.toolOutputLogic) {
+            const derived = evalToolOutputLogic(step.toolOutputLogic, realOutput, this.params, this.intent, this.respParams);
+            derivedKeys = Object.keys(derived);
+            this.respParams = { ...this.respParams, ...derived };
+        }
+        this.stepIndex += 1;
+        return derivedKeys;
+    }
+    /** Build the final response model from everything the steps accumulated. */
+    responseModel() {
+        if (!this.scenario.responseParamsLogic)
+            return { ...this.respParams };
+        return evalResponseParamsLogic(this.scenario.responseParamsLogic, this.respParams, this.params, this.intent);
+    }
+    /**
+     * The directive injected via `UserPromptSubmit`'s `additionalContext`.
+     *
+     * In `direct` mode it asks for one call to the first-party tool, which runs the
+     * whole sequence server-side. In `steer` mode it names the sequence so the
+     * model initiates the expected calls — the arguments are supplied by the
+     * system, so the model need not compute them.
+     */
+    steeringDirective(directToolName = "mcp__bir__run_scenario") {
+        // 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 lines = this.steps.map((s, i) => {
+            const why = s.reasoning ? ` — ${s.reasoning}` : "";
+            return `  ${i + 1}. ${s.toolName}${why}`;
+        });
+        if (this.mode === "direct") {
+            // The sequence is listed even though the model does not call it itself:
+            // it is about to receive these results, and knowing what was run is what
+            // lets it tell a complete answer from a partial one. It is also the only
+            // place an operator watching the session can see what a replay is doing.
+            return [
+                "[BaseInstRunner calculated replay] A known-good tool sequence was recorded",
+                `for this request${intent ? ` (intent: ${intent})` : ""}.`,
+                "",
+                "It runs these tools, in order, and returns their results:",
+                "",
+                ...lines,
+                "",
+                `Call ${directToolName} once, with no arguments, before any other tool.`,
+                "Then answer the user's request from the results it returns.",
+            ].join("\n");
+        }
+        return [
+            "[BaseInstRunner calculated replay] A known-good tool sequence was previously",
+            "recorded for this request. Call exactly these tools, in order, one at a time:",
+            "",
+            ...lines,
+            ...(intent ? ["", `Context: ${intent}`] : []),
+            "",
+            "The system supplies the exact arguments for each call — you do not need to",
+            "compute them. Do not call any other tools until this sequence is complete,",
+            "then answer the user's request from the tool results.",
+        ].join("\n");
+    }
+    /**
+     * Execute every **remaining** step and lay the results out as one bundle.
+     *
+     * Iteration starts at {@link currentStepIndex}, not at 0: in a steered turn the
+     * live session already ran — with side effects — every step before the one it
+     * diverged on, so re-running them would be wrong.
+     *
+     * There is no try/catch around the input or output logic: a throw there
+     * propagates out, and the caller abandons the whole bundle rather than
+     * shipping a half-computed one. The tool call itself is the exception — a
+     * rejection means the step could not be run *here*, and then a recorded output
+     * is not a shortcut past a real result, it is the only result that exists.
+     * Skipping instead would drop the step *and* stop threading `respParams`, so
+     * every later step reading from it fails too.
+     */
+    async composeBundle(maxChars, execute, recordedOutputFor, onStep) {
+        // A local copy: composing must not corrupt the live plan's accumulation if
+        // the caller decides to keep steering afterwards.
+        const respParams = { ...this.respParams };
+        const entries = [];
+        let executed = 0;
+        let recordedCount = 0;
+        let skipped = 0;
+        let errored = 0;
+        for (const step of this.steps.slice(this.stepIndex)) {
+            const startedAt = Date.now();
+            const computed = reportingStage(onStep, step, "tool_input_logic", {}, startedAt, () => evalToolInputLogic(step.toolInputLogic, this.params, this.intent, respParams));
+            let response;
+            let recorded = false;
+            try {
+                response = await execute(step, computed);
+                executed += 1;
+            }
+            catch (err) {
+                const error = err instanceof Error ? err.message : String(err);
+                const fallback = (typeof step.recordedOutput === "string" && step.recordedOutput.length > 0
+                    ? step.recordedOutput
+                    : undefined) ?? (await recordedOutputFor?.(step).catch(() => undefined));
+                if (!fallback) {
+                    skipped += 1;
+                    onStep?.({ step, input: computed, outcome: "skipped", error, ms: Date.now() - startedAt });
+                    continue;
+                }
+                response = fallback;
+                recorded = true;
+                recordedCount += 1;
+                onStep?.({ step, input: computed, outcome: "recorded", error, ms: Date.now() - startedAt });
+            }
+            // Thread the output for later steps' inputs. A recorded output threads
+            // too: `toolOutputLogic` was authored against exactly this shape, and a
+            // stale value beats a missing one downstream.
+            let derivedKeys = [];
+            if (step.toolOutputLogic) {
+                const derived = reportingStage(onStep, step, "tool_output_logic", computed, startedAt, () => evalToolOutputLogic(step.toolOutputLogic, response, this.params, this.intent, respParams));
+                derivedKeys = Object.keys(derived);
+                Object.assign(respParams, derived);
+            }
+            if (!recorded) {
+                // A step's verdict is its output, not its resolution: a tool that ran
+                // and answered "Error: …" resolves like any other, and a chain of eight
+                // of them once logged ok=true eight times (docs/mcpmark.md §13).
+                const error = toolResultError(response);
+                if (error)
+                    errored += 1;
+                onStep?.({
+                    step,
+                    input: computed,
+                    outcome: error ? "failed" : "executed",
+                    stage: error ? "tool_call" : undefined,
+                    error,
+                    derivedKeys,
+                    ms: Date.now() - startedAt,
+                });
+            }
+            entries.push({
+                toolName: step.toolName,
+                input: bundleInput(computed),
+                response,
+                recorded,
+            });
+        }
+        return {
+            text: assembleBundle(entries, maxChars),
+            executed,
+            recorded: recordedCount,
+            skipped,
+            errored,
+        };
+    }
+    /**
+     * Run the whole plan from the current cursor, advancing it as it goes.
+     *
+     * This is `direct` mode's driver, and unlike {@link composeBundle} it mutates
+     * the plan — the steps really did run, so the cursor and `respParams` must say
+     * so, which is what lets the outcome be `steered_full` and `stepsPinned` be
+     * truthful. A step that cannot run at all still advances the cursor: the plan
+     * is spent either way, and stalling it would leave a retired turn looking live.
+     *
+     * `maxChars` caps the bundle exactly as a divergence bundle is capped. The
+     * direct path once passed `Number.MAX_SAFE_INTEGER` here — fine at 10 KB, and
+     * an unbounded payload into the model's context for a scenario whose tools
+     * answer in megabytes (docs/mcpmark.md §12).
+     */
+    async runToCompletion(execute, recordedOutputFor, onStep, deadline, maxChars = MAX_REPLAY_REASON) {
+        const entries = [];
+        let executed = 0;
+        let recordedCount = 0;
+        let skipped = 0;
+        let errored = 0;
+        let partial = false;
+        while (!this.isDone()) {
+            if (deadline !== undefined && Date.now() >= deadline) {
+                partial = true;
+                break;
+            }
+            const step = this.steps[this.stepIndex];
+            const startedAt = Date.now();
+            const computed = reportingStage(onStep, step, "tool_input_logic", {}, startedAt, () => this.toolInputForCurrentStep());
+            let response;
+            let recorded = false;
+            try {
+                response = await execute(step, computed);
+                executed += 1;
+            }
+            catch (err) {
+                const error = err instanceof Error ? err.message : String(err);
+                const fallback = (typeof step.recordedOutput === "string" && step.recordedOutput.length > 0
+                    ? step.recordedOutput
+                    : undefined) ?? (await recordedOutputFor?.(step).catch(() => undefined));
+                if (!fallback) {
+                    skipped += 1;
+                    onStep?.({ step, input: computed, outcome: "skipped", error, ms: Date.now() - startedAt });
+                    // Advance past a step that cannot run, without threading anything.
+                    this.stepIndex += 1;
+                    continue;
+                }
+                response = fallback;
+                recorded = true;
+                recordedCount += 1;
+                onStep?.({ step, input: computed, outcome: "recorded", error, ms: Date.now() - startedAt });
+            }
+            const derivedKeys = reportingStage(onStep, step, "tool_output_logic", computed, startedAt, () => this.applyOutput(response));
+            if (!recorded) {
+                // A step's verdict is its output, not its resolution: a tool that ran
+                // and answered "Error: …" resolves like any other, and a chain of eight
+                // of them once logged ok=true eight times (docs/mcpmark.md §13).
+                const error = toolResultError(response);
+                if (error)
+                    errored += 1;
+                onStep?.({
+                    step,
+                    input: computed,
+                    outcome: error ? "failed" : "executed",
+                    stage: error ? "tool_call" : undefined,
+                    error,
+                    derivedKeys,
+                    ms: Date.now() - startedAt,
+                });
+            }
+            entries.push({
+                toolName: step.toolName,
+                input: bundleInput(computed),
+                response,
+                recorded,
+            });
+        }
+        return {
+            text: assembleBundle(entries, maxChars),
+            executed,
+            recorded: recordedCount,
+            skipped,
+            errored,
+            partial,
+        };
+    }
+}
+//# sourceMappingURL=plan.js.map

package/dist/replay/pricing.d.ts

@@ -0,0 +1,41 @@
+/**
+ * pricing — token cost, in $/million tokens (docs/calculatedReplay.md §11.3).
+ *
+ * COPIED FROM THE SERVICE, NOT FROM RRepeat. A saving is `baseline − actual`,
+ * where the baseline is priced by BaseIn's `src/scenarios/cost.ts` and the actual
+ * by this file. The two are maintained by hand in separate repositories, so any
+ * drift between them is fake money — and {@link PRICING_VERSION} is stamped on
+ * every execution report so the server can store a mismatched one *unmeasured*
+ * rather than silently differencing two different tables.
+ *
+ * The service owns the baseline, so the service's table is the one to match.
+ * That is not a stylistic preference: at the time of writing, RRepeat and BaseIn
+ * both declare version `2026-08-30` while pricing `claude-opus-4-6` at 3.0/15.0
+ * and 5.0/25.0 respectively. Equal versions are supposed to certify that two
+ * numbers are comparable. For that row, right now, they are not.
+ *
+ * Bump the version — on **every** side — whenever a row changes.
+ */
+/** Identifies {@link MODEL_PRICING}. Must equal the service's constant. */
+export declare const PRICING_VERSION = "2026-08-30";
+/**
+ * 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): {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+} | undefined;
+export declare function hasModelPricing(model: string): boolean;
+export interface TokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens?: number;
+    cacheCreationTokens?: number;
+}
+/** Cost in USD. An unpriced model yields 0 — the caller reports `measured: false`. */
+export declare function calculateCostUsd(model: string, usage: TokenUsage): number;
+//# sourceMappingURL=pricing.d.ts.map