@basein/runner 0.3.8 → 0.3.10

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";
@@ -62,7 +62,7 @@ export const DEFAULT_BUDGETS = {
     deriveMs: 8_000,
     planMs: 100_000,
     stepMs: 60_000,
-    hookDeriveMs: 4_000,
+    hookDeriveMs: 8_000,
     preToolMs: 9_000,
 };
 /**
@@ -311,15 +311,21 @@ export class ReplayController {
      * Always returns a state — a declined match still has a ticket to redeem and a
      * baseline sample to contribute, and losing that is how a savings ledger ends
      * up with a denominator nobody measured.
+     *
+     * `host` is given for a session whose host is not Claude Code, and is kept
+     * on the state (see {@link HostContext}).
      */
-    async arm(match, prompt, wrapped, armedBy = "prompt", ctx = {}) {
+    async arm(match, prompt, wrapped, armedBy = "prompt", ctx = {}, host) {
         const state = {
             scenarioId: match.scenarioId,
             ticket: match.executionTicket,
             similarity: match.similarity,
             matchedRunId: match.runId,
             mode: "none",
-            wrapped,
+            // No proxy of this folder sees another host's calls, whatever a tool is
+            // named: every output is threaded from the host's own report.
+            wrapped: host ? new Set() : wrapped,
+            host,
             pinned: new Map(),
             outcome: "not_steered",
             deriveCostUsd: 0,
@@ -364,6 +370,18 @@ export class ReplayController {
         // Gate 2 — replay enabled.
         if (!this.enabled)
             return decline("BIR_REPLAY=0", "replay_disabled");
+        // And asked for. An adapter that only records never asks for a plan, and
+        // one started for it anyway would have nobody to step through it — while
+        // every call its model made itself would be read against the plan.
+        if (host?.recordsOnly) {
+            return decline(`the ${host.app} adapter of this run only records — it asked for no plan with its prompt`, "host_records_only");
+        }
+        // The service matched the prompt and handed over nothing, because this
+        // runner is older than its plans need (its RUNNER_MIN_CONTRACT). Its own
+        // code, ahead of "no scenario": the fix is an update, not a calculation.
+        if (match.withheld === "runner_update_required") {
+            return decline("the service hands this runner no plan until it is updated — run `bir update`", "runner_update_required");
+        }
         // Gate 3 — a ready scenario with steps.
         const scenario = match.scenario;
         if (!match.scenarioId || !isReadyScenario(scenario)) {
@@ -428,7 +446,13 @@ export class ReplayController {
         // built-in on `BIR_BUILTIN_TOOLS` counts as reachable: the runner
         // executes it itself (replay/builtins.ts), so a chain that starts with a
         // `Read` no longer forces steer mode.
-        const mode = modeFor(planned.map((e) => e.step), wrapped, this.opts.allowServers, this.builtinTools);
+        //
+        // Another host's plan is always `steer`, every step `live`: its tools are
+        // in its own process, and a tool it happens to call `Read` or
+        // `mcp__fleet__list` is not the runner's to run or a proxy's to reach.
+        const allowServers = host ? undefined : this.opts.allowServers;
+        const builtinTools = host ? undefined : this.builtinTools;
+        const mode = modeFor(planned.map((e) => e.step), state.wrapped, allowServers, builtinTools);
         if (mode === "none")
             return decline("no step is executable", "coverage");
         // Tool results feed derivation as context, and they are whatever the agent
@@ -441,11 +465,11 @@ export class ReplayController {
         // target only a result names declines more often — one replay, never a
         // command nobody asked for.
         let deriveCtx = ctx;
-        if (ctx.recentResults?.length && sinkOfPlan(planned) === "command") {
+        if (ctx.recentResults?.length && sinkOfPlan(planned, host?.sinks) === "command") {
             deriveCtx = { liveCall: ctx.liveCall };
             logLine("replay.derive_context", {
                 scenario: scenario.id,
-                shell: hasShellStep(planned) || undefined,
+                shell: hasShellStep(planned, host?.sinks) || undefined,
                 why: "a step's input is run by a shell or a database (or its tool is named for one, such as *_query) — " +
                     "recent tool results are not read for its parameters, so a target only they name is not found",
             });
@@ -527,7 +551,7 @@ export class ReplayController {
             // same check still runs where the values settle later (`readyFor`).
             // It travels as `missing_target`: the value read for a target could not
             // be used, and no new code reaches a service that may not know it.
-            const sink = sinkOfPlan(planned);
+            const sink = sinkOfPlan(planned, host?.sinks);
             if (result?.derived && sink) {
                 const bad = unsafeParameter(result.params, scenario.paramsObject, sink);
                 if (bad) {
@@ -590,6 +614,7 @@ export class ReplayController {
             run: match.runId,
             scenario: scenario.id,
             mode,
+            host: host?.app,
             steps: entries.length,
             stopsAt: stopAt,
             by: armedBy === "intent" ? "intent" : undefined,
@@ -602,11 +627,99 @@ export class ReplayController {
             unusable: flat.stopReason?.reason,
             // Which steps the service told this plan to stop in front of, and why.
             stops: stopLines(entries),
-            coverage: coverageOf(entries.map((e) => e.step), wrapped, this.opts.allowServers, this.builtinTools).join(","),
+            coverage: coverageOf(entries.map((e) => e.step), state.wrapped, allowServers, builtinTools).join(","),
             tools: entries.map((e) => e.step.toolName ?? "").join(","),
         });
         return state;
     }
+    /**
+     * The armed plan as data: the steps it will run, in order, and where it
+     * stops when that is before its end. For a host that steps through the plan
+     * itself and must not have to pick the tool names out of a directive
+     * written for a model — a reworded sentence would break every adapter in
+     * the field. Built from the same entries the directive lists.
+     */
+    planData(state) {
+        const plan = state.plan;
+        if (!plan || state.retired)
+            return undefined;
+        const steps = plan
+            .allEntries()
+            .slice(0, plan.stepCount)
+            .map((entry, stepIndex) => ({ stepIndex, toolName: entry.step.toolName ?? "" }));
+        return {
+            scenarioId: state.scenarioId,
+            mode: state.mode,
+            steps,
+            ...(plan.stopsEarly() ? { stopAt: plan.stepCount } : {}),
+        };
+    }
+    /**
+     * Take back a plan that armed and has run nothing, as a decline.
+     *
+     * For what `arm` could not know: which tools the agent of another host
+     * holds. Such a host shows its tools only when its model is about to be
+     * called, with the first request for a step, and a plan that names a tool
+     * the agent lacks cannot be finished there. It ends before any step runs,
+     * booked like any gate's decline: `not_steered` under `code`, no step
+     * marked failed or missing — either would count against a plan that is
+     * not at fault. Returns false, changing nothing, once a step has run.
+     */
+    declineArmed(state, code, why) {
+        if (!state.plan || state.retired)
+            return false;
+        if (state.stepsPinned > 0 || state.pinned.size > 0 || state.stepResults.size > 0)
+            return false;
+        state.declined = code;
+        logLine("replay.decision", {
+            verdict: "no-steer",
+            code,
+            run: state.matchedRunId,
+            scenario: state.scenarioId ?? undefined,
+            similarity: state.similarity.toFixed(3),
+            kind: state.kind,
+            why,
+        });
+        state.plan = undefined;
+        state.mode = "none";
+        state.stepsPlanned = 0;
+        this.retire(state, undefined);
+        return true;
+    }
+    /**
+     * Hand a live plan over for something its host did, not the plan: the
+     * model made a call of its own while the plan was live (`own_call`), the
+     * run was closed with the plan still live (`closed`), or the host was
+     * answered without a step's arguments because they were not ready in time
+     * (`late`).
+     *
+     * Only for a host that is not Claude Code, where a call the plan did not
+     * hand out is by definition the model's own — it is never pinned and never
+     * answered with a bundle. No step is marked failed, so nothing is counted
+     * against the plan; the outcome is `fell_back` when a step ran and `failed`
+     * when none did, as for every hand-over. The note is the caller's to
+     * deliver ({@link takeNote}). Returns false when there was no live plan.
+     */
+    hostHandOver(state, why) {
+        const plan = state.plan;
+        if (!plan || state.retired)
+            return false;
+        const position = plan.currentStepIndex;
+        this.handOver(state, {
+            kind: "step_failed",
+            step: plan.currentStep(),
+            entry: plan.currentEntry(),
+            position,
+            error: why === "own_call"
+                ? "the model made a call of its own, so the scenario stopped"
+                : why === "late"
+                    ? "its arguments were not ready in time"
+                    : "the run ended before this step",
+            delivery: "above",
+            stopReason: "not_run",
+        });
+        return true;
+    }
     /**
      * The directive to inject via `additionalContext`, or undefined when declined.
      *
@@ -650,6 +763,10 @@ export class ReplayController {
         const plan = state.plan;
         if (!plan || state.retired || state.mode !== "steer")
             return false;
+        // Another host reads the plan as data and is handed each step's arguments
+        // when it asks for them: there is no preview to wait for.
+        if (state.host)
+            return false;
         if (plan.parametersSettled)
             return true;
         const planned = plan.allEntries().slice(0, plan.stepCount);
@@ -695,9 +812,13 @@ export class ReplayController {
      * Deliver text to the model in place of the tool call it was about to make:
      * as genuine command output for `Bash`, as the denial reason otherwise — the
      * two channels a divergence bundle already uses.
+     *
+     * `otherHost` is a session whose host is not Claude Code: a tool it calls
+     * `Bash` is its own, and its command is never rewritten. The text is always
+     * the refusal reason there.
      */
-    deliverInstead(text, toolName) {
-        if (toolName === "Bash") {
+    deliverInstead(text, toolName, otherHost = false) {
+        if (toolName === "Bash" && !otherHost) {
             // A short command, whatever the text's size (bash-channel.ts): a long
             // heredoc is cut by the shell, and a long output by the host.
             const command = bashCommandFor(truncate(text, BASH_CHANNEL_MAX));
@@ -750,7 +871,8 @@ export class ReplayController {
         // `bir scenario show` the model runs while a Bash step is expected must
         // run as `bir`, never be swapped for the plan's command (D13). And before
         // the wait for the parameters, which a `ToolSearch` has no use for.
-        if (isHousekeepingCall(toolName, toolInput)) {
+        const otherHost = state.host !== undefined;
+        if (isHousekeepingCall(toolName, toolInput, otherHost)) {
             logDetail("replay.housekeeping", {
                 tool: toolName,
                 step: `${plan.currentStepIndex}/${plan.stepCount}`,
@@ -779,7 +901,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",
@@ -791,7 +919,7 @@ export class ReplayController {
                 stopReason: "not_run",
             });
             const note = this.takeNote(state);
-            return note ? this.deliverInstead(note, toolName) : { kind: "abort" };
+            return note ? this.deliverInstead(note, toolName, otherHost) : { kind: "abort" };
         }
         // ONE CALL AT A TIME. A pin moves the cursor only when its output threads,
         // which for a wrapped step is the proxy's report — landing either side of
@@ -829,6 +957,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 +979,7 @@ export class ReplayController {
                 if (step) {
                     this.recordStep(state, {
                         step,
+                        entry: plan.currentEntry(),
                         outcome: "failed",
                         stage: "tool_input_logic",
                         error: errText(err),
@@ -863,11 +993,29 @@ export class ReplayController {
                     });
                     const note = this.takeNote(state);
                     if (note)
-                        return this.deliverInstead(note, toolName);
+                        return this.deliverInstead(note, toolName, otherHost);
                 }
                 return { kind: "abort" };
             }
         }
+        if (state.host) {
+            // Another host steps through the plan by asking for each step in turn,
+            // so a request for anything but the next step is its adapter out of
+            // step with the plan. Nothing can be recovered by running the rest
+            // here — only the host can run its tools — so the plan stops, and the
+            // model is told which steps ran. No step is marked failed.
+            this.handOver(state, {
+                kind: "step_failed",
+                step: plan.currentStep(),
+                entry: plan.currentEntry(),
+                position: plan.currentStepIndex,
+                error: `the scenario's next step is ${expected ?? "none"}, and the host asked for ${toolName}`,
+                delivery: "above",
+                stopReason: "not_run",
+            });
+            const note = this.takeNote(state);
+            return note ? this.deliverInstead(note, toolName, true) : { kind: "abort" };
+        }
         return await this.diverge(state, toolName, `expected ${expected ?? "no more tools"}, model called ${toolName}`, deadline, hook.signal);
     }
     /**
@@ -919,7 +1067,9 @@ export class ReplayController {
         if (inFlight.size > 0)
             state.lingering = inFlight;
         const note = this.takeNote(state);
-        return note ? this.deliverInstead(note, toolName) : { kind: "passthrough" };
+        return note
+            ? this.deliverInstead(note, toolName, state.host !== undefined)
+            : { kind: "passthrough" };
     }
     /**
      * Wait until the plan's outstanding pins thread, or until waiting is no
@@ -1043,6 +1193,28 @@ 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 HOST STOPPED THE STEP, and says so. Read before any failure: a
+        // person's "no" arrives as an error result, and booked as one it would be
+        // counted against a plan that did nothing wrong — after enough of them the
+        // service stops serving the step. Nothing threads either way: after
+        // `rejected` the tool never ran, and after `edited` its result answers a
+        // call the plan did not plan, which its later steps were not computed for.
+        if (how.hostStop && step) {
+            this.hostStopped(state, pin, step, entry, output, how.hostStop);
+            this.handOver(state, {
+                kind: "step_failed",
+                step,
+                entry,
+                position: pin.stepIndex,
+                delivery: "above",
+                stopReason: how.hostStop === "edited" ? "host_edited" : "host_rejected",
+            });
+            return false;
+        }
         // 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 +1229,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 +1243,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 +1265,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 +1304,9 @@ export class ReplayController {
         if (step && toolError) {
             const info = {
                 step,
+                entry,
+                input: pin.input,
+                output,
                 outcome: "failed",
                 stage: "tool_call",
                 error: toolError,
@@ -1146,6 +1328,9 @@ export class ReplayController {
         if (step) {
             this.recordStep(state, {
                 step,
+                entry,
+                input: pin.input,
+                output,
                 outcome: "executed",
                 ms: Date.now() - pin.pinnedAt,
             });
@@ -1201,6 +1386,11 @@ export class ReplayController {
         const step = plan.allSteps()[pin.stepIndex];
         if (!step)
             return;
+        if (how.hostStop) {
+            // The host stopped it: neither a failure nor work the plan did.
+            this.hostStopped(state, pin, step, plan.allEntries()[pin.stepIndex], output, how.hostStop);
+            return;
+        }
         const ms = Date.now() - pin.pinnedAt;
         // Read the same way as a live pin's (`pinFailure`). A call that was sent
         // and not seen through says so in its verdict: it may have done its work.
@@ -1210,13 +1400,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", {
@@ -1225,6 +1425,39 @@ export class ReplayController {
             why: "a step pinned before the hand-over finished — counted, not threaded",
         });
     }
+    /**
+     * Record a step its host stopped ({@link PostToolOptions.hostStop}) as
+     * `skipped`, in plain words, and remember the stop for the report. Never
+     * `failed`: the service counts failures against the plan. And not counted
+     * in `stepsPinned`: the plan's own call did not run.
+     */
+    hostStopped(state, pin, step, entry, output, stop) {
+        const edited = stop === "edited";
+        // After `rejected` nothing later can change what the report may claim.
+        if (state.hostStop !== "rejected")
+            state.hostStop = stop;
+        logLine("replay.step_host_stopped", {
+            scenario: state.scenarioId ?? undefined,
+            n: step.stepIndex,
+            tool: step.toolName ?? undefined,
+            stop,
+            why: edited
+                ? "a person changed this call before it ran — it ran with their arguments, and the plan stops there"
+                : "the host did not run this step — a person said no or answered in its place, or a limit blocked it",
+        });
+        this.recordStep(state, {
+            step,
+            entry,
+            // The plan's own arguments are what a refused call was asked with; a
+            // changed call ran with other ones, which only the host knows.
+            input: edited ? undefined : pin.input,
+            output: answerOf(output),
+            outcome: "skipped",
+            stage: "tool_call",
+            error: edited ? "a person changed this call" : "the host did not run this step",
+            ms: Date.now() - pin.pinnedAt,
+        });
+    }
     /** Whether a pinned call's output is threaded from the proxy's report (§7.2). */
     threadsFromProxy(state, toolUseId) {
         const pin = state.pinned.get(toolUseId) ?? state.lingering?.get(toolUseId);
@@ -1494,8 +1727,14 @@ export class ReplayController {
             stepsPlanned: state.stepsPlanned,
             stepsPinned: state.stepsPinned,
             // A run its caller cancelled ended the turn early: its cost is no
-            // measurement of the task, whatever the transcript says.
-            measured: d.measured && state.callerCancelled !== true,
+            // measurement of the task, whatever the transcript says. So is one a
+            // person said no in: the model is told not to run that step, the task
+            // ends short of itself, and a verified saving booked against it would
+            // be the cost of the work nobody did.
+            measured: d.measured &&
+                state.callerCancelled !== true &&
+                state.hostStop !== "rejected" &&
+                d.cutShort !== true,
             pricingVersion: PRICING_VERSION,
             prompt: d.prompt,
             steps,
@@ -1524,7 +1763,14 @@ export class ReplayController {
             // wrong before — a declined prompt scenario followed by an intent-armed
             // plan, whose "baseline" was really the turn cut short at the second arm.
             // A lone plan, armed or declined, sends nothing: the default is eligible.
-            baselineEligible: d.siblings?.some((s) => s !== state && s.plan !== undefined)
+            //
+            // Nor is a turn its host stopped a step of, or one that was cut short.
+            // After a person's "no" the task ended early; after a changed call that
+            // was the plan's first step, the turn made one model call fewer than
+            // the task needs — the one the plan's call replaced.
+            baselineEligible: d.siblings?.some((s) => s !== state && s.plan !== undefined) ||
+                state.hostStop !== undefined ||
+                d.cutShort === true
                 ? false
                 : undefined,
         };
@@ -1880,7 +2126,7 @@ export class ReplayController {
             // done its work, and the model must know before it does the task itself.
             if (stop?.reason === "uncertain" && stop.flatIndex !== undefined) {
                 const note = this.stopNote(state, plan, stop, "none");
-                return this.deliverInstead(note, toolName);
+                return this.deliverInstead(note, toolName, state.host !== undefined);
             }
             return { kind: "abort" };
         }
@@ -1914,7 +2160,7 @@ export class ReplayController {
         // Bash-clean delivery: the model reaches for `Bash` when it cannot call a
         // scripted tool, and a genuine command output is trusted where a `deny`
         // reason is read as adversarial interception.
-        const action = this.deliverInstead(text, toolName);
+        const action = this.deliverInstead(text, toolName, state.host !== undefined);
         logDetail("replay.inject", { channel: action.kind, bytes: text.length });
         return action;
     }
@@ -1998,9 +2244,11 @@ export class ReplayController {
                             ? "a second call arrived while the pinned step was still running — the agent continues from here"
                             : h.stopReason === "budget" || h.stopReason === "cancelled"
                                 ? "the run was cut short before this step — the agent continues from here"
-                                : h.stopReason === "not_run" || h.stopReason === "uncertain"
-                                    ? "a step produced no result here — the agent continues from here"
-                                    : "a step broke — the agent continues from here",
+                                : h.stopReason === "host_rejected" || h.stopReason === "host_edited"
+                                    ? "the host stopped this step itself — no fault of the plan; the agent continues from here"
+                                    : h.stopReason === "not_run" || h.stopReason === "uncertain"
+                                        ? "a step produced no result here — the agent continues from here"
+                                        : "a step broke — the agent continues from here",
         });
     }
     /**
@@ -2017,6 +2265,9 @@ export class ReplayController {
     noteFor(state, h) {
         const plan = state.plan;
         const executed = h.ran ?? (h.ranThisStep ? h.position + 1 : h.position);
+        // A step its host stopped was dealt with there — refused, answered, or
+        // run with a person's arguments — so it is not among what is left to do.
+        const handled = h.ranThisStep === true || h.stopReason === "host_rejected" || h.stopReason === "host_edited";
         let params;
         try {
             params = plan?.parameters;
@@ -2047,7 +2298,7 @@ export class ReplayController {
             inFlight: h.inFlight,
             ranThisStep: h.ranThisStep,
             totalSteps: plan?.totalSteps ?? state.stepsPlanned,
-            remainingTools: plan ? plan.toolsFrom(h.ranThisStep ? h.position + 1 : h.position) : [],
+            remainingTools: plan ? plan.toolsFrom(handled ? h.position + 1 : h.position) : [],
             params,
             delivery: h.delivery,
         });
@@ -2068,6 +2319,12 @@ export class ReplayController {
     executeStep(state, opts = {}) {
         return async (step, input) => {
             const name = step.toolName ?? "";
+            // Another host's tools are in its own process, whatever they are
+            // named: one it calls `Bash` or `mcp__fleet__list` is not the runner's
+            // built-in or a proxy's upstream. Nothing of such a plan runs here.
+            if (state.host) {
+                throw new StepRunError(`${name || "this step"} runs in the host's own process`, "not_run");
+            }
             const mcp = parseQualifiedName(name);
             if (!mcp) {
                 // An allow-listed built-in runs *here*, against the session's own
@@ -2219,7 +2476,9 @@ export class ReplayController {
                 }
             }
         }
-        const sink = opts.adHoc ? undefined : sinkOfPlan(plan.allEntries().slice(0, plan.stepCount));
+        const sink = opts.adHoc
+            ? undefined
+            : sinkOfPlan(plan.allEntries().slice(0, plan.stepCount), state.host?.sinks);
         if (sink) {
             const bad = unsafeParameter(plan.derivedValues, plan.paramsSchema, sink);
             if (bad) {
@@ -2308,7 +2567,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 +2591,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 +2610,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 +2785,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).
  *