@basein/runner 0.3.21 → 0.3.22

package/dist/replay/plan.js

@@ -20,8 +20,7 @@
  *      step to know its reach, so it can choose between the proxy, a recorded
  *      output, and skipping.
  */
-import { evalParamMapLogic, evalParamsLogic, evalResponseParamsLogic, evalResultMapLogic, evalToolInputLogic, evalToolOutputLogic, evalWhenLogic, LogicTimeoutError, } from "./logic.js";
-import { flatEntriesOf, frameEdges } from "./flatten.js";
+import { evalParamsLogic, evalResponseParamsLogic, evalToolInputLogic, evalToolOutputLogic, evalWhenLogic, LogicTimeoutError, } from "./logic.js";
 import { assembleBundle, bundleInput, MAX_REPLAY_REASON, testWords } from "./bundle.js";
 import { redact, redactText } from "../record/redact.js";
 import { sinkOfPlan, unsafeParameter } from "./safety.js";
@@ -272,25 +271,6 @@ function renderArguments(toolName, input) {
     }
     return `arguments: {${parts.join(",")}}${shortened ? " (shortened)" : ""}`;
 }
-/**
- * The recorded values for the *settings* a mapping did not name (R-CALL-21).
- *
- * A target must always be supplied by the caller; a setting is what the segment
- * was recorded doing, and taking its sample here is what makes "may be omitted"
- * true rather than "runs with undefined".
- */
-function settingsOf(paramsObject, mapped) {
-    const out = {};
-    if (!paramsObject || typeof paramsObject !== "object")
-        return out;
-    for (const [name, p] of Object.entries(paramsObject)) {
-        if (name in mapped)
-            continue;
-        if (p?.kind === "setting" && p && "sampleValue" in p)
-            out[name] = p.sampleValue;
-    }
-    return out;
-}
 /**
  * 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.
@@ -303,14 +283,13 @@ function settingsOf(paramsObject, mapped) {
  * `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, output) {
+function reportingStage(onStep, step, stage, input, startedAt, fn, output) {
     try {
         return fn();
     }
     catch (err) {
         onStep?.({
-            step: entry.step,
-            entry,
+            step,
             input,
             output,
             // A value only the recording holds is no fault of the step's (issue 1212).
@@ -328,8 +307,8 @@ export class ScenarioReplayPlan {
     mode;
     intent;
     scenario;
-    /** The flat list this plan walks. One entry per step that will really run. */
-    entries;
+    /** The chain this plan walks. */
+    steps;
     paramsPromise;
     /** The values a step worked out in the recording ({@link FROM_STEP_MARK}). */
     fromStep;
