@basein/runner 0.3.15 → 0.3.17

package/dist/replay/plan.js

@@ -20,9 +20,9 @@
  *      step to know its reach, so it can choose between the proxy, a recorded
  *      output, and skipping.
  */
-import { evalParamMapLogic, evalParamsLogic, evalResponseParamsLogic, evalResultMapLogic, evalToolInputLogic, evalToolOutputLogic, LogicTimeoutError, } from "./logic.js";
-import { flatEntriesOf } from "./flatten.js";
-import { assembleBundle, bundleInput, MAX_REPLAY_REASON } from "./bundle.js";
+import { evalParamMapLogic, evalParamsLogic, evalResponseParamsLogic, evalResultMapLogic, evalToolInputLogic, evalToolOutputLogic, evalWhenLogic, LogicTimeoutError, } from "./logic.js";
+import { flatEntriesOf, frameEdges } from "./flatten.js";
+import { assembleBundle, bundleInput, MAX_REPLAY_REASON, testWords } from "./bundle.js";
 import { redact, redactText } from "../record/redact.js";
 import { sinkOfPlan, unsafeParameter } from "./safety.js";
 import { errText } from "../util/log.js";
@@ -259,6 +259,18 @@ export class ScenarioReplayPlan {
     stopAt;
     /** This plan is a sub-task inside the agent's own task (segmented.md R-OUT-13). */
     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: [] };
     constructor(opts) {
         this.scenario = opts.scenario;
         this.scenarioId = opts.scenario.id;
@@ -279,6 +291,19 @@ export class ScenarioReplayPlan {
             typeof stop === "number" && stop >= 0 && stop < this.entries.length
                 ? stop
                 : this.entries.length;
+        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() {
@@ -304,10 +329,22 @@ export class ScenarioReplayPlan {
      * out. A mapping that omits a setting therefore cannot pass the service's
      * check and then run `undefined` here.
      */
-    enterFrame(entry, resp) {
-        if (!entry.first || entry.depth === 0)
+    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;
-        const frame = entry.frame;
+        // 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
@@ -329,15 +366,91 @@ export class ScenarioReplayPlan {
             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(entry, resp) {
-        if (!entry.last || entry.depth === 0)
+    leaveFrame(frame, resp) {
+        if (frame.depth === 0)
             return;
-        const frame = entry.frame;
         const parent = frame.parent;
         if (!frame.resultMapLogic || !parent)
             return;
@@ -448,10 +561,6 @@ export class ScenarioReplayPlan {
     stopEntry() {
         return this.stopsEarly() ? this.entries[this.stopAt] : undefined;
     }
-    /** Tool names from position `from` to the end of the flat chain. */
-    toolsFrom(from) {
-        return this.entries.slice(Math.max(0, from)).map((e) => e.step.toolName ?? "");
-    }
     /** Every entry in order — for the report, and for the owning scenario ids. */
     allEntries() {
         return this.entries;
@@ -514,10 +623,265 @@ export class ScenarioReplayPlan {
         if (!entry)
             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).
-        this.enterFrame(entry);
+        // 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 evalToolInputLogic(entry.step.toolInputLogic ?? "return {};", this.paramsFor(entry), entry.frame.intent, this.respFor(entry));
     }
+    // ── tests (the service's autocorrect.md AC5) ──────────────────────────────
+    //
+    // 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.
+    /** 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 tool names of the steps from flat 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) {
+        return this.entries.slice(Math.max(0, from)).map((e) => {
+            const name = e.step.toolName ?? "";
+            const t = this.onlyWhen(e);
+            return t ? `${name} (only when ${t.text ?? "a request needs it"})` : name;
+        });
+    }
+    /** The steps the plan's own cursor has left out so far, in order (AC5). */
+    leftOut() {
+        return this.walk.left;
+    }
+    /** Whether any planned step runs only under a test. */
+    hasTests() {
+        return this.entries.slice(0, this.stopAt).some((e) => this.onlyWhen(e) !== undefined);
+    }
+    /** One test, answered — or the reason it could not be. Never throws. */
+    answer(test, params, intent, resp) {
+        try {
+            return { yes: evalWhenLogic(test.logic, params, intent, resp) };
+        }
+        catch (err) {
+            return { error: errText(err) };
+        }
+    }
+    /**
+     * 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.
+     */
+    gate(flatIndex, walk) {
+        const entry = this.entries[flatIndex];
+        if (!entry)
+            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))
+            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 text = testWords(test.text);
+        if ("error" in said) {
+            return {
+                kind: "stop",
+                stop: {
+                    kind: "step_failed",
+                    stepIndex: entry.stepIndex,
+                    flatIndex,
+                    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 },
+            };
+        }
+        if (said.yes) {
+            walk.passed.add(flatIndex);
+            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,
+                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 },
+        };
+    }
+    /** What a skip the gate decided leaves out, as the notes name it. */
+    leftOutOf(g, flatIndex) {
+        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 !== ""),
+            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}).
+     */
+    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);
+        }
+    }
+    /**
+     * 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 = {}) {
+        const left = [];
+        while (this.stepIndex < this.stopAt) {
+            const g = this.gate(this.stepIndex, this.walk);
+            if (g.kind === "run")
+                break;
+            if (g.kind === "stop") {
+                if (g.info)
+                    onStep?.(g.info);
+                return { stop: g.stop, left };
+            }
+            onStep?.(g.info);
+            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;
+        }
+        return { left };
+    }
     /**
      * Thread a real tool output into `respParams` and advance.
      *
@@ -540,7 +904,7 @@ export class ScenarioReplayPlan {
         }
         // Leaving a called frame hands its results back to the caller before the
         // caller's next step reads them (R-CALL-29).
-        this.leaveFrame(entry);
+        this.leaveFramesAt(this.stepIndex, this.walk);
         this.stepIndex += 1;
         return derivedKeys;
     }
@@ -661,9 +1025,19 @@ export class ScenarioReplayPlan {
         // because in steer mode the list *is* the instruction.
         const planned = this.entries.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 anyTest = tests.some((t) => t !== undefined);
+        const onlyWhen = (i) => {
+            const t = tests[i];
+            if (!t)
+                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 ?? ""}${why ? ` — ${why}` : ""}`;
+            const head = `  ${i + 1}. ${e.step.toolName ?? ""}${onlyWhen(i)}${why ? ` — ${why}` : ""}`;
             const shown = i < argsBefore ? args[i] : undefined;
             return shown ? `${head}\n     ${shown}` : head;
         });
@@ -701,7 +1075,9 @@ export class ScenarioReplayPlan {
                 "[BaseInstRunner calculated replay] A known-good tool sequence was recorded",
                 `for this request${intent ? ` (intent: ${intent})` : ""}.`,
                 "",
-                "It runs these tools, in order, and returns their results:",
+                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:'
+                    : "It runs these tools, in order, and returns their results:",
                 "",
                 ...lines,
                 "",
@@ -720,6 +1096,14 @@ export class ScenarioReplayPlan {
             "",
             ...lines,
             ...(intent ? ["", `Context: ${intent}`] : []),
+            ...(anyTest
+                ? [
+                    "",
+                    'A step marked "only when" may not be needed for this request. After each call the',
+                    "system says when the next one is not needed: leave that one out and go on with the",
+                    "one it names. It supplies arguments only for the steps this request needs.",
+                ]
+                : []),
             "",
             ...(anyArgs
                 ? [
@@ -764,16 +1148,67 @@ export class ScenarioReplayPlan {
         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).
+        const walk = {
+            resp,
+            entered: new Set(this.walk.entered),
+            tested: new Set(this.walk.tested),
+            passed: new Set(this.walk.passed),
+            left: [],
+        };
         const entries = [];
         let executed = 0;
         let recordedCount = 0;
         let skipped = 0;
         let errored = 0;
+        let notTaken = 0;
         let stopped;
         const stopOnFailure = opts.stopOnFailure === true;
-        for (let flatIndex = this.stepIndex; flatIndex < this.stopAt; flatIndex += 1) {
+        let flatIndex = this.stepIndex;
+        for (; flatIndex < this.stopAt; flatIndex += 1) {
             const entry = this.entries[flatIndex];
             const step = entry.step;
+            // 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);
+            if (g.kind === "stop") {
+                if (g.info)
+                    onStep?.(g.info);
+                stopped = g.stop;
+                break;
+            }
+            if (g.kind === "skip") {
+                onStep?.(g.info);
+                notTaken += 1;
+                const l = this.leftOutOf(g, flatIndex);
+                walk.left.push(l);
+                this.passOver(l, recordedOutputFor);
+                entries.push({
+                    toolName: g.entry.step.toolName ?? g.entry.step.callIntent ?? "a sub-task",
+                    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);
             if (before) {
                 stopped = before;
@@ -783,7 +1218,7 @@ export class ScenarioReplayPlan {
             let computed;
             try {
                 computed = reportingStage(onStep, entry, "tool_input_logic", {}, startedAt, () => {
-                    this.enterFrame(entry, resp);
+                    this.enterFramesAt(flatIndex, walk);
                     const respParams = resp.get(entry.frame.id) ?? {};
                     return evalToolInputLogic(step.toolInputLogic ?? "return {};", this.paramsFor(entry), entry.frame.intent, respParams);
                 });
@@ -849,7 +1284,7 @@ export class ScenarioReplayPlan {
                         derivedKeys = Object.keys(derived);
                         Object.assign(resp.get(entry.frame.id) ?? {}, derived);
                     }
-                    this.leaveFrame(entry, resp);
+                    this.leaveFramesAt(flatIndex, walk);
                 }, response);
             }
             catch (err) {
@@ -891,15 +1326,19 @@ export class ScenarioReplayPlan {
         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".
-                handover: opts.handover === true || stopped !== undefined,
+                // 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,
                 subTask: this.subTask,
             }),
             executed,
             recorded: recordedCount,
             skipped,
             errored,
+            notTaken,
+            left: walk.left,
             stopped,
+            endedAt: flatIndex,
         };
     }
     /**
@@ -926,11 +1365,31 @@ export class ScenarioReplayPlan {
         let recordedCount = 0;
         let skipped = 0;
         let errored = 0;
+        let notTaken = 0;
+        const left = [];
         let partial = false;
         let aborted = false;
         let stopped;
         const stopOnFailure = opts.stopOnFailure === true;
         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 });
+            left.push(...settled.left);
+            for (const l of settled.left) {
+                this.passOver(l, recordedOutputFor);
+                entries.push({ toolName: l.toolName, input: "", response: "", notNeeded: { text: l.text } });
+            }
+            notTaken += settled.left.length;
+            if (settled.stop) {
+                stopped = settled.stop;
+                break;
+            }
+            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,
@@ -1042,8 +1501,9 @@ export class ScenarioReplayPlan {
             }
             entries.push({ toolName: step.toolName ?? "", input: bundleInput(computed), response, recorded });
         }
-        // Every planned step ran and the plan ends in front of a parked one.
-        if (!stopped && this.stopsEarly() && this.isDone()) {
+        // 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).
+        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 = {
@@ -1061,9 +1521,12 @@ export class ScenarioReplayPlan {
             recorded: recordedCount,
             skipped,
             errored,
+            notTaken,
+            left,
             partial,
             stopped,
             aborted: aborted || undefined,
+            endedAt: this.stepIndex,
         };
     }
     /**