@basein/runner 0.3.8 → 0.3.9

package/dist/record/remote-recorder.d.ts

@@ -69,6 +69,14 @@ export declare const TEXT_CAPS: {
     /** An execution report's error lines, rendered in a web page. */
     readonly reportError: number;
 };
+/**
+ * The most an execution report's request may weigh. The service reads this
+ * route with its 100 kB JSON parser — only `/recordings` has the larger one —
+ * and a report it refuses for its size loses the turn's cost with it. So the
+ * steps' tool payloads get what is left of this after everything else in the
+ * report: the costs, the prompt, the verdicts.
+ */
+export declare const REPORT_MAX_BYTES: number;
 /** Queued sends past which the oldest unsent step is dropped (`BIR_RECORDER_MAX_PENDING`). */
 export declare const DEFAULT_MAX_PENDING_SENDS = 500;
 /** Queued bytes past which the same happens (`BIR_RECORDER_MAX_PENDING_BYTES`). */

package/dist/record/remote-recorder.js

@@ -52,7 +52,7 @@ import { credentialsPath, describeBody, isAuthResponse, issuedFor, loadCredentia
 import { errText, logDetail, logEvery, logLine } from "../util/log.js";
 import { isUnhealthyStatus, serviceHealth, serviceTimeoutMs, timeoutSignal, } from "../util/service-health.js";
 import { redactJsonText, redactText } from "./redact.js";
-import { capJsonText, capText, DEFAULT_MAX_PAYLOAD_BYTES, preCut } from "./truncate.js";
+import { capJsonText, capText, DEFAULT_MAX_PAYLOAD_BYTES, preCut, REPORT_PAYLOAD_MAX_BYTES, } from "./truncate.js";
 /**
  * Caps for the free text this recorder sends, in UTF-8 bytes. Tool payloads
  * arrive capped at 64 KiB by their producers; text never passed through one,
@@ -73,6 +73,14 @@ export const TEXT_CAPS = {
     /** An execution report's error lines, rendered in a web page. */
     reportError: 2 * 1024,
 };
+/**
+ * The most an execution report's request may weigh. The service reads this
+ * route with its 100 kB JSON parser — only `/recordings` has the larger one —
+ * and a report it refuses for its size loses the turn's cost with it. So the
+ * steps' tool payloads get what is left of this after everything else in the
+ * report: the costs, the prompt, the verdicts.
+ */
+export const REPORT_MAX_BYTES = 96 * 1024;
 /** Queued sends past which the oldest unsent step is dropped (`BIR_RECORDER_MAX_PENDING`). */
 export const DEFAULT_MAX_PENDING_SENDS = 500;
 /** Queued bytes past which the same happens (`BIR_RECORDER_MAX_PENDING_BYTES`). */
@@ -177,6 +185,61 @@ function sizeOf(...parts) {
         n += p?.text.length ?? 0;
     return n;
 }
