@basein/runner 0.3.14 → 0.3.16

package/dist/replay/flatten.d.ts

@@ -22,7 +22,7 @@
  * the service did that long before this payload was built. It only lays out
  * what it was served, and stops in front of anything it cannot run.
  */
-import type { SerializedScenario, SerializedScenarioStep, CallUnusable } from "./types.js";
+import type { SerializedScenario, SerializedScenarioStep, CallUnusable, StepTest } from "./types.js";
 import type { ParamsSchema } from "./types.js";
 /** The scope one stretch of steps runs in. Frame 0 is the caller's own. */
 export interface Frame {
@@ -47,6 +47,15 @@ export interface Frame {
     chainRevision?: number;
     /** The segment's own parameters, for the settings a mapping omits (R-CALL-21). */
     paramsObject?: ParamsSchema | null;
+    /**
+     * The call row that opened this frame, when it carries a test (the
+     * service's autocorrect.md AC5): the whole sub-task runs only when the test
+     * says so. It is evaluated in the *caller's* frame, before this one is
+     * entered.
+     */
+    when?: StepTest;
+    /** That call row itself, for the verdict a sub-task left out gets. */
+    callStep?: SerializedScenarioStep;
     /** Filled by the plan when the frame is entered. */
     parameters?: Record<string, unknown>;
     respParams: Record<string, unknown>;
@@ -63,7 +72,11 @@ export interface FlatEntry {
     step: SerializedScenarioStep;
     frame: Frame;
     depth: number;
-    /** First / last entry of its frame — where the two mapping bodies run. */
+    /**
+     * First / last of its frame's *own* entries. Where a frame is entered and
+     * left is {@link frameEdges}: a frame whose chain begins or ends with a
+     * call begins or ends with that call's steps.
+     */
     first: boolean;
     last: boolean;
 }
@@ -113,9 +126,32 @@ export declare function flattenChain(scenario: SerializedScenario, opts?: {
  * Used for the known-bad-step gate, which judges entries: a parked step in the
  * middle of a sub-task stops the plan in front of the *sub-task*, not in front
  * of the step, because stopping inside it would skip the body that hands its
- * results back.
+ * results back. The sub-task starts at its first entry *or its callee's*: one
+ * whose chain begins with a call starts where that call's steps do.
  */
 export declare function clampToFrameStart(entries: readonly FlatEntry[], index: number): number;
+/**
+ * Where each called frame begins and ends in the flat list, its callees'
+ * entries included — not where its *own* entries do (`first` / `last`).
+ *
+ * The two differ when a sub-task's chain begins or ends with a call: for
+ * F = [call G, f1] the flat order is g0, g1, f1, and F begins at g0. Entering
+ * F there, before G, is what gives G's mapping (and G's test) F's parameters;
+ * deciding F's own test there is what keeps G from running when F is not
+ * needed (the service's autocorrect.md AC5). Leaving F after the last of
+ * them is what hands G's results on through F.
+ */
+export interface FrameEdges {
+    /** Per frame id, the flat position of its first entry, its callees' included. */
+    start: Map<number, number>;
+    /** Per frame id, the flat position of its last entry, its callees' included. */
+    end: Map<number, number>;
+    /** Per flat position, the called frames that begin there, outermost first. */
+    startsAt: Map<number, Frame[]>;
+    /** Per flat position, the called frames that end there, innermost first. */
+    endsAt: Map<number, Frame[]>;
+}
+export declare function frameEdges(entries: readonly FlatEntry[]): FrameEdges;
 /**
  * One frame per chain, for a payload with no calls in it and for the callers
  * that build a plan by hand (tests, `bir replay`). Byte for byte the old

package/dist/replay/flatten.js

@@ -121,6 +121,10 @@ export function flattenChain(scenario, opts = {}) {
                 segmentId: segment.id,
                 chainRevision: segment.chainRevision,
                 paramsObject: segment.paramsObject ?? null,
+                // A sub-task may run only when a test says so (AC5): the plan decides
+                // the whole frame at its first entry, in the caller's scope.
+                ...(step.when ? { when: step.when } : {}),
+                callStep: step,
                 respParams: {},
             };
             frameStart.set(child.id, entries.length);
@@ -147,6 +151,13 @@ export function flattenChain(scenario, opts = {}) {
     });
     return { entries, stopAt, stopReason };
 }
+/** Whether `frame` is `outer` or lies inside it. */
+function within(frame, outer) {
+    for (let f = frame; f; f = f.parent)
+        if (f.id === outer.id)
+            return true;
+    return false;
+}
 /**
  * Move a stop back to the start of the outermost called frame it falls in
  * (R-CALL-30, 10.6 step 3).
@@ -154,7 +165,8 @@ export function flattenChain(scenario, opts = {}) {
  * Used for the known-bad-step gate, which judges entries: a parked step in the
  * middle of a sub-task stops the plan in front of the *sub-task*, not in front
  * of the step, because stopping inside it would skip the body that hands its
- * results back.
+ * results back. The sub-task starts at its first entry *or its callee's*: one
+ * whose chain begins with a call starts where that call's steps do.
  */
 export function clampToFrameStart(entries, index) {
     const at = entries[index];
@@ -166,11 +178,39 @@ export function clampToFrameStart(entries, index) {
     if (!outermost)
         return index;
     for (let i = 0; i < entries.length; i += 1) {
-        if (entries[i].frame.id === outermost.id)
+        if (within(entries[i].frame, outermost))
             return i;
     }
     return index;
 }
+export function frameEdges(entries) {
+    const start = new Map();
+    const end = new Map();
+    const frames = new Map();
+    entries.forEach((entry, index) => {
+        for (let f = entry.frame; f; f = f.parent) {
+            frames.set(f.id, f);
+            if (!start.has(f.id))
+                start.set(f.id, index);
+            end.set(f.id, index);
+        }
+    });
+    const startsAt = new Map();
+    const endsAt = new Map();
+    for (const f of frames.values()) {
+        if (f.depth === 0)
+            continue;
+        const s = start.get(f.id);
+        const e = end.get(f.id);
+        startsAt.set(s, [...(startsAt.get(s) ?? []), f]);
+        endsAt.set(e, [...(endsAt.get(e) ?? []), f]);
+    }
+    for (const list of startsAt.values())
+        list.sort((a, b) => a.depth - b.depth);
+    for (const list of endsAt.values())
+        list.sort((a, b) => b.depth - a.depth);
+    return { start, end, startsAt, endsAt };
+}
 /**
  * One frame per chain, for a payload with no calls in it and for the callers
  * that build a plan by hand (tests, `bir replay`). Byte for byte the old

package/dist/replay/handover.d.ts

@@ -57,7 +57,19 @@ export type HandoverStopReason =
  * place of the plan's. Its result is real; the plan's later steps were
  * computed for the call it planned, so it stops there.
  */
- | "host_edited";
+ | "host_edited"
+/**
+ * The step's test (the service's autocorrect.md AC5) threw, or answered
+ * neither true nor false: nothing says whether this request needs the
+ * step, and nothing is guessed. The step did not run.
+ */
+ | "test_failed"
+/**
+ * A sub-task's last step was left out by its test (AC5), and the sub-task
+ * could not hand its results back to its caller: the body that maps them
+ * threw. Its steps that ran did their work; the one left out did not run.
+ */
+ | "result_map";
 export interface HandoverNoteInput {
     intent: string;
     kind: FallbackKind;
@@ -72,6 +84,25 @@ export interface HandoverNoteInput {
     stopReason?: HandoverStopReason;
     /** Steps that ran under the scenario before the stop. */
     executed: number;
+    /**
+     * When steps before the stop were left out by their tests (AC5): the
+     * 1-based numbers of the steps that ran, so the note names them rather than
+     * "steps 1–N". `executed` is then their count.
+     */
+    ranSteps?: number[];
+    /**
+     * The steps before the stop that their tests left out, 1-based and
+     * inclusive (a sub-task left out whole spans several): named, so the model
+     * neither thinks they ran nor runs them.
+     */
+    leftOut?: Array<{
+        from: number;
+        to: number;
+        toolName: string;
+        text: string | null;
+    }>;
+    /** For `result_map`: the sub-task whose results could not go back. */
+    subTask?: string | null;
     /**
      * Of {@link executed}, how many are the model's own tool calls above — the
      * steps a steered session ran before a divergence took over. Only read when
@@ -120,6 +151,13 @@ export interface HandoverNoteInput {
     ownerScenarioId?: string | null;
     /** The sub-task the stopped step belongs to, when it is inside one. */
     inSubTask?: string | null;
+    /**
+     * For `other_branch`: the stopped step's test in words — what the steps
+     * from there on are for, which this request is not (autocorrect.md AC5).
+     */
+    whenText?: string | null;
 }
 export declare function buildHandoverNote(n: HandoverNoteInput): string;
+/** "Step 2", "Steps 1–3", "Steps 1, 3 and 5–6": 1-based numbers in order, runs joined. */
+export declare function stepsPhrase(numbers: readonly number[]): string;
 //# sourceMappingURL=handover.d.ts.map

package/dist/replay/handover.js

@@ -35,7 +35,28 @@ export function buildHandoverNote(n) {
     ];
     if (intent)
         lines.push(`Intent: ${intent}`);
-    if (n.executed > 0) {
+    // Steps left out by their tests sit among those before the stop (AC5): the
+    // ones that ran are then named, never "steps 1–N", which would say a step
+    // ran that did not.
+    const numbered = n.ranSteps && n.ranSteps.length > 0 ? n.ranSteps.slice(0, n.executed) : undefined;
+    if (n.executed > 0 && numbered) {
+        const above = Math.max(0, Math.min(n.executedAbove ?? 0, n.executed));
+        const delivery = above >= n.executed ? "above" : n.delivery;
+        const one = numbered.length === 1;
+        const ran = `${stepsPhrase(numbered)} of ${n.totalSteps} ran under the scenario`;
+        const them = one ? "it" : "them";
+        const aboveAre = `${stepsPhrase(numbered.slice(0, above)).toLowerCase()} ${above === 1 ? "is the tool call" : "are the tool calls"} above`;
+        lines.push(delivery === "above"
+            ? `${ran}; ${one ? "its call and result are the tool call" : "their calls and results are the tool calls"} above. Do not repeat ${them}.`
+            : above > 0
+                ? delivery === "none"
+                    ? `${ran}: ${aboveAre}, and the side effects of the rest are in place. Do not repeat ${them}.`
+                    : `${ran}: ${aboveAre}, and the rest ${n.executed - above === 1 ? "is" : "are"} below. Do not repeat ${them}.`
+                : delivery === "none"
+                    ? `${ran}, and ${one ? "its" : "their"} side effects are in place. Do not repeat ${them}.`
+                    : `${ran}; ${one ? "its call and result are" : "their calls and results are"} below. Do not repeat ${them}.`);
+    }
+    else if (n.executed > 0) {
         // Part of the work may be the model's own calls above (a steered session
         // that diverged), and the rest the bundle below or side effects only.
         const above = Math.max(0, Math.min(n.executedAbove ?? 0, n.executed));
@@ -65,6 +86,14 @@ export function buildHandoverNote(n) {
     else {
         lines.push("No step of the scenario ran; the whole task is yours.");
     }
+    if (n.leftOut && n.leftOut.length > 0) {
+        // Named, so the model neither counts them as done nor runs them now.
+        const named = n.leftOut.map((l) => `${l.from === l.to ? `step ${l.from}` : `steps ${l.from}–${l.to}`} (${l.toolName})`);
+        const texts = [...new Set(n.leftOut.map((l) => l.text).filter((t) => !!t))];
+        const why = texts.length === 1 ? ` — only for when ${texts[0]}` : "";
+        const one = n.leftOut.length === 1 && n.leftOut[0].from === n.leftOut[0].to;
+        lines.push(`Not needed for this request, so not run: ${joinList(named)}${why}. Do not run ${one ? "it" : "them"}.`);
+    }
     if (n.inFlight) {
         // Never "ran", never "did not run": the host has not said which.
         const inTool = n.inFlight.toolName ? ` (${n.inFlight.toolName})` : "";
@@ -93,10 +122,22 @@ export function buildHandoverNote(n) {
         // judgement, and the agent is the one to make it (plan-services.md D8).
         lines.push(`Step ${human} of ${n.totalSteps}${tool} did not run: its input needs a judgement the scenario cannot compute. Make that choice yourself and carry on.`);
     }
+    else if (n.kind === "other_branch") {
+        // The plan holds one half of an "if … otherwise" and this request is the
+        // other (autocorrect.md AC5). The steps from here are not wrong, they are
+        // not this request's: the model is told what they are for, never to run
+        // them, and the list of their tools is left out below for that reason.
+        const why = n.whenText ? `they are only for when ${n.whenText}, and that is not so for this request` : "this request is the other case of the task, which they are not for";
+        lines.push(n.stepIndex >= n.totalSteps
+            ? "None of the scenario's steps was needed for this request. Do the task as this request needs it."
+            : `Step ${human} of ${n.totalSteps}${tool} and the steps after it did not run: ${why}. Do the rest of the task yourself, as this request needs it.`);
+    }
     else {
         lines.push(stepFailedLine(n, human, tool));
     }
-    if (n.remainingTools.length > 0) {
+    // Not for the other half: those tools are the ones this request must not
+    // run, and naming them invites exactly that.
+    if (n.remainingTools.length > 0 && n.kind !== "other_branch") {
         lines.push(`The remaining planned steps were: ${n.remainingTools.join(", ")}.`);
     }
     if (n.params && Object.keys(n.params).length > 0) {
@@ -111,6 +152,32 @@ export function buildHandoverNote(n) {
     }
     return truncate(lines.join("\n"), MAX_HANDOVER_NOTE);
 }
+/** "Step 2", "Steps 1–3", "Steps 1, 3 and 5–6": 1-based numbers in order, runs joined. */
+export function stepsPhrase(numbers) {
+    if (numbers.length === 0)
+        return "No step";
+    if (numbers.length === 1)
+        return `Step ${numbers[0]}`;
+    const runs = [];
+    let from = numbers[0];
+    let to = from;
+    for (const n of numbers.slice(1)) {
+        if (n === to + 1) {
+            to = n;
+            continue;
+        }
+        runs.push(from === to ? `${from}` : `${from}–${to}`);
+        from = to = n;
+    }
+    runs.push(from === to ? `${from}` : `${from}–${to}`);
+    return `Steps ${joinList(runs)}`;
+}
+/** "a", "a and b", "a, b and c". */
+function joinList(items) {
+    if (items.length <= 1)
+        return items.join("");
+    return `${items.slice(0, -1).join(", ")} and ${items[items.length - 1]}`;
+}
 /** The line that names a stopped step and says what may be assumed about it. */
 function stepFailedLine(n, human, tool) {
     const at = `Step ${human} of ${n.totalSteps}${tool}`;
@@ -135,6 +202,18 @@ function stepFailedLine(n, human, tool) {
             `could not read its output${detail ? ` (${detail})` : ""}, so it stops there. Do not run it again.`);
     }
     switch (n.stopReason) {
+        case "result_map": {
+            // Nothing of the stopped position ran: its sub-task's last step was left
+            // out, and what failed is handing the sub-task's results on.
+            const what = n.subTask ? ` "${truncate(n.subTask, 120)}"` : "";
+            return (`The sub-task${what} could not hand back its results${detail ? ` (${detail})` : ""}, ` +
+                "so the scenario stops after it. Do the rest of the task yourself.");
+        }
+        case "test_failed":
+            // The test could not answer, so whether the step is needed is open: the
+            // model decides, as it would without the scenario.
+            return (`${at} did not run: the scenario could not tell whether this request needs it` +
+                `${detail ? ` (${detail})` : ""}. Decide that yourself and carry on.`);
         case "not_run":
             return `${at} did not run${detail ? `: ${detail}` : ""}. Nothing of it happened; do it yourself.`;
         case "uncertain":

package/dist/replay/logic.d.ts

@@ -74,6 +74,14 @@ export interface LogicRunOptions {
 }
 /** Transform the derived parameters once, before any step runs. */
 export declare function evalParamsLogic(code: string, parameters: Record<string, unknown>, intent: string): Record<string, unknown>;
+/**
+ * A step's test (the service's autocorrect.md AC5): whether this request needs
+ * the step, from the parameters and what the earlier steps accumulated. The
+ * answer must be exactly `true` or `false` — a truthy string or a missing key
+ * is not an answer, and a test that cannot answer is never guessed at: it
+ * throws, and the plan stops in front of the step.
+ */
+export declare function evalWhenLogic(code: string, parameters: Record<string, unknown>, intent: string, respParams?: Record<string, unknown>): boolean;
 /** Derive one step's tool input from params, intent and the accumulated respParams. */
 export declare function evalToolInputLogic(code: string, parameters: Record<string, unknown>, intent: string, respParams?: Record<string, unknown>, opts?: LogicRunOptions): Record<string, unknown>;
 /** Extract keys from a step's real output, to merge into respParams for later steps. */

package/dist/replay/logic.js

@@ -137,6 +137,25 @@ function assertPlainObject(result, label) {
 export function evalParamsLogic(code, parameters, intent) {
     return assertPlainObject(run("paramsLogic", ["parameters", "intent"], code, [parameters, intent]), "paramsLogic");
 }
+/**
+ * A step's test (the service's autocorrect.md AC5): whether this request needs
+ * the step, from the parameters and what the earlier steps accumulated. The
+ * answer must be exactly `true` or `false` — a truthy string or a missing key
+ * is not an answer, and a test that cannot answer is never guessed at: it
+ * throws, and the plan stops in front of the step.
+ */
+export function evalWhenLogic(code, parameters, intent, respParams = {}) {
+    const answer = run("whenLogic", ["parameters", "intent", "respParams"], code, [
+        parameters,
+        intent,
+        respParams,
+    ]);
+    if (answer !== true && answer !== false) {
+        const shown = answer === undefined ? "undefined" : typeof answer === "string" ? `"${answer.slice(0, 40)}"` : typeof answer;
+        throw new Error(`whenLogic must return true or false, and returned ${shown}`);
+    }
+    return answer;
+}
 /** Derive one step's tool input from params, intent and the accumulated respParams. */
 export function evalToolInputLogic(code, parameters, intent, respParams = {}, opts) {
     return assertPlainObject(run("toolInputLogic", ["parameters", "intent", "respParams"], code, [parameters, intent, respParams], opts), "toolInputLogic");

package/dist/replay/plan.d.ts

@@ -83,8 +83,14 @@ export interface DriveOptions {
  * It takes the *entry*, not the step: a step inside a called segment takes its
  * recorded output from that segment's own recording, within its own range
  * (segmented.md R-CALL-31).
+ *
+ * `leftOut`, when there, is told of every step a test left out (the service's
+ * autocorrect.md AC5): one that was in the recording made its call there, and
+ * its output is passed over, so the next step of its tool takes its own.
  */
-export type RecordedOutputFor = (entry: FlatEntry) => Promise<string | undefined>;
+export type RecordedOutputFor = ((entry: FlatEntry) => Promise<string | undefined>) & {
+    leftOut?: (entry: FlatEntry) => void;
+};
 /**
  * What one step did, told to the caller as it happens.
  *
@@ -111,7 +117,12 @@ export interface StepInfo {
      * call produced none — `skipped`, or a failure before the tool ran.
      */
     output?: string;
-    outcome: "executed" | "recorded" | "skipped" | "failed";
+    /**
+     * `not_taken`: the step's test said this request does not need it, and it
+     * was left out on purpose (the service's autocorrect.md AC5). No call, no
+     * output logic; a sub-task's call row left out whole is one such verdict.
+     */
+    outcome: "executed" | "recorded" | "skipped" | "failed" | "not_taken";
     /** Which part of the step broke. Only set for `failed`. */
     stage?: ExecutionStage;
     error?: string;
@@ -152,8 +163,18 @@ export interface ComposeResult {
      * and yet the work did not happen, and an outcome must not say it did.
      */
     errored: number;
+    /** Steps a test left out because this request does not need them (AC5). */
+    notTaken: number;
+    /** Those steps, in order: what a note counting the steps that ran leaves out. */
+    left: LeftOut[];
     /** Where, and why, the run stopped short of its end, when it did. */
     stopped?: PlanStop;
+    /**
+     * The flat position the walk ended at. At or past the plan's `stepCount`
+     * when it reached the end of the planned steps — past it when a test left
+     * out a sub-task that reaches beyond a parked step.
+     */
+    endedAt: number;
 }
 /** Where, and why, a run stopped short of the chain's end (fallbk.md). */
 export interface PlanStop {
@@ -170,6 +191,58 @@ export interface PlanStop {
      * Absent means its logic threw or its tool reported an error.
      */
     reason?: HandoverStopReason;
+    /** For `other_branch`: the test in words — what the steps from here are for (AC5). */
+    whenText?: string | null;
+    /**
+     * For `result_map`: the sub-task whose results could not go back to its
+     * caller, after its last step was left out by its test (AC5).
+     */
+    subTask?: string | null;
+}
+/**
+ * What a step's test decided at one flat position (the service's
+ * autocorrect.md AC5).
+ *
+ *  - `run`: no test, or its test said yes.
+ *  - `skip`: this request does not need it — the step, or the whole sub-task
+ *    whose call row's test said no. The walk goes on at `until`. `leave` says
+ *    the step left out was the last of an entered sub-task, so the sub-task's
+ *    results still go back to its caller.
+ *  - `stop`: the test said `hand_over` (this request is the other half), or
+ *    could not answer. `info` is the step's verdict when there is one to give.
+ */
+export type Gate = {
+    kind: "run";
+} | {
+    kind: "skip";
+    until: number;
+    info: StepInfo;
+    entry: FlatEntry;
+    text: string | null;
+    tools: string[];
+} | {
+    kind: "stop";
+    stop: PlanStop;
+    info?: StepInfo;
+};
+/** A step left out by its test, as the steer note and the bundle name it. */
+export interface LeftOut {
+    /** The owning scenario's own `stepIndex` — the caller's for a sub-task. */
+    stepIndex: number;
+    /** Its flat position. */
+    flatIndex: number;
+    /**
+     * The flat position after it: past every step of a sub-task left out
+     * whole, `flatIndex + 1` for one step.
+     */
+    until: number;
+    toolName: string;
+    /**
+     * Every tool the steps left out call — the sub-task's, for a sub-task left
+     * out whole — so a call the model makes to any of them is known for one.
+     */
+    tools: string[];
+    text: string | null;
 }
 export interface PlanOptions {
     scenario: SerializedScenario;
@@ -230,7 +303,22 @@ export declare class ScenarioReplayPlan {
     private readonly stopAt;
     /** This plan is a sub-task inside the agent's own task (segmented.md R-OUT-13). */
     readonly subTask: boolean;
+    /**
+     * 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).
+     */
+    private readonly edges;
+    /** Each entry's flat position. */
+    private readonly positions;
+    /** Every frame of the flat list, by id. */
+    private readonly frames;
+    /** The plan's own walk: what its cursor has entered and decided (AC5). */
+    private readonly walk;
     constructor(opts: PlanOptions);
+    private frameById;
+    /** The called frames that begin at flat position `flatIndex`, outermost first. */
+    private framesStartingAt;
     /** The caller's own frame — the one at depth 0. */
     private rootFrame;
     /** The parameters one entry's logic runs with (segmented.md R-CALL-29). */
@@ -246,7 +334,27 @@ export declare class ScenarioReplayPlan {
      * out. A mapping that omits a setting therefore cannot pass the service's
      * check and then run `undefined` here.
      */
+    private enterFramesAt;
     private enterFrame;
+    /**
+     * 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.
+     */
+    private leaveFramesAt;
+    /**
+     * 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`.
+     */
+    private leaveAfterSkip;
+    /**
+     * 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).
+     */
+    private callRowOf;
     /**
      * Leaving a called frame: hand what the segment emitted back to its caller
      * (R-CALL-29). `out` is the frame's own accumulated `respParams`.
@@ -295,8 +403,6 @@ export declare class ScenarioReplayPlan {
     stopStep(): SerializedScenarioStep | undefined;
     /** The entry the plan stops in front of, with the frame that owns it. */
     stopEntry(): FlatEntry | undefined;
-    /** Tool names from position `from` to the end of the flat chain. */
-    toolsFrom(from: number): string[];
     /** Every entry in order — for the report, and for the owning scenario ids. */
     allEntries(): readonly FlatEntry[];
     /** The entry awaiting execution, or undefined when the plan is done. */
@@ -333,6 +439,61 @@ export declare class ScenarioReplayPlan {
      * a throw as divergence.
      */
     toolInputForCurrentStep(): Record<string, unknown>;
+    /** Whether the plan's cursor rests in front of the step it is parked before. */
+    atStop(): boolean;
+    /**
+     * 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: FlatEntry): {
+        text: string | null;
+    } | 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: number): string[];
+    /** The steps the plan's own cursor has left out so far, in order (AC5). */
+    leftOut(): readonly LeftOut[];
+    /** Whether any planned step runs only under a test. */
+    hasTests(): boolean;
+    /** One test, answered — or the reason it could not be. Never throws. */
+    private answer;
+    /**
+     * 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.
+     */
+    private gate;
+    /**
+     * 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.
+     */
+    private decideCall;
+    /** What a skip the gate decided leaves out, as the notes name it. */
+    private leftOutOf;
+    /**
+     * 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}).
+     */
+    private passOver;
+    /**
+     * 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?: StepObserver, opts?: {
+        rethrow?: boolean;
+    }): {
+        stop?: PlanStop;
+        left: LeftOut[];
+    };
     /**
      * Thread a real tool output into `respParams` and advance.
      *