@@ -352,219 +331,33 @@ export class ScenarioReplayPlan {
     readyPromise;
     /** Exclusive end of the planned steps. Equal to the chain length unless a step is parked. */
     stopAt;
-    /** This plan is a sub-task inside the agent's own task (segmented.md R-OUT-13). */
+    /** This plan is a sub-task inside the agent's own task: it was armed mid-task by intent. */
     subTask;
-    /**
-     * Where each called frame begins and ends, its callees' entries included:
-     * where it is entered, its test decided and it is left, and where a
-     * sub-task its test leaves out ends (AC5).
-     */
-    edges;
-    /** Each entry's flat position. */
-    positions = new Map();
-    /** Every frame of the flat list, by id. */
-    frames = new Map();
-    /** The plan's own walk: what its cursor has entered and decided (AC5). */
-    walk = { entered: new Set(), tested: new Set(), passed: new Set(), left: [] };
+    /** The plan's own walk: what its cursor has decided (AC5). */
+    walk = { passed: new Set(), left: [] };
     constructor(opts) {
         this.scenario = opts.scenario;
         this.scenarioId = opts.scenario.id;
         this.runId = opts.scenario.runId;
         this.intent = opts.scenario.intent ?? "";
-        this.entries = opts.entries ?? flatEntriesOf(opts.scenario);
+        this.steps = opts.scenario.steps ?? [];
         this.mode = opts.mode;
         this.paramsPromise = opts.params;
         this.fromStep = fromStepKeys(opts.scenario.paramsObject);
         this.fallbackTargets = opts.fallbackTargets ?? "null";
         this.respParams = { ...(opts.respParamsInit ?? {}) };
-        // The caller's own frame accumulates into the plan's `respParams`, so
-        // `accumulated`, `responseModel` and every depth-0 step see one object.
-        if (this.entries[0])
-            this.rootFrame().respParams = this.respParams;
         this.subTask = opts.subTask === true;
         const stop = opts.stopAt;
         this.stopAt =
-            typeof stop === "number" && stop >= 0 && stop < this.entries.length
+            typeof stop === "number" && stop >= 0 && stop < this.steps.length
                 ? stop
-                : this.entries.length;
+                : this.steps.length;
         // Judged over the steps this plan will run, as the gate that armed it was.
         const schema = opts.scenario.paramsObject;
         this.oneHalf =
             schema && typeof schema === "object"
-                ? testedOnlyTargets(Object.keys(schema).filter((k) => schema[k]?.kind !== "setting"), schema, this.entries.slice(0, this.stopAt), opts.scenario.paramsLogic)
+                ? testedOnlyTargets(Object.keys(schema).filter((k) => schema[k]?.kind !== "setting"), schema, this.steps.slice(0, this.stopAt), opts.scenario.paramsLogic)
                 : [];
-        this.edges = frameEdges(this.entries);
-        this.entries.forEach((entry, index) => {
-            this.positions.set(entry, index);
-            for (let f = entry.frame; f; f = f.parent)
-                this.frames.set(f.id, f);
-        });
-    }
-    frameById(id) {
-        return this.frames.get(id);
-    }
-    /** The called frames that begin at flat position `flatIndex`, outermost first. */
-    framesStartingAt(flatIndex) {
-        return this.edges.startsAt.get(flatIndex) ?? [];
-    }
-    /** The caller's own frame — the one at depth 0. */
-    rootFrame() {
-        let frame = this.entries[0].frame;
-        while (frame.parent)
-            frame = frame.parent;
-        return frame;
-    }
-    /** The parameters one entry's logic runs with (segmented.md R-CALL-29). */
-    paramsFor(entry) {
-        return entry.depth === 0 ? this.params : (entry.frame.parameters ?? {});
-    }
-    /** The accumulated values one entry's logic runs with. */
-    respFor(entry) {
-        return entry.depth === 0 ? this.respParams : entry.frame.respParams;
-    }
-    /**
-     * Entering a called frame: build the segment's parameters from the caller's
-     * state (R-CALL-29).
-     *
-     * The recipe is the dry run's, exactly (9.8 step 10): the mapping's output,
-     * plus the segment's own recorded sample for every *setting* the mapping left
-     * out. A mapping that omits a setting therefore cannot pass the service's
-     * check and then run `undefined` here.
-     */
-    enterFramesAt(flatIndex, walk) {
-        // Outermost first: a sub-task whose chain begins with a call begins where
-        // its callee does, and the callee's mapping reads the sub-task's
-        // parameters — built here, before it (AC5 review).
-        for (const frame of this.framesStartingAt(flatIndex))
-            this.enterFrame(frame, walk);
-    }
-    enterFrame(frame, walk) {
-        if (frame.depth === 0)
-            return;
-        // Once per walk: a step's test may need the frame's parameters before the
-        // step's input is computed (AC5), and a steer cursor computes one step's
-        // input again when a pin was declined.
-        if (walk.entered.has(frame.id))
-            return;
-        const resp = walk.resp;
-        const parent = frame.parent;
-        const parentParams = parent
-            ? parent.depth === 0
-                ? this.params
-                : (parent.parameters ?? {})
-            : this.params;
-        const parentResp = parent
-            ? resp
-                ? (resp.get(parent.id) ?? parent.respParams)
-                : parent.respParams
-            : this.respParams;
-        const mapped = frame.paramMapLogic
-            ? evalParamMapLogic(frame.paramMapLogic, parentParams, parent?.intent ?? this.intent, {
-                ...parentResp,
-            })
-            : {};
-        frame.parameters = { ...settingsOf(frame.paramsObject, mapped), ...mapped };
-        if (resp)
-            resp.set(frame.id, {});
-        else
-            frame.respParams = {};
-        walk.entered.add(frame.id);
-    }
-    /**
-     * Leave every called frame that ends at `flatIndex` and that `walk`
-     * entered, innermost first: a sub-task whose chain ends with a call is left
-     * after its callee has handed it its results.
-     */
-    leaveFramesAt(flatIndex, walk) {
-        for (const frame of this.edges.endsAt.get(flatIndex) ?? []) {
-            if (walk.entered.has(frame.id))
-                this.leaveFrame(frame, walk.resp);
-        }
-    }
-    /**
-     * After a skip that ends at flat position `last`: leave every entered
-     * sub-task that ends there — its results still go back to its caller. A
-     * result mapping that throws ends the walk: its verdict is filed on the
-     * call row, in the caller's chain, and the stop says the step at `last` was
-     * left out, not run (`result_map`). Rethrown instead when `rethrow`.
-     */
-    leaveAfterSkip(last, walk, onStep, rethrow) {
-        for (const frame of this.edges.endsAt.get(last) ?? []) {
-            if (!walk.entered.has(frame.id))
-                continue;
-            try {
-                this.leaveFrame(frame, walk.resp);
-            }
-            catch (err) {
-                if (rethrow)
-                    throw err;
-                const error = errText(err);
-                const { step, entry } = this.callRowOf(frame, this.entries[last]);
-                onStep?.({ step, entry, input: {}, outcome: "failed", stage: "tool_output_logic", error, ms: 0 });
-                return {
-                    kind: "step_failed",
-                    stepIndex: step.stepIndex,
-                    // At the step left out, which did not run: what ran before it did
-                    // its work, and what comes after it is left to do.
-                    flatIndex: last,
-                    stage: "tool_output_logic",
-                    error,
-                    reason: "result_map",
-                    subTask: frame.callIntent ?? null,
-                };
-            }
-        }
-        return undefined;
-    }
-    /**
-     * The call row that opened `frame`, as a step of its caller's chain: where
-     * a sub-task's test and its result mapping are filed (R-CALL-13).
-     */
-    callRowOf(frame, at) {
-        const step = frame.callStep ?? {
-            stepIndex: frame.callerStepIndex ?? at.stepIndex,
-            kind: "segment",
-            toolName: null,
-            toolInputLogic: null,
-            toolOutputLogic: null,
-            reasoning: null,
-        };
-        const owner = frame.parent ?? frame;
-        return {
-            step,
-            entry: {
-                scenarioId: owner.scenarioId,
-                runId: owner.runId,
-                stepFrom: owner.stepFrom,
-                stepTo: owner.stepTo,
-                stepIndex: step.stepIndex,
-                step,
-                frame: owner,
-                depth: owner.depth,
-                first: false,
-                last: false,
-            },
-        };
-    }
-    /**
-     * Leaving a called frame: hand what the segment emitted back to its caller
-     * (R-CALL-29). `out` is the frame's own accumulated `respParams`.
-     */
-    leaveFrame(frame, resp) {
-        if (frame.depth === 0)
-            return;
-        const parent = frame.parent;
-        if (!frame.resultMapLogic || !parent)
-            return;
-        const parentParams = parent.depth === 0 ? this.params : (parent.parameters ?? {});
-        const target = resp
-            ? (resp.get(parent.id) ?? parent.respParams)
-            : parent.depth === 0
-                ? this.respParams
-                : parent.respParams;
-        const own = resp ? (resp.get(frame.id) ?? frame.respParams) : frame.respParams;
-        const out = evalResultMapLogic(frame.resultMapLogic, { ...own }, parentParams, parent.intent, { ...target });
-        Object.assign(target, out);
     }
     /**
      * Await the derivation, then apply `paramsLogic` — once, however many callers
@@ -684,37 +477,17 @@ export class ScenarioReplayPlan {
     get stepCount() {
         return this.stopAt;
     }
-    /** Every step this plan could run, planned or not. */
+    /** Every step in the scenario's chain, planned or not. */
     get totalSteps() {
-        return this.entries.length;
+        return this.steps.length;
     }
     /** True when the plan ends in front of a known-bad step (fallbk.md D3). */
     stopsEarly() {
-        return this.stopAt < this.entries.length;
+        return this.stopAt < this.steps.length;
     }
     /** The known-bad step the plan stops in front of, if any. */
     stopStep() {
-        return this.stopsEarly() ? this.entries[this.stopAt]?.step : undefined;
-    }
-    /** The entry the plan stops in front of, with the frame that owns it. */
-    stopEntry() {
-        return this.stopsEarly() ? this.entries[this.stopAt] : undefined;
-    }
-    /**
-     * The flat position of the chain's decision stop (the service's
-     * segmentsbreakdown.md SB-18), or -1 when it has none. The steps from there
-     * on are the half the recording took, whatever stops the plan first.
-     */
-    decisionIndex() {
-        return this.entries.findIndex((e) => e.step.stop?.kind === "decision");
-    }
-    /** Every entry in order — for the report, and for the owning scenario ids. */
-    allEntries() {
-        return this.entries;
-    }
-    /** The entry awaiting execution, or undefined when the plan is done. */
-    currentEntry() {
-        return this.stepIndex < this.stopAt ? this.entries[this.stepIndex] : undefined;
+        return this.stopsEarly() ? this.steps[this.stopAt] : undefined;
     }
     /** The parameters in force. Empty until {@link ready} resolves. */
     get parameters() {
@@ -772,19 +545,19 @@ export class ScenarioReplayPlan {
     }
     /** The step awaiting execution, or undefined when the plan is done. */
     currentStep() {
-        return this.currentEntry()?.step;
+        return this.stepIndex < this.stopAt ? this.steps[this.stepIndex] : undefined;
     }
     /** The tool the current step expects, or undefined when done. */
     expectedTool() {
-        return this.currentStep()?.toolName ?? undefined;
+        return this.currentStep()?.toolName;
     }
     /** True once every planned step has been applied — the plan should be retired. */
     isDone() {
         return this.stepIndex >= this.stopAt;
     }
-    /** Every step in order — for the directive, and for coverage reporting. */
+    /** Every step in order — for the directive, the report and coverage reporting. */
     allSteps() {
-        return this.entries.map((e) => e.step);
+        return this.steps;
     }
     /**
      * True when `toolName` is one of this scenario's own tools.
@@ -796,7 +569,7 @@ export class ScenarioReplayPlan {
      * abandoned the sequence.
      */
     usesTool(toolName) {
-        return this.entries.some((e) => e.step.toolName === toolName);
+        return this.steps.some((s) => s.toolName === toolName);
     }
     /**
      * Compute the pinned input for the current step. Throws when there is no
@@ -804,14 +577,10 @@ export class ScenarioReplayPlan {
      * a throw as divergence.
      */
     toolInputForCurrentStep() {
-        const entry = this.entries[this.stepIndex];
-        if (!entry)
+        const step = this.steps[this.stepIndex];
+        if (!step)
             throw new Error("no current step to compute input for");
-        // Entering a called frame happens here, on its first step, because this is
-        // the first moment the caller's own accumulation is final (R-CALL-29) —
-        // unless the step's test needed the frame first (AC5).
-        this.enterFramesAt(this.stepIndex, this.walk);
-        return this.inputOf(entry, this.paramsFor(entry), entry.frame.intent, this.respFor(entry));
+        return this.inputOf(step, this.params, this.intent, this.respParams);
     }
     /**
      * A step's input, refused when it holds a value only the recording had: its
@@ -820,9 +589,9 @@ export class ScenarioReplayPlan {
      * is one that reads, or holds, a value the request did not give (review
      * item 11): {@link MissingValueError}.
      */
-    inputOf(entry, params, intent, resp, opts) {
+    inputOf(step, params, intent, resp, opts) {
         const w = this.watched(params);
-        const input = evalToolInputLogic(entry.step.toolInputLogic ?? "return {};", w.params, intent, resp, opts);
+        const input = evalToolInputLogic(step.toolInputLogic, w.params, intent, resp, opts);
         const read = [...w.read][0];
         if (read !== undefined)
             throw this.valueError(read);
@@ -836,41 +605,28 @@ export class ScenarioReplayPlan {
     // A step may run only when its test says so: a JavaScript body over the
     // parameters, the intent and what the earlier steps accumulated, decided
     // when the step comes due — never sooner, because the accumulation it reads
-    // is final only then. A call row's test decides its whole sub-task, in the
-    // caller's scope, before the sub-task's frame is entered. `skip` leaves the
-    // step out; `hand_over` stops the plan in front of it (the other half of an
-    // "if … otherwise", which the agent does); a test that throws or answers
-    // anything but true or false stops it too. Nothing is ever guessed.
+    // is final only then. `skip` leaves the step out; `hand_over` stops the plan
+    // in front of it (the other half of an "if … otherwise", which the agent
+    // does); a test that throws or answers anything but true or false stops it
+    // too. Nothing is ever guessed.
     /** Whether the plan's cursor rests in front of the step it is parked before. */
     atStop() {
         return this.stopsEarly() && this.stepIndex === this.stopAt;
     }
-    /**
-     * The test an entry runs under, in words, when it has one: its own, or that
-     * of a sub-task beginning at it — one whose chain begins with a call begins
-     * at its callee's first step.
-     */
-    onlyWhen(entry) {
-        const own = entry.step.when;
-        if (own)
-            return { text: testWords(own.text) };
-        const at = this.positions.get(entry);
-        const call = at === undefined ? undefined : this.framesStartingAt(at).find((f) => f.when)?.when;
-        if (call)
-            return { text: testWords(call.text) };
-        return undefined;
+    /** The test a step runs under, in words, when it has one. */
+    onlyWhen(step) {
+        const own = step.when;
+        return own ? { text: testWords(own.text) } : undefined;
     }
     /**
-     * The tool names of the steps from flat position `from` to the end (or to
-     * `until`, not included), each that runs only under a test marked so — for a
-     * hand-over note's "remaining planned steps", which must not read as steps
-     * this request needs.
+     * The tool names of the steps from position `from` to the end, each that
+     * runs only under a test marked so — for a hand-over note's "remaining
+     * planned steps", which must not read as steps this request needs.
      */
-    remainingFrom(from, until) {
-        return this.entries.slice(Math.max(0, from), until).map((e) => {
-            const name = e.step.toolName ?? "";
-            const t = this.onlyWhen(e);
-            return t ? `${name} (only when ${t.text ?? "a request needs it"})` : name;
+    remainingFrom(from) {
+        return this.steps.slice(Math.max(0, from)).map((s) => {
+            const t = this.onlyWhen(s);
+            return t ? `${s.toolName} (only when ${t.text ?? "a request needs it"})` : s.toolName;
         });
     }
     /** The steps the plan's own cursor has left out so far, in order (AC5). */
@@ -879,7 +635,7 @@ export class ScenarioReplayPlan {
     }
     /** Whether any planned step runs only under a test. */
     hasTests() {
-        return this.entries.slice(0, this.stopAt).some((e) => this.onlyWhen(e) !== undefined);
+        return this.steps.slice(0, this.stopAt).some((s) => this.onlyWhen(s) !== undefined);
     }
     /** One test, answered — or the reason it could not be. Never throws. */
     answer(test, params, intent, resp) {
@@ -898,180 +654,72 @@ export class ScenarioReplayPlan {
         }
     }
     /**
-     * What the tests decide at flat position `flatIndex` for `walk`. Enters the
-     * position's frame when its own test needs the frame's parameters, and
-     * nothing else changes: the caller moves its cursor.
+     * What the step's test decides at `position` for `walk`. Nothing changes:
+     * the caller moves its cursor.
      */
-    gate(flatIndex, walk) {
-        const entry = this.entries[flatIndex];
-        if (!entry)
+    gate(position, walk) {
+        const step = this.steps[position];
+        if (!step)
             return { kind: "run" };
-        const frame = entry.frame;
-        const resp = walk.resp;
-        // 1. The sub-tasks that begin here, outermost first — one whose chain
-        //    begins with a call begins where its callee's steps do, so nothing of
-        //    it runs before its test says it is needed. Each test is decided
-        //    once, in its caller's scope, before its frame is entered; a caller
-        //    that begins here too is entered first, for its parameters.
-        const starting = this.framesStartingAt(flatIndex);
-        for (let k = 0; k < starting.length; k += 1) {
-            const sub = starting[k];
-            if (!sub.when || walk.tested.has(sub.id))
-                continue;
-            try {
-                for (const outer of starting.slice(0, k))
-                    this.enterFrame(outer, walk);
-            }
-            catch (err) {
-                return {
-                    kind: "stop",
-                    stop: { kind: "step_failed", stepIndex: entry.stepIndex, flatIndex, stage: "tool_input_logic", error: errText(err) },
-                    info: { step: entry.step, entry, input: {}, outcome: "failed", stage: "tool_input_logic", error: errText(err), ms: 0 },
-                };
-            }
-            const decided = this.decideCall(sub, entry, flatIndex, walk);
-            if (decided)
-                return decided;
-            walk.tested.add(sub.id);
-        }
-        // 2. The step's own test, in its own frame's scope.
-        const test = entry.step.when;
-        if (!test || walk.passed.has(flatIndex))
+        const test = step.when;
+        if (!test || walk.passed.has(position))
             return { kind: "run" };
-        try {
-            // Its frame's parameters, which a test inside a sub-task reads.
-            this.enterFramesAt(flatIndex, walk);
-        }
-        catch (err) {
-            return {
-                kind: "stop",
-                stop: { kind: "step_failed", stepIndex: entry.stepIndex, flatIndex, stage: "tool_input_logic", error: errText(err) },
-                info: { step: entry.step, entry, input: {}, outcome: "failed", stage: "tool_input_logic", error: errText(err), ms: 0 },
-            };
-        }
-        const own = resp ? (resp.get(frame.id) ?? {}) : this.respFor(entry);
-        const said = this.answer(test, this.paramsFor(entry), frame.intent, own);
+        const said = this.answer(test, this.params, this.intent, walk.resp ?? this.respParams);
         const text = testWords(test.text);
         if ("error" in said) {
             return {
                 kind: "stop",
                 stop: {
                     kind: "step_failed",
-                    stepIndex: entry.stepIndex,
-                    flatIndex,
+                    stepIndex: step.stepIndex,
+                    position,
                     stage: "when_logic",
                     error: said.error,
                     reason: "test_failed",
                 },
-                info: { step: entry.step, entry, input: {}, outcome: "failed", stage: "when_logic", error: said.error, ms: 0 },
+                info: { step, input: {}, outcome: "failed", stage: "when_logic", error: said.error, ms: 0 },
             };
         }
         if (said.yes) {
-            walk.passed.add(flatIndex);
+            walk.passed.add(position);
             return { kind: "run" };
         }
         if (test.otherwise === "skip") {
             return {
                 kind: "skip",
-                until: flatIndex + 1,
-                info: { step: entry.step, entry, input: {}, outcome: "not_taken", ms: 0 },
-                entry,
-                text,
-                tools: [entry.step.toolName ?? ""],
-            };
-        }
-        return { kind: "stop", stop: { kind: "other_branch", stepIndex: entry.stepIndex, flatIndex, whenText: text } };
-    }
-    /**
-     * A sub-task's test, decided in its caller's scope at flat position
-     * `flatIndex`, where the sub-task begins. Undefined when it says yes.
-     */
-    decideCall(sub, entry, flatIndex, walk) {
-        const resp = walk.resp;
-        const parent = sub.parent;
-        const params = !parent || parent.depth === 0 ? this.params : (parent.parameters ?? {});
-        const parentResp = parent
-            ? resp
-                ? (resp.get(parent.id) ?? (parent.depth === 0 ? this.respParams : parent.respParams))
-                : parent.depth === 0
-                    ? this.respParams
-                    : parent.respParams
-            : this.respParams;
-        // The call row, as a step of its caller's chain: its verdict is filed
-        // there, under the call's own index.
-        const call = this.callRowOf(sub, entry);
-        const owner = parent ?? sub;
-        const said = this.answer(sub.when, params, owner.intent ?? this.intent, parentResp);
-        const text = testWords(sub.when.text);
-        if ("error" in said) {
-            return {
-                kind: "stop",
-                stop: {
-                    kind: "step_failed",
-                    stepIndex: call.step.stepIndex,
-                    flatIndex,
-                    stage: "when_logic",
-                    error: said.error,
-                    reason: "test_failed",
-                },
-                info: { step: call.step, entry: call.entry, input: {}, outcome: "failed", stage: "when_logic", error: said.error, ms: 0 },
-            };
-        }
-        if (said.yes)
-            return undefined;
-        if (sub.when.otherwise === "skip") {
-            const until = (this.edges.end.get(sub.id) ?? flatIndex) + 1;
-            return {
-                kind: "skip",
-                until,
-                info: { step: call.step, entry: call.entry, input: {}, outcome: "not_taken", ms: 0 },
-                entry: call.entry,
+                info: { step, input: {}, outcome: "not_taken", ms: 0 },
+                step,
                 text,
-                // Every tool of the sub-task: a call the model makes to any of them is
-                // one to a step left out.
-                tools: [...new Set(this.entries.slice(flatIndex, until).map((e) => e.step.toolName ?? ""))],
             };
         }
-        return {
-            kind: "stop",
-            stop: { kind: "other_branch", stepIndex: call.step.stepIndex, flatIndex, whenText: text },
-        };
+        return { kind: "stop", stop: { kind: "other_branch", stepIndex: step.stepIndex, position, whenText: text } };
     }
     /** What a skip the gate decided leaves out, as the notes name it. */
-    leftOutOf(g, flatIndex) {
+    leftOutOf(g, position) {
         return {
-            stepIndex: g.entry.stepIndex,
-            flatIndex,
-            until: g.until,
-            toolName: g.entry.step.toolName ?? g.entry.step.callIntent ?? "a sub-task",
-            tools: g.tools.filter((t) => t !== ""),
+            stepIndex: g.step.stepIndex,
+            position,
+            toolName: g.step.toolName,
             text: g.text,
         };
     }
     /**
-     * Tell a recorded-output source of the steps one skip left out — every step
-     * of a sub-task left out whole — so its queues pass over the outputs of the
-     * ones that were in the recording ({@link RecordedOutputFor}).
+     * Tell a recorded-output source of a step a test left out, so its queues
+     * pass over that step's output when it was in the recording
+     * ({@link RecordedOutputFor}).
      */
     passOver(l, recordedOutputFor) {
-        const tell = recordedOutputFor?.leftOut;
-        if (!tell)
-            return;
-        for (let i = l.flatIndex; i < l.until; i += 1) {
-            const entry = this.entries[i];
-            if (entry)
-                tell(entry);
-        }
+        const step = this.steps[l.position];
+        if (step)
+            recordedOutputFor?.leftOut?.(step);
     }
     /**
      * Move the plan's own cursor past every step this request does not need,
      * deciding each test as its step comes due (AC5). Stops at a step that will
      * run, at the end, or at a test that stops the plan — which it returns, with
      * the steps it left out. The observer is told each verdict as it is made.
-     * A sub-task whose results cannot go back after its last step was left out
-     * stops the plan too (`result_map`), its verdict filed on the call row.
      */
-    settleTests(onStep, opts = {}) {
+    settleTests(onStep) {
         const left = [];
         while (this.stepIndex < this.stopAt) {
             const g = this.gate(this.stepIndex, this.walk);
@@ -1086,10 +734,7 @@ export class ScenarioReplayPlan {
             const l = this.leftOutOf(g, this.stepIndex);
             left.push(l);
             this.walk.left.push(l);
-            const failed = this.leaveAfterSkip(g.until - 1, this.walk, onStep, opts.rethrow === true);
-            if (failed)
-                return { stop: failed, left };
-            this.stepIndex = g.until;
+            this.stepIndex += 1;
         }
         return { left };
     }
@@ -1102,20 +747,16 @@ export class ScenarioReplayPlan {
      * Throws when `toolOutputLogic` fails; the caller aborts to a normal turn.
      */
     applyOutput(realOutput) {
-        const entry = this.entries[this.stepIndex];
-        if (!entry)
+        const step = this.steps[this.stepIndex];
+        if (!step)
             return [];
         let derivedKeys = [];
-        if (entry.step.toolOutputLogic) {
-            const derived = evalToolOutputLogic(entry.step.toolOutputLogic, realOutput, this.paramsFor(entry), entry.frame.intent, this.respFor(entry));
+        if (step.toolOutputLogic) {
+            const derived = evalToolOutputLogic(step.toolOutputLogic, realOutput, this.params, this.intent, this.respParams);
             derivedKeys = Object.keys(derived);
-            // Mutated, not replaced: the frame's store is the object the plan and
-            // every later step of that frame already hold.
-            Object.assign(this.respFor(entry), derived);
+            // Mutated, not replaced: `accumulated` hands out this very object.
+            Object.assign(this.respParams, derived);
         }
-        // Leaving a called frame hands its results back to the caller before the
-        // caller's next step reads them (R-CALL-29).
-        this.leaveFramesAt(this.stepIndex, this.walk);
         this.stepIndex += 1;
         return derivedKeys;
     }
@@ -1145,12 +786,11 @@ export class ScenarioReplayPlan {
      * The arguments each planned step will run with, where they are known before
      * any step runs — for the steer directive (see {@link steeringDirective}).
      *
-     * Known means: the parameters are settled, the step is the caller's own
-     * (a called segment's parameters are only built when it is entered), and
-     * its input logic neither reads nor passes on anything an earlier step
-     * accumulates — or it is the step at the cursor, whose accumulation is
-     * already final. Everything else is undefined, and the directive leaves
-     * those steps' arguments to the system.
+     * Known means: the parameters are settled, and the step's input logic
+     * neither reads nor passes on anything an earlier step accumulates — or it
+     * is the step at the cursor, whose accumulation is already final.
+     * Everything else is undefined, and the directive leaves those steps'
+     * arguments to the system.
      *
      * A look-ahead only: every body runs on copies, under a short limit, and a
      * body that throws or runs long just leaves its step without arguments —
@@ -1175,9 +815,7 @@ export class ScenarioReplayPlan {
             const left = deadline - Date.now();
             if (left < MIN_PREVIEW_BODY_MS)
                 break;
-            const entry = planned[i];
-            if (entry.depth !== 0)
-                continue;
+            const step = planned[i];
             const params = copyOf(this.params);
             const accumulated = copyOf(this.respParams);
             if (!params || !accumulated)
@@ -1190,7 +828,7 @@ export class ScenarioReplayPlan {
                 });
             let input;
             try {
-                input = this.inputOf(entry, params, entry.frame.intent, resp, { timeoutMs: Math.min(bodyMs, left) });
+                input = this.inputOf(step, params, this.intent, resp, { timeoutMs: Math.min(bodyMs, left) });
             }
             catch (err) {
                 // A body that throws (often on an earlier result it does not have
@@ -1207,7 +845,7 @@ export class ScenarioReplayPlan {
             try {
                 if (readsEarlier || (resp !== accumulated && holds(input, resp)))
                     continue;
-                out[i] = renderArguments(entry.step.toolName ?? "", input);
+                out[i] = renderArguments(step.toolName, input);
             }
             catch {
                 // A value that throws when read (a getter the body returned): nothing
@@ -1239,8 +877,8 @@ export class ScenarioReplayPlan {
      * {@link MIN_PREVIEW_BODY_MS} there is no preview at all.
      */
     steeringDirective(directToolName = "mcp__bir__run_scenario", opts) {
-        // A sub-task plan (segmented.md R-OUT-13) never tells the agent to stop
-        // calling tools: the steps below are a part of the task it is already doing.
+        // A sub-task plan (armed mid-task) never tells the agent to stop calling
+        // tools: the steps below are a part of the task it is already doing.
         const subTask = opts?.subTask ?? this.subTask;
         // The intent is a paragraph the analyser wrote; it is context, not an
         // instruction, so it is clipped rather than dumped whole into the prompt.
@@ -1250,11 +888,11 @@ export class ScenarioReplayPlan {
         // paragraph: its first line, clipped. A chain long enough that even the
         // labels would run to kilobytes lists its tools alone — every tool always,
         // because in steer mode the list *is* the instruction.
-        const planned = this.entries.slice(0, this.stopAt);
+        const planned = this.steps.slice(0, this.stopAt);
         const args = this.previewArguments(planned, opts?.previewBudgetMs, opts?.previewBodyMs);
         // A step that runs only under a test says so on its line (AC5): which of
         // them this request needs is known only as the steps run.
-        const tests = planned.map((e) => this.onlyWhen(e));
+        const tests = planned.map((s) => this.onlyWhen(s));
         const anyTest = tests.some((t) => t !== undefined);
         const onlyWhen = (i) => {
             const t = tests[i];
@@ -1262,9 +900,9 @@ export class ScenarioReplayPlan {
                 return "";
             return ` (only when ${t.text ?? "this request needs it"})`;
         };
-        const listing = (withWhy, argsBefore) => planned.map((e, i) => {
-            const why = withWhy ? clipReasoning(e.step.reasoning) : "";
-            const head = `  ${i + 1}. ${e.step.toolName ?? ""}${onlyWhen(i)}${why ? ` — ${why}` : ""}`;
+        const listing = (withWhy, argsBefore) => planned.map((s, i) => {
+            const why = withWhy ? clipReasoning(s.reasoning) : "";
+            const head = `  ${i + 1}. ${s.toolName}${onlyWhen(i)}${why ? ` — ${why}` : ""}`;
             const shown = i < argsBefore ? args[i] : undefined;
             return shown ? `${head}\n     ${shown}` : head;
         });
@@ -1288,21 +926,10 @@ export class ScenarioReplayPlan {
             break;
         }
         const anyArgs = args.slice(0, argsShown).some((a) => a !== undefined);
-        // A plan whose chain holds a decision (the service's segmentsbreakdown.md
-        // SB-18) never shows its intent, even when it stops earlier for another
-        // reason: the intent names the recorded task, the half the recording took
-        // included, and which way applies is the agent's choice.
-        const atDecision = this.stopStep()?.stop?.kind === "decision";
-        const shownIntent = this.decisionIndex() >= 0 ? "" : intent;
         // A parked step (fallbk.md D3): the model is told up front that the plan is
         // partial, so the hand-over that follows is expected rather than a surprise.
         const tail = this.stopsEarly()
-            ? [
-                "",
-                atDecision
-                    ? "The system will then hand the task back to you at a decision."
-                    : "The system will then hand the rest of the task back to you.",
-            ]
+            ? ["", "The system will then hand the rest of the task back to you."]
             : [];
         if (this.mode === "direct") {
             // The sequence is listed even though the model does not call it itself:
@@ -1311,7 +938,7 @@ export class ScenarioReplayPlan {
             // 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${shownIntent ? ` (intent: ${shownIntent})` : ""}.`,
+                `for this request${intent ? ` (intent: ${intent})` : ""}.`,
                 "",
                 anyTest
                     ? 'It runs these tools, in order, and returns their results. A step marked "only when" runs only when this request needs it, and the results say which ones did not:'
@@ -1333,7 +960,7 @@ export class ScenarioReplayPlan {
             "recorded for this request. Call exactly these tools, in order, one at a time:",
             "",
             ...lines,
-            ...(shownIntent ? ["", `Context: ${shownIntent}`] : []),
+            ...(intent ? ["", `Context: ${intent}`] : []),
             ...(anyTest
                 ? [
                     "",
@@ -1381,26 +1008,13 @@ export class ScenarioReplayPlan {
      * waiting is a side effect nobody is told about.
      */
     async composeBundle(maxChars, execute, recordedOutputFor, onStep, opts = {}) {
-        // One copy per frame: composing must not corrupt the live plan's
-        // accumulation if the caller decides to keep steering afterwards.
-        const resp = new Map();
-        if (this.entries[0])
-            resp.set(this.rootFrame().id, { ...this.respParams });
-        // A sub-task the plan's cursor is inside goes on from what it has made so
-        // far: its copy, and the frames and tests the cursor already settled. A
-        // bundle that started such a frame afresh read `{}` for it — its steps'
-        // outputs were lost, and a test there read nothing (AC5 review).
-        for (const id of this.walk.entered) {
-            const frame = this.frameById(id);
-            if (frame)
-                resp.set(id, { ...frame.respParams });
-        }
-        // Its own walk, on those copies: what it enters and decides is not the
-        // live plan's either (AC5).
+        // A copy: composing must not corrupt the live plan's accumulation if the
+        // caller decides to keep steering afterwards.
+        const resp = { ...this.respParams };
+        // Its own walk, on that copy, from the tests the cursor already settled:
+        // what it decides is not the live plan's either (AC5).
         const walk = {
             resp,
-            entered: new Set(this.walk.entered),
-            tested: new Set(this.walk.tested),
             passed: new Set(this.walk.passed),
             left: [],
         };
@@ -1412,13 +1026,12 @@ export class ScenarioReplayPlan {
         let notTaken = 0;
         let stopped;
         const stopOnFailure = opts.stopOnFailure === true;
-        let flatIndex = this.stepIndex;
-        for (; flatIndex < this.stopAt; flatIndex += 1) {
-            const entry = this.entries[flatIndex];
-            const step = entry.step;
+        let position = this.stepIndex;
+        for (; position < this.stopAt; position += 1) {
+            const step = this.steps[position];
             // A step this request does not need is left out, and said so in the
             // bundle; a test that says "the other half" stops the bundle here (AC5).
-            const g = this.gate(flatIndex, walk);
+            const g = this.gate(position, walk);
             if (g.kind === "stop") {
                 if (g.info)
                     onStep?.(g.info);
@@ -1428,26 +1041,18 @@ export class ScenarioReplayPlan {
             if (g.kind === "skip") {
                 onStep?.(g.info);
                 notTaken += 1;
-                const l = this.leftOutOf(g, flatIndex);
+                const l = this.leftOutOf(g, position);
                 walk.left.push(l);
                 this.passOver(l, recordedOutputFor);
                 entries.push({
-                    toolName: g.entry.step.toolName ?? g.entry.step.callIntent ?? "a sub-task",
+                    toolName: step.toolName,
                     input: "",
                     response: "",
                     notNeeded: { text: g.text },
                 });
-                // The sub-tasks that end with the step left out still hand back what
-                // they made; one that cannot stops the bundle (`result_map`).
-                const failed = this.leaveAfterSkip(g.until - 1, walk, onStep, !stopOnFailure);
-                if (failed) {
-                    stopped = failed;
-                    break;
-                }
-                flatIndex = g.until - 1;
                 continue;
             }
-            const before = this.stopBefore(entry, flatIndex, opts.signal, opts.deadline);
+            const before = this.stopBefore(step, position, opts.signal, opts.deadline);
             if (before) {
                 stopped = before;
                 break;
@@ -1455,11 +1060,7 @@ export class ScenarioReplayPlan {
             const startedAt = Date.now();
             let computed;
             try {
-                computed = reportingStage(onStep, entry, "tool_input_logic", {}, startedAt, () => {
-                    this.enterFramesAt(flatIndex, walk);
-                    const respParams = resp.get(entry.frame.id) ?? {};
-                    return this.inputOf(entry, this.paramsFor(entry), entry.frame.intent, respParams);
-                });
+                computed = reportingStage(onStep, step, "tool_input_logic", {}, startedAt, () => this.inputOf(step, this.params, this.intent, resp));
             }
             catch (err) {
                 if (!stopOnFailure)
@@ -1467,14 +1068,14 @@ export class ScenarioReplayPlan {
                 stopped = {
                     kind: "step_failed",
                     stepIndex: step.stepIndex,
-                    flatIndex,
+                    position,
                     stage: "tool_input_logic",
                     error: errText(err),
                     ...(err instanceof RecordedValueError ? { reason: "not_run" } : {}),
                 };
                 break;
             }
-            const call = await this.callStep(entry, flatIndex, computed, startedAt, execute, recordedOutputFor, onStep, opts, opts.deadline);
+            const call = await this.callStep(step, position, computed, startedAt, execute, recordedOutputFor, onStep, opts, opts.deadline);
             if (call.stopped) {
                 skipped += 1;
                 stopped = call.stopped;
@@ -1493,7 +1094,6 @@ export class ScenarioReplayPlan {
                     errored += 1;
                     onStep?.({
                         step,
-                        entry,
                         input: computed,
                         output: response,
                         outcome: "failed",
@@ -1502,11 +1102,11 @@ export class ScenarioReplayPlan {
                         toolMissing: isMissingToolError(toolError) || undefined,
                         ms: Date.now() - startedAt,
                     });
-                    entries.push({ toolName: step.toolName ?? "", input: bundleInput(computed), response, recorded });
+                    entries.push({ toolName: step.toolName, input: bundleInput(computed), response, recorded });
                     stopped = {
                         kind: "step_failed",
                         stepIndex: step.stepIndex,
-                        flatIndex,
+                        position,
                         stage: "tool_call",
                         error: toolError,
                     };
@@ -1517,24 +1117,23 @@ export class ScenarioReplayPlan {
             // too: `toolOutputLogic` was authored against exactly this shape.
             let derivedKeys = [];
             try {
-                reportingStage(onStep, entry, "tool_output_logic", computed, startedAt, () => {
+                reportingStage(onStep, step, "tool_output_logic", computed, startedAt, () => {
                     if (step.toolOutputLogic) {
-                        const derived = evalToolOutputLogic(step.toolOutputLogic, response, this.paramsFor(entry), entry.frame.intent, resp.get(entry.frame.id) ?? {});
+                        const derived = evalToolOutputLogic(step.toolOutputLogic, response, this.params, this.intent, resp);
                         derivedKeys = Object.keys(derived);
-                        Object.assign(resp.get(entry.frame.id) ?? {}, derived);
+                        Object.assign(resp, derived);
                     }
-                    this.leaveFramesAt(flatIndex, walk);
                 }, response);
             }
             catch (err) {
                 if (!stopOnFailure)
                     throw err;
                 // The tool ran; its output is real and belongs in front of the model.
-                entries.push({ toolName: step.toolName ?? "", input: bundleInput(computed), response, recorded });
+                entries.push({ toolName: step.toolName, input: bundleInput(computed), response, recorded });
                 stopped = {
                     kind: "step_failed",
                     stepIndex: step.stepIndex,
-                    flatIndex,
+                    position,
                     stage: "tool_output_logic",
                     error: errText(err),
                 };
@@ -1549,7 +1148,6 @@ export class ScenarioReplayPlan {
                     errored += 1;
                 onStep?.({
                     step,
-                    entry,
                     input: computed,
                     output: response,
                     outcome: error ? "failed" : "executed",
@@ -1560,14 +1158,13 @@ export class ScenarioReplayPlan {
                     ms: Date.now() - startedAt,
                 });
             }
-            entries.push({ toolName: step.toolName ?? "", input: bundleInput(computed), response, recorded });
+            entries.push({ toolName: step.toolName, input: bundleInput(computed), response, recorded });
         }
         return {
             text: assembleBundle(entries, maxChars, {
                 // A bundle that stops short of the task — in front of a parked step, or
-                // at a step that broke — must never say "the work is done". One that
-                // left out a sub-task reaching past the parked step did not stop short.
-                handover: (opts.handover === true && flatIndex <= this.stopAt) || stopped !== undefined,
+                // at a step that broke — must never say "the work is done".
+                handover: opts.handover === true || stopped !== undefined,
                 subTask: this.subTask,
                 reportTool: opts.reportTool,
             }),
@@ -1578,7 +1175,7 @@ export class ScenarioReplayPlan {
             notTaken,
             left: walk.left,
             stopped,
-            endedAt: flatIndex,
+            endedAt: position,
         };
     }
     /**
@@ -1614,10 +1211,7 @@ export class ScenarioReplayPlan {
         while (!this.isDone()) {
             // The steps this request does not need are left out, and said so in the
             // bundle; a test that says "the other half" stops the run here (AC5).
-            // A sub-task whose results cannot go back after its last step was left
-            // out stops the run (`result_map`) — or, without `stopOnFailure`, its
-            // throw propagates, as any logic throw does.
-            const settled = this.settleTests(onStep, { rethrow: !stopOnFailure });
+            const settled = this.settleTests(onStep);
             left.push(...settled.left);
             for (const l of settled.left) {
                 this.passOver(l, recordedOutputFor);
@@ -1630,12 +1224,11 @@ export class ScenarioReplayPlan {
             }
             if (this.isDone())
                 break;
-            const entry = this.entries[this.stepIndex];
-            const step = entry.step;
-            // Where this step sits in the flat list — what a stop reports. Taken now,
+            const step = this.steps[this.stepIndex];
+            // Where this step sits in the chain — what a stop reports. Taken now,
             // because the cursor has moved on by the time some stops are written.
-            const flatIndex = this.stepIndex;
-            const before = this.stopBefore(entry, flatIndex, opts.signal, deadline);
+            const position = this.stepIndex;
+            const before = this.stopBefore(step, position, opts.signal, deadline);
             if (before) {
                 stopped = before;
                 if (before.reason === "budget")
@@ -1647,7 +1240,7 @@ export class ScenarioReplayPlan {
             const startedAt = Date.now();
             let computed;
             try {
-                computed = reportingStage(onStep, entry, "tool_input_logic", {}, startedAt, () => this.toolInputForCurrentStep());
+                computed = reportingStage(onStep, step, "tool_input_logic", {}, startedAt, () => this.toolInputForCurrentStep());
             }
             catch (err) {
                 if (!stopOnFailure)
@@ -1655,14 +1248,14 @@ export class ScenarioReplayPlan {
                 stopped = {
                     kind: "step_failed",
                     stepIndex: step.stepIndex,
-                    flatIndex,
+                    position,
                     stage: "tool_input_logic",
                     error: errText(err),
                     ...(err instanceof RecordedValueError ? { reason: "not_run" } : {}),
                 };
                 break;
             }
-            const call = await this.callStep(entry, flatIndex, computed, startedAt, execute, recordedOutputFor, onStep, opts, deadline);
+            const call = await this.callStep(step, position, computed, startedAt, execute, recordedOutputFor, onStep, opts, deadline);
             if (call.stopped) {
                 skipped += 1;
                 stopped = call.stopped;
@@ -1681,7 +1274,6 @@ export class ScenarioReplayPlan {
                     errored += 1;
                     onStep?.({
                         step,
-                        entry,
                         input: computed,
                         output: response,
                         outcome: "failed",
@@ -1690,12 +1282,12 @@ export class ScenarioReplayPlan {
                         toolMissing: isMissingToolError(toolError) || undefined,
                         ms: Date.now() - startedAt,
                     });
-                    entries.push({ toolName: step.toolName ?? "", input: bundleInput(computed), response, recorded });
+                    entries.push({ toolName: step.toolName, input: bundleInput(computed), response, recorded });
                     this.stepIndex += 1;
                     stopped = {
                         kind: "step_failed",
                         stepIndex: step.stepIndex,
-                        flatIndex,
+                        position,
                         stage: "tool_call",
                         error: toolError,
                     };
@@ -1704,17 +1296,17 @@ export class ScenarioReplayPlan {
             }
             let derivedKeys;
             try {
-                derivedKeys = reportingStage(onStep, entry, "tool_output_logic", computed, startedAt, () => this.applyOutput(response), response);
+                derivedKeys = reportingStage(onStep, step, "tool_output_logic", computed, startedAt, () => this.applyOutput(response), response);
             }
             catch (err) {
                 if (!stopOnFailure)
                     throw err;
                 // The tool ran; its output is real and belongs in front of the model.
-                entries.push({ toolName: step.toolName ?? "", input: bundleInput(computed), response, recorded });
+                entries.push({ toolName: step.toolName, input: bundleInput(computed), response, recorded });
                 stopped = {
                     kind: "step_failed",
                     stepIndex: step.stepIndex,
-                    flatIndex,
+                    position,
                     stage: "tool_output_logic",
                     error: errText(err),
                 };
@@ -1729,7 +1321,6 @@ export class ScenarioReplayPlan {
                     errored += 1;
                 onStep?.({
                     step,
-                    entry,
                     input: computed,
                     output: response,
                     outcome: error ? "failed" : "executed",
@@ -1740,17 +1331,16 @@ export class ScenarioReplayPlan {
                     ms: Date.now() - startedAt,
                 });
             }
-            entries.push({ toolName: step.toolName ?? "", input: bundleInput(computed), response, recorded });
+            entries.push({ toolName: step.toolName, input: bundleInput(computed), response, recorded });
         }
-        // Every planned step ran and the plan ends in front of a parked one — not
-        // when a test left out a sub-task that reaches past it (AC5).
+        // Every planned step ran and the plan ends in front of a parked one.
         if (!stopped && this.atStop()) {
             // `known_bad_step` here means "in front of the plan's end": the
             // controller reads the served reason and names the kind (D8).
             stopped = {
                 kind: "known_bad_step",
-                stepIndex: this.entries[this.stopAt].stepIndex,
-                flatIndex: this.stopAt,
+                stepIndex: this.steps[this.stopAt].stepIndex,
+                position: this.stopAt,
             };
         }
         return {
@@ -1775,12 +1365,12 @@ export class ScenarioReplayPlan {
      * A reason not to *start* the next step: the caller is gone, or the time is
      * up. Undefined means go ahead.
      */
-    stopBefore(entry, flatIndex, signal, deadline) {
+    stopBefore(step, position, signal, deadline) {
         if (signal?.aborted) {
-            return { kind: "step_failed", stepIndex: entry.step.stepIndex, flatIndex, reason: "cancelled" };
+            return { kind: "step_failed", stepIndex: step.stepIndex, position, reason: "cancelled" };
         }
         if (deadline !== undefined && Date.now() >= deadline) {
-            return { kind: "step_failed", stepIndex: entry.step.stepIndex, flatIndex, reason: "budget" };
+            return { kind: "step_failed", stepIndex: step.stepIndex, position, reason: "budget" };
         }
         return undefined;
     }
@@ -1789,10 +1379,9 @@ export class ScenarioReplayPlan {
      * that may stand in for it (only under `recordedFallback`, only for a step
      * that could not be sent), or with the stop a missing result means.
      */
-    async callStep(entry, flatIndex, computed, startedAt, execute, recordedOutputFor, onStep, opts, 
+    async callStep(step, position, computed, startedAt, execute, recordedOutputFor, onStep, opts, 
     /** The driver's deadline: a recorded-output lookup is not waited on past it. */
     deadline) {
-        const step = entry.step;
         try {
             return { response: await execute(step, computed), recorded: false };
         }
@@ -1802,11 +1391,10 @@ export class ScenarioReplayPlan {
             const standIn = opts.recordedFallback === true && reason === "not_run"
                 ? ((typeof step.recordedOutput === "string" && step.recordedOutput.length > 0
                     ? step.recordedOutput
-                    : undefined) ?? (await this.recordedWithin(recordedOutputFor, entry, deadline)))
+                    : undefined) ?? (await this.recordedWithin(recordedOutputFor, step, deadline)))
                 : undefined;
             onStep?.({
                 step,
-                entry,
                 input: computed,
                 // The stand-in is what the step's output logic runs on from here.
                 output: standIn,
@@ -1821,7 +1409,7 @@ export class ScenarioReplayPlan {
                 stopped: {
                     kind: "step_failed",
                     stepIndex: step.stepIndex,
-                    flatIndex,
+                    position,
                     stage: "tool_call",
                     error,
                     reason,
@@ -1839,14 +1427,14 @@ export class ScenarioReplayPlan {
      * breaker, and a lookup that has not answered in time is no recorded output.
      * A sliver of time left is not worth a request, nor a verdict on the service.
      */
-    async recordedWithin(recordedOutputFor, entry, deadline) {
+    async recordedWithin(recordedOutputFor, step, deadline) {
         if (!recordedOutputFor)
             return undefined;
         if (deadline !== undefined && deadline - Date.now() < MIN_RECORDED_LOOKUP_MS)
             return undefined;
         let pending;
         try {
-            pending = recordedOutputFor(entry);
+            pending = recordedOutputFor(step);
         }
         catch {
             return undefined;