+function pendStep(step) {
+    return {
+        step,
+        toolInput: pend(step.toolInput, REPORT_PAYLOAD_MAX_BYTES, true),
+        toolOutput: pend(step.toolOutput, REPORT_PAYLOAD_MAX_BYTES, true),
+    };
+}
+/**
+ * An execution report's request body: `fields`, and its steps as sent — each
+ * error and each tool payload capped and redacted, like every other field here.
+ *
+ * The payloads are what makes a report heavy, so they are added last and only
+ * while the whole body stays within {@link REPORT_MAX_BYTES}: the failed
+ * steps' first — theirs are the ones somebody will read — then every step's
+ * input, then the outputs, each in the order the steps ran. A payload that
+ * does not fit is left out; its step keeps its verdict, and the costs the
+ * report exists for are never what gives way.
+ */
+function reportBody(fields, steps) {
+    if (!steps)
+        return JSON.stringify(fields);
+    const sent = steps.map(({ step }) => ({
+        ...step,
+        error: typeof step.error === "string"
+            ? capText(step.error, TEXT_CAPS.reportError, redactText)
+            : step.error,
+        toolInput: undefined,
+        toolOutput: undefined,
+    }));
+    const bare = Buffer.byteLength(JSON.stringify({ ...fields, steps: sent }), "utf8");
+    let left = REPORT_MAX_BYTES - bare;
+    const add = (i, key) => {
+        if (sent[i][key] !== undefined)
+            return;
+        const text = out(steps[i][key]);
+        if (text === undefined)
+            return;
+        // The value as a JSON string, and `,"<key>":` in front of it.
+        const size = Buffer.byteLength(JSON.stringify(text), "utf8") + key.length + 4;
+        if (size > left)
+            return;
+        sent[i][key] = text;
+        left -= size;
+    };
+    const all = sent.map((_, i) => i);
+    for (const i of all.filter((n) => sent[n].status === "failed")) {
+        add(i, "toolInput");
+        add(i, "toolOutput");
+    }
+    for (const i of all)
+        add(i, "toolInput");
+    for (const i of all)
+        add(i, "toolOutput");
+    return JSON.stringify({ ...fields, steps: sent });
+}
 /** A tool error is JSON when a producer serialized it, and prose when it did not. */
 function pendError(text) {
     if (typeof text !== "string")
@@ -609,12 +672,21 @@ export class RemoteRecorder {
         const costUsd = report.deriveCostUsd + report.sessionCostUsd + report.fallbackCostUsd;
         const prompt = pend(report.prompt, TEXT_CAPS.prompt);
         const error = pend(report.error, TEXT_CAPS.reportError);
+        const steps = report.steps?.map(pendStep);
         this.enqueue({
             lane: EXECUTIONS,
             kind: "report",
-            bytes: sizeOf(prompt, error) + 1024,
+            bytes: sizeOf(prompt, error, ...(steps ?? []).flatMap((s) => [s.toolInput, s.toolOutput])) + 1024,
             send: async () => {
-                const body = await this.request("POST", `/scenarios/${report.scenarioId}/executions`, JSON.stringify({
+                const body = await this.request("POST", `/scenarios/${report.scenarioId}/executions`, 
+                // Per-step verdicts and the headline failure (errorshandling.md) ride
+                // beside the costs. All optional on the service side, so an older
+                // service ignores them rather than rejecting the report — and the
+                // costs still book. Errors are shown on a web page, so they are
+                // capped and redacted like any text; so is what each step sent and
+                // received, which the page shows under the verdict in place of the
+                // recording's sample (`reportBody`).
+                reportBody({
                     ticket: report.ticket,
                     outcome: report.outcome,
                     costUsd,
@@ -627,11 +699,6 @@ export class RemoteRecorder {
                     measured: report.measured,
                     pricingVersion: report.pricingVersion,
                     prompt: out(prompt),
-                    // Per-step verdicts and the headline failure (errorshandling.md). All
-                    // optional on the service side, so an older service ignores them rather
-                    // than rejecting the report — and the costs still book. Errors are
-                    // shown on a web page, so they are capped and redacted like any text.
-                    steps: report.steps?.map((s) => typeof s.error === "string" ? { ...s, error: capText(s.error, TEXT_CAPS.reportError, redactText) } : s),
                     error: out(error),
                     errorStage: report.errorStage,
                     errorStepIndex: report.errorStepIndex,
@@ -643,7 +710,7 @@ export class RemoteRecorder {
                     // Why nothing ran, when nothing ran. Additive: an older service drops
                     // the field and books the cost exactly as it always did.
                     declined: report.declined,
-                }), { retryTransient: Boolean(report.ticket) });
+                }, steps), { retryTransient: Boolean(report.ticket) });
                 const r = (body ?? {});
                 const failed = report.steps?.filter((s) => s.status === "failed").length ?? 0;
                 logLine("execution.reported", {

package/dist/record/truncate.d.ts

@@ -20,6 +20,17 @@
 export declare const DEFAULT_MAX_PAYLOAD_BYTES: number;
 /** 8 KiB per individual string leaf. */
 export declare const DEFAULT_MAX_STRING_BYTES: number;
+/**
+ * What one tool payload may take inside an execution report. A report carries
+ * every step of a replay in one small request, so a step's input or output
+ * gets far less there than the 64 KiB a recorded step has to itself.
+ *
+ * 3,800 bytes, not a round 4 KiB: the service keeps 4,000 characters of each,
+ * and a payload cut here still fits that with its marker. So the scenario's
+ * page shows this cut, which says how large the payload was, and never a
+ * second one made on top of it.
+ */
+export declare const REPORT_PAYLOAD_MAX_BYTES = 3800;
 export interface TruncateOptions {
     maxPayloadBytes?: number;
     maxStringBytes?: number;

package/dist/record/truncate.js

@@ -20,6 +20,17 @@
 export const DEFAULT_MAX_PAYLOAD_BYTES = 64 * 1024;
 /** 8 KiB per individual string leaf. */
 export const DEFAULT_MAX_STRING_BYTES = 8 * 1024;
+/**
+ * What one tool payload may take inside an execution report. A report carries
+ * every step of a replay in one small request, so a step's input or output
+ * gets far less there than the 64 KiB a recorded step has to itself.
+ *
+ * 3,800 bytes, not a round 4 KiB: the service keeps 4,000 characters of each,
+ * and a payload cut here still fits that with its marker. So the scenario's
+ * page shows this cut, which says how large the payload was, and never a
+ * second one made on top of it.
+ */
+export const REPORT_PAYLOAD_MAX_BYTES = 3_800;
 const utf8 = (s) => Buffer.byteLength(s, "utf8");
 /** The marker {@link truncateString} appends, so a second cut can report the first size. */
 const MARKER = /… \[truncated \d+ of (\d+) bytes\]$/;

package/dist/replay/controller.d.ts

@@ -273,6 +273,12 @@ interface PinnedCall {
     toolName: string;
     /** When it was pinned — a steered step's duration is measured across hooks. */
     pinnedAt: number;
+    /**
+     * The arguments the pin gave the call, for the step's verdict: the plan
+     * never sees a steered call, so this is the only place they are known when
+     * its result lands.
+     */
+    input?: Record<string, unknown>;
     /**
      * When the host said the call finished (`PostToolUse`), if the control
      * server told us ({@link ReplayController.hostCompleted}). A wrapped step
@@ -854,7 +860,14 @@ export declare class ReplayController {
      * never be told something the log does not also say.
      */
     private observeStep;
-    /** Upsert one step's verdict. Later news about a step replaces earlier news. */
+    /**
+     * Upsert one step's verdict. Later news about a step replaces earlier news.
+     *
+     * The verdict keeps what the step sent and what came back, when the caller
+     * has them. They are this run's, which the service can learn nowhere else:
+     * a matched turn is not recorded, so without them the scenario's page shows
+     * the recording's input and output beside this run's verdict.
+     */
     private recordStep;
     /** The step verdicts, in chain order, for the execution report. */
     private stepResultsOf;

package/dist/replay/controller.js

@@ -13,8 +13,8 @@
  */
 import { parseQualifiedName } from "../control/correlation.js";
 import { isHousekeepingCall } from "../record/housekeeping.js";
-import { redact } from "../record/redact.js";
-import { serializeCapped } from "../record/truncate.js";
+import { REDACT_SCAN_MAX_CHARS, redact, redactJsonText, redactText } from "../record/redact.js";
+import { capText, REPORT_PAYLOAD_MAX_BYTES, serializeCapped } from "../record/truncate.js";
 import { logDetail, logLine, errText } from "../util/log.js";
 import { serviceHealth, serviceTimeoutMs, timeoutSignal, } from "../util/service-health.js";
 import { bashCommandFor } from "./bash-channel.js";
@@ -779,7 +779,13 @@ export class ReplayController {
             // The model does the task itself — told so in place of this call.
             const step = plan.currentStep();
             if (step && ready.blame) {
-                this.recordStep(state, { step, outcome: "failed", stage: ready.stage, error: ready.error });
+                this.recordStep(state, {
+                    step,
+                    entry: plan.currentEntry(),
+                    outcome: "failed",
+                    stage: ready.stage,
+                    error: ready.error,
+                });
             }
             this.handOver(state, {
                 kind: "step_failed",
@@ -829,6 +835,7 @@ export class ReplayController {
                     reach: this.reachFor(state, step),
                     toolName,
                     pinnedAt: Date.now(),
+                    input,
                 });
                 logDetail("replay.pin", { n: plan.currentStepIndex, tool: toolName });
                 return { kind: "pin", input, stepIndex: plan.currentStepIndex };
@@ -850,6 +857,7 @@ export class ReplayController {
                 if (step) {
                     this.recordStep(state, {
                         step,
+                        entry: plan.currentEntry(),
                         outcome: "failed",
                         stage: "tool_input_logic",
                         error: errText(err),
@@ -1043,6 +1051,10 @@ export class ReplayController {
         // reading it after the call would judge the *next* step, and reading it
         // before assumes no other pin ever moved it.
         const step = plan.allSteps()[pin.stepIndex];
+        // The entry it ran as, so its verdict is kept under the scenario that owns
+        // the step: a called segment numbers its steps from zero too, and without
+        // this its step 0 replaced the caller's (segmented.md R-CALL-13).
+        const entry = plan.allEntries()[pin.stepIndex];
         // The output threads into the step at the cursor. One pin at a time
         // (`preTool`) keeps that the pin's own step; if it ever is not, threading
         // would feed one step's output to another's logic, so the plan stops.
@@ -1057,6 +1069,9 @@ export class ReplayController {
                 `the plan's cursor is at step ${plan.currentStepIndex}, not the pinned step ${pin.stepIndex}`;
             const info = {
                 step,
+                entry,
+                input: pin.input,
+                output: answerOf(output),
                 outcome: "failed",
                 stage: "tool_call",
                 error,
@@ -1068,7 +1083,7 @@ export class ReplayController {
             this.handOver(state, {
                 kind: "step_failed",
                 step,
-                entry: plan.allEntries()[pin.stepIndex],
+                entry,
                 position: pin.stepIndex,
                 error,
                 delivery: "above",
@@ -1090,6 +1105,10 @@ export class ReplayController {
             if (step) {
                 this.recordStep(state, {
                     step,
+                    entry,
+                    input: pin.input,
+                    // What the logic threw on — the output is usually the explanation.
+                    output,
                     outcome: "failed",
                     stage: "tool_output_logic",
                     error: errText(err),
@@ -1125,6 +1144,9 @@ export class ReplayController {
         if (step && toolError) {
             const info = {
                 step,
+                entry,
+                input: pin.input,
+                output,
                 outcome: "failed",
                 stage: "tool_call",
                 error: toolError,
@@ -1146,6 +1168,9 @@ export class ReplayController {
         if (step) {
             this.recordStep(state, {
                 step,
+                entry,
+                input: pin.input,
+                output,
                 outcome: "executed",
                 ms: Date.now() - pin.pinnedAt,
             });
@@ -1210,13 +1235,23 @@ export class ReplayController {
                 ? `${failure.error} — it was sent, and may or may not have completed`
                 : failure.error
             : toolResultError(output);
+        const entry = plan.allEntries()[pin.stepIndex];
         if (error !== undefined) {
-            const info = { step, outcome: "failed", stage: "tool_call", error, ms };
+            const info = {
+                step,
+                entry,
+                input: pin.input,
+                output: answerOf(output),
+                outcome: "failed",
+                stage: "tool_call",
+                error,
+                ms,
+            };
             this.logStep(info);
             this.recordStep(state, info);
             return;
         }
-        this.recordStep(state, { step, outcome: "executed", ms });
+        this.recordStep(state, { step, entry, input: pin.input, output, outcome: "executed", ms });
         state.stepsPinned += 1;
         this.upgrade(state, "fell_back");
         logDetail("replay.thread_late", {
@@ -2308,7 +2343,14 @@ export class ReplayController {
             this.recordStep(state, info);
         };
     }
-    /** Upsert one step's verdict. Later news about a step replaces earlier news. */
+    /**
+     * Upsert one step's verdict. Later news about a step replaces earlier news.
+     *
+     * The verdict keeps what the step sent and what came back, when the caller
+     * has them. They are this run's, which the service can learn nowhere else:
+     * a matched turn is not recorded, so without them the scenario's page shows
+     * the recording's input and output beside this run's verdict.
+     */
     recordStep(state, info) {
         const status = info.outcome === "executed" ? "ok" : info.outcome;
         // Keyed by the *flat* position, not by the step's own index: two scenarios
@@ -2325,6 +2367,16 @@ export class ReplayController {
                 ? `${info.error.slice(0, MAX_STEP_ERROR_CHARS)}…`
                 : info.error
             : undefined;
+        // Payloads only for a step of the reported scenario's own chain. The
+        // console still files an execution's verdicts by step number alone
+        // (plan-services.md W1.9), and a called segment numbers its steps from
+        // zero as well: a called step's call would be shown under the caller's
+        // step of the same number — the very mix-up the payloads are there to end.
+        const own = !info.entry || info.entry.depth === 0;
+        // A step whose input logic threw never had an input: the `{}` the plan
+        // reports there is a placeholder, not a call with no arguments.
+        const sent = own && info.stage !== "tool_input_logic" ? info.input : undefined;
+        const received = own ? info.output : undefined;
         state.stepResults.set(key, {
             stepIndex: info.step.stepIndex,
             toolName: info.step.toolName ?? "",
@@ -2334,6 +2386,8 @@ export class ReplayController {
             stage: info.stage ?? (status === "skipped" ? "tool_call" : undefined),
             error,
             durationMs: info.ms,
+            toolInput: sent === undefined ? undefined : reportPayload(serializeCapped(redact(sent)), true),
+            toolOutput: received === undefined ? undefined : reportPayload(received),
             // The tool is gone from its server: the service repairs the plan without
             // waiting out the grace (plan-services.md D8, kind 2).
             toolMissing: info.toolMissing || undefined,
@@ -2507,6 +2561,37 @@ function pinFailure(pin, output, failed, how) {
                 : "the tool reported an error");
     return { error, reason };
 }
+/**
+ * What a call that did not thread answered with, if it answered anything.
+ * `null` is a proxy that lost the call (tool-error.ts, `isNoResult`), and `{}`
+ * is how a hook that carried no `tool_response` reaches here: neither is an
+ * output anybody received.
+ */
+function answerOf(output) {
+    return isNoResult(output) || output.trim() === "{}" ? undefined : output;
+}
+/**
+ * A step's input or output as its verdict carries it: redacted as a recorded
+ * step's is, and cut — visibly — to what a report has room for.
+ *
+ * Cut as text rather than kept as JSON: these are read on the scenario's page,
+ * never parsed, and the first kilobytes of the payload itself read better than
+ * a preview of it inside a second layer of escapes.
+ *
+ * `clean` says it was redacted a moment ago — the input, serialized by the
+ * caller. An output may not have been: the hook's view of a steered built-in
+ * is threaded as the host gave it. So an output is redacted here, and as JSON,
+ * where a secret is judged by its key as well as by its shape.
+ */
+function reportPayload(json, clean = false) {
+    if (clean)
+        return capText(json, REPORT_PAYLOAD_MAX_BYTES);
+    // Larger than any producer here makes: only what a report keeps is scanned.
+    if (json.length > REDACT_SCAN_MAX_CHARS) {
+        return capText(json, REPORT_PAYLOAD_MAX_BYTES, redactText);
+    }
+    return capText(redactJsonText(json), REPORT_PAYLOAD_MAX_BYTES);
+}
 /**
  * The index a hand-over reports, in the *caller's* chain (R-CALL-32).
  *

package/dist/replay/plan.d.ts

@@ -105,6 +105,12 @@ export interface StepInfo {
      */
     entry?: FlatEntry;
     input: Record<string, unknown>;
+    /**
+     * What the step's output logic was given: the tool's answer, or for
+     * `recorded` the source run's output that stood in for it. Absent when the
+     * call produced none — `skipped`, or a failure before the tool ran.
+     */
+    output?: string;
     outcome: "executed" | "recorded" | "skipped" | "failed";
     /** Which part of the step broke. Only set for `failed`. */
     stage?: ExecutionStage;

package/dist/replay/plan.js

@@ -215,8 +215,11 @@ function settingsOf(paramsObject, mapped) {
  * 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.
+ *
+ * `output` is what the body was given, for a stage that runs on one: a throw
+ * in the output logic is only readable next to the output it threw on.
  */
-function reportingStage(onStep, entry, stage, input, startedAt, fn) {
+function reportingStage(onStep, entry, stage, input, startedAt, fn, output) {
     try {
         return fn();
     }
@@ -225,6 +228,7 @@ function reportingStage(onStep, entry, stage, input, startedAt, fn) {
             step: entry.step,
             entry,
             input,
+            output,
             outcome: "failed",
             stage,
             error: err instanceof Error ? err.message : String(err),
@@ -817,6 +821,7 @@ export class ScenarioReplayPlan {
                         step,
                         entry,
                         input: computed,
+                        output: response,
                         outcome: "failed",
                         stage: "tool_call",
                         error: toolError,
@@ -845,7 +850,7 @@ export class ScenarioReplayPlan {
                         Object.assign(resp.get(entry.frame.id) ?? {}, derived);
                     }
                     this.leaveFrame(entry, resp);
-                });
+                }, response);
             }
             catch (err) {
                 if (!stopOnFailure)
@@ -872,6 +877,7 @@ export class ScenarioReplayPlan {
                     step,
                     entry,
                     input: computed,
+                    output: response,
                     outcome: error ? "failed" : "executed",
                     stage: error ? "tool_call" : undefined,
                     error,
@@ -977,6 +983,7 @@ export class ScenarioReplayPlan {
                         step,
                         entry,
                         input: computed,
+                        output: response,
                         outcome: "failed",
                         stage: "tool_call",
                         error: toolError,
@@ -997,7 +1004,7 @@ export class ScenarioReplayPlan {
             }
             let derivedKeys;
             try {
-                derivedKeys = reportingStage(onStep, entry, "tool_output_logic", computed, startedAt, () => this.applyOutput(response));
+                derivedKeys = reportingStage(onStep, entry, "tool_output_logic", computed, startedAt, () => this.applyOutput(response), response);
             }
             catch (err) {
                 if (!stopOnFailure)
@@ -1024,6 +1031,7 @@ export class ScenarioReplayPlan {
                     step,
                     entry,
                     input: computed,
+                    output: response,
                     outcome: error ? "failed" : "executed",
                     stage: error ? "tool_call" : undefined,
                     error,
@@ -1095,6 +1103,8 @@ export class ScenarioReplayPlan {
                 step,
                 entry,
                 input: computed,
+                // The stand-in is what the step's output logic runs on from here.
+                output: standIn,
                 outcome: standIn !== undefined ? "recorded" : "skipped",
                 error,
                 toolMissing: isMissingToolError(error) || undefined,

package/dist/replay/types.d.ts

@@ -249,6 +249,22 @@ export interface ExecutionStepResult {
     /** Message only — never a tool payload; this is rendered in a web page. */
     error?: string;
     durationMs?: number;
+    /**
+     * What the step sent its tool on this run: the arguments its input logic
+     * computed, serialized and redacted as a recorded step's are, and cut to
+     * what a report carries. Absent when the step broke before it had any.
+     *
+     * Without the two payloads the scenario's page can only put the recording's
+     * sample under this run's verdict and time — a call that was not made, and
+     * an answer that was not given, on a card that says "passed".
+     */
+    toolInput?: string;
+    /**
+     * What the step's output logic was given, on the same terms: the tool's
+     * answer, or for `recorded` the source run's output that stood in for it.
+     * Absent on a step that got none.
+     */
+    toolOutput?: string;
     /**
      * The step's tool no longer exists on its server, read from the error text
      * (plan-services.md D8, kind 2). The service then repairs the plan without

package/docs/calculatedReplay.md

@@ -903,9 +903,38 @@ steps: Array<{
   stage?: ExecutionStage;     // where in the step, for `failed` / `skipped`
   error?: string;             // message only — this is rendered in a web page
   durationMs?: number;
+  toolInput?: string;         // what the step sent its tool, as JSON text
+  toolOutput?: string;        // what its output logic was given
 }>
 ```
 
+**What the step sent and received.** `toolInput` is the arguments the step's input logic computed
+on this turn, and `toolOutput` what its output logic was given: the tool's answer, or for `recorded`
+the source run's output that stood in. They are this run's, and the service can learn them nowhere
+else — a matched turn is not recorded (§12). Without them the recording page can only put the
+recording's own sample under this run's verdict and time: a transfer of 3500 beside "passed", after
+a replay that sent 3600.
+
+- **Redacted and capped.** Each is serialized and redacted as a recorded step's payload is
+  (`serializeCapped(redact(…))`; an output is redacted again here, as JSON, because the hook's view
+  of a steered built-in is threaded as the host gave it). Then it is cut to 3,800
+  bytes (`REPORT_PAYLOAD_MAX_BYTES`), as text and with a marker that says how much was dropped: these
+  are read on a page, never parsed, and with its marker a cut payload still fits the 4,000
+  characters the service keeps of each — so the page shows this cut and its sizes, not a second one.
+  The recorder redacts once more as it sends.
+- **Inside one small request.** The service reads `POST /scenarios/:id/executions` with its 100 kB
+  JSON parser (only `/recordings` has the 5 MB one) and answers a larger body 413, which would lose
+  the turn's cost with it. So the recorder holds the whole report to 96 KiB (`REPORT_MAX_BYTES`):
+  it writes the costs and the verdicts first, then adds payloads while they fit — the failed steps'
+  first, then every step's input, then the outputs, in the order the steps ran. A payload that does
+  not fit is left out, and its step keeps its verdict.
+- **Absent where there was none.** A step whose input logic threw has no input. A `skipped` step
+  has no output, and neither has a call the host says failed without a result.
+- **Only for the reported scenario's own steps.** A step inside a called segment is reported with
+  its verdict and its `scenarioId`, without payloads: the console still files verdicts by step
+  number alone (the service's plan-services.md, W1.9), and a called segment numbers its steps from
+  zero too.
+
 `ok` and `recorded` are passes (`recorded` with an asterisk: the values came from the source run,
 which happens only with `BIR_REPLAY_RECORDED_OUTPUTS=1` and in `bir replay`). `skipped` produced no
 result here: its call could not be sent (a built-in outside the session, no proxy for its server,
@@ -926,8 +955,10 @@ The verdicts come from `plan.ts`'s `onStep`, which has always known them — wit
 logic failure is announced *before* the throw propagates (`reportingStage`), because after it
 nothing knows which step the stack trace belonged to. In steer mode there is no loop to observe, so
 the controller records the verdict at both hooks: `PreToolUse` for an input-logic throw, `PostToolUse`
-for the pass or the output-logic throw. `ReplayState.stepResults` is keyed by step index so the
-second word on a step replaces the first.
+for the pass or the output-logic throw — and keeps the pinned arguments on the pin, so the verdict
+`PostToolUse` writes can say what the call ran with. `ReplayState.stepResults` is keyed by the
+scenario that owns the step and its index, so the second word on a step replaces the first and a
+called segment's step 0 never replaces the caller's.
 
 One consequence for the rule that a costless decline is not worth sending (`buildReport`, and the
 service's matching `202 { recorded: false }`): it now *is* worth sending when a step broke. No cost
@@ -991,6 +1022,10 @@ trusting it.
 would 404. `run.recording = false` already handles it — `record()` early-returns and `sealRun` skips
 both the final answer and `finishRun`.
 
+What the turn's steps sent and received is not lost with it: the execution report carries them, on
+each step's verdict (§11.2a). That is the only copy the service gets, and it is what the recording
+page shows as the scenario's last run.
+
 Three consequences to keep straight:
 
 1. **Step indices are still allocated.** `ordering` runs regardless, correlations are still minted

package/docs/calculatedReplayGuide.md

@@ -572,6 +572,7 @@ matches. A prompt that missed both is matched once more on its task line (`PROMP
 | A parked step ran again after an hour, or a plan was recalculated by itself | The service's grace period (D8): a parked step is served with `stop: null` once an hour for a day and a success clears its count; if it keeps failing, or its tool is gone, the next repeat of the prompt is recorded in full and the plan is calculated again from it | Nothing: that is the repair. `bir investigate` says which it is — a step still being retried, a parked step whose repair is due, or a plan being calculated again. To repair now by hand: `bir scenario calc <runId> --force` for a whole-run plan; from the next version, `bir scenario calc <scnId> --force` works for any plan, a sub-task one included. A plan with steps edited by hand is not repaired by itself: the parked step stays parked, and `bir investigate` says the repair was skipped. Then fix the step (§9.2); or take the edits back with `bir scenario undo`, once per edit, and it is repaired as usual; or recalculate now and drop the edits: `bir scenario calc <scnId> --force --discard-edits` |
 | `sessionCostUsd` grows every prompt in a session | The per-run usage watermark is missing or not taken | Design §11.4. Reports without a mark must carry `measured: false` |
 | Everything works, nothing is saved | A replayed turn is deliberately not recorded (design §12) | Correct. The matched run stays canonical and its `iterations` is bumped |
+| The console shows a replayed step's input and output with the recording's values, beside this run's verdict and time | The run was reported by a runner up to 0.3.8, which sent each step's verdict and duration and nothing of what it sent or received. The page then falls back to the recording's sample (design §11.2a) | Update the runner: a newer one sends each replayed step's input and output with its verdict, redacted and cut to under 4 KB, and the card shows them as *last run*. To see what an older replay ran with: the result of `mcp__bir__run_scenario` in the session's transcript, or `lastParams` in `bir scenario show scn_…` |
 | `bir doctor`: the SessionStart hook points at a Node that is gone | The hook names Node by absolute path. That Node was uninstalled, moved, or was a version manager's per-shell copy; the hook then fails on every session, no recorder is started, and runs record Tier 2 | `bir setup` here again — it rewrites the hook to the Node that runs it |
 | `control.port_busy` in the log; the recorder is not running | Another program holds this project's port, or the system excludes it (on Windows, a range Hyper-V or WSL reserved). A background recorder with a recorded port does not fall back to another, because every hook but SessionStart names this one; only a `bir-hooks` you run by hand in a terminal still does | `bir setup --port <another>` in this directory — the fix the log line itself names. It rewrites the hook URLs and the scenario server's address together and restarts the recorder |
 | The recorder was started by the hook, and `bir doctor` says `servers=(all wrapped)` although you set `BIR_REPLAY_ALLOW_SERVERS` | The hook starts the recorder with Claude Code's environment, not your terminal's; a variable set in one terminal is not seen | `bir replay allow <a,b>` — stored for the project, read by every recorder — then `bir up --restart` |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@basein/runner",
-  "version": "0.3.8",
+  "version": "0.3.9",
   "description": "A recording MCP proxy: sits between any MCP client and its MCP servers, executes each call on the client's behalf, and records the run as a reusable BaseIn scenario.",
   "type": "module",
   "license": "MIT",

package/production.md

@@ -518,6 +518,7 @@ Over 2-minute runs with one turn every 8 s (92 hooks):
 - Non-JSON tool errors: 8 KiB.
 - Report errors: 2 KiB.
 - Tool payloads: 64 KiB.
+- A replayed step's input and output, in the execution report: 3,800 bytes each, redacted like a recorded step's. The whole report stays under 96 KiB, because the service reads that route with its 100 kB parser: a payload that does not fit is left out, and its step keeps its verdict.
 
 Truncation is always marked with the original size.