@basein/runner 0.3.21 → 0.3.23

package/dist/replay/controller.js

@@ -29,7 +29,6 @@ import { PREVIEW_BUDGET_MS, RecordedValueError, ScenarioReplayPlan, StepRunError
 import { PRICING_VERSION } from "./pricing.js";
 import { hasShellStep, sinkOf, sinkOfPlan, unsafeParameter } from "./safety.js";
 import { SourceRunOutputs } from "./source-run.js";
-import { clampToFrameStart, flattenChain, frameEdges, } from "./flatten.js";
 import { blockingTargets, testedOnlyTargets } from "./targets.js";
 import { isNoResult, toolResultError } from "./tool-error.js";
 import { OUTCOME_RANK, hasTargets, isReadyScenario, } from "./types.js";
@@ -168,7 +167,7 @@ function handedOver(note) {
 }
 export const DEFAULT_INTENT_MATCH = {
     enabled: true,
-    budgetMs: 4_000,
+    budgetMs: 1_500,
     maxPerTurn: 3,
     maxRequestsPerTurn: 40,
 };
@@ -197,6 +196,15 @@ const MAX_STEP_ERROR_CHARS = 500;
  * cannot hold more than a few megabytes in the recorder.
  */
 const TURN_CALLS_MAX_CHARS = 8 * 1024 * 1024;
+/**
+ * Whether a plan is a part of the task the agent is already doing — armed
+ * mid-turn by its intent — so its words say "continue" and never "answer the
+ * user". A continuation is armed mid-turn too, and it is the rest of the
+ * user's request: it ends with the answer.
+ */
+export function isSubTask(state) {
+    return state.armedBy === "intent" && state.continuation === undefined;
+}
 export class ReplayController {
     enabled;
     work = new ProxyWorkQueue();
@@ -291,18 +299,6 @@ export class ReplayController {
             ? builtins
             : new Set([...builtins].filter(reachable));
     }
-    /**
-     * Whether a handed-out segment may actually arm (segmented.md R-OUT-10).
-     *
-     * Only when the option says so. The recorder passes it on unless
-     * `BIR_SEGMENT_ARM=0` (from 0.3.19; the service's segmentsbreakdown.md
-     * SB-21); a controller built without it stays observe-only, asks for no
-     * segment and arms none. The server enforces the same thing from its side
-     * (R-OUT-9).
-     */
-    get segmentArm() {
-        return this.opts.segmentArm === true;
-    }
     /** The plan's own delivery vehicle is never a scenario step. */
     isDirectTool(toolName) {
         return toolName === DIRECT_TOOL_NAME;
@@ -362,13 +358,6 @@ export class ReplayController {
             reported: false,
             retired: false,
             armedBy,
-            // An older server sends no `kind`, and a whole-run scenario is the safe
-            // reading: it is what every hand-out was before segments existed.
-            kind: match.kind ?? "scenario",
-            segment: match.segment,
-            key: match.key,
-            verified: match.verified,
-            sharedWith: [],
         };
     }
     /**
@@ -385,6 +374,30 @@ export class ReplayController {
         state.retired = true;
         return state;
     }
+    /**
+     * The state of a continuation handed out and not armed (the service's
+     * fallbk.md Part 3): declined before any gate ran — its first step is not
+     * the model's call (`not_first_step`), or the service's answer came too
+     * late (`match_late`). Like {@link lateMatch}, it exists only for its
+     * ticket's report, with the reason.
+     */
+    declinedContinuation(match, code, continuation) {
+        const state = this.blankState(match, new Set(), "intent");
+        state.continuation = continuation;
+        state.declined = code;
+        state.retired = true;
+        logLine("replay.decision", {
+            verdict: "no-steer",
+            code,
+            run: match.runId,
+            scenario: match.scenarioId ?? undefined,
+            continues: `${continuation.ofScenarioId}@${continuation.stepIndex}`,
+            why: code === "not_first_step"
+                ? "a continuation starts only on its first step, and the model's call after the hand-over is another one"
+                : "the continuation came after the call it could have replaced had gone ahead",
+        });
+        return state;
+    }
     /**
      * Run the gate ladder and, if every gate passes, arm a plan.
      *
@@ -393,15 +406,14 @@ export class ReplayController {
      * up with a denominator nobody measured.
      *
      * `host` is given for a session whose host is not Claude Code, and is kept
-     * on the state (see {@link HostContext}).
+     * on the state (see {@link HostContext}). `extra.continuation` arms a
+     * continuation (the service's fallbk.md Part 3): see
+     * {@link ReplayState.continuation}.
      */
-    async arm(match, prompt, wrapped, armedBy = "prompt", ctx = {}, host) {
+    async arm(match, prompt, wrapped, armedBy = "prompt", ctx = {}, host, extra = {}) {
         const state = this.blankState(match, wrapped, armedBy, host);
-        // A decision note quotes the request (SB-18); a plan armed by intent was
-        // given the step's intent here, and its control server sets the request.
-        if (armedBy === "prompt")
-            state.request = prompt;
-        const isSegment = state.kind === "segment";
+        if (extra.continuation)
+            state.continuation = extra.continuation;
         const decline = (why, code) => {
             state.declined = code;
             logLine("replay.decision", {
@@ -410,19 +422,10 @@ export class ReplayController {
                 run: match.runId,
                 scenario: match.scenarioId ?? undefined,
                 similarity: match.similarity.toFixed(3),
-                kind: state.kind,
-                key: state.key,
-                verified: state.verified?.verdict,
                 why,
             });
             return state;
         };
-        // The server never sends a segment to a runner that did not ask for one
-        // (R-OUT-9). One arriving anyway is declined here rather than run: an
-        // observe-only period that quietly armed something would be worthless.
-        if (isSegment && !this.segmentArm) {
-            return decline("segment hand-out while BIR_SEGMENT_ARM is off", "replay_disabled");
-        }
         // Gate 2 — replay enabled.
         if (!this.enabled)
             return decline("BIR_REPLAY=0", "replay_disabled");
@@ -452,65 +455,24 @@ export class ReplayController {
         }
         // Gate 4 — similarity — is gone. A hand-out is the service's decision that
         // this scenario does what the prompt asks: its match threshold, the
-        // same-request question under it, the intent pass, a segment's clear band
-        // or `same` verdict. Scoring it again here declined matches the service
-        // had made (a checked 0.85, a task line at 0.91), so every match now
-        // steers. What a plan cannot do — a step that keeps failing, a tool
-        // nobody wrapped, a target the prompt never named — the gates below
-        // still stop.
-        // Flatten the chain before the remaining gates, so every one of them judges
-        // the steps that will *really* run — the caller's own and, in order, those
-        // of every segment it calls (segmented.md R-CALL-29, R-CALL-30).
-        let flat;
-        try {
-            flat = flattenChain(scenario, {
-                range: match.segment
-                    ? { stepFrom: match.segment.stepFrom, stepTo: match.segment.stepTo }
-                    : null,
-            });
-        }
-        catch (err) {
-            // A payload we cannot lay out is a payload we cannot run. It costs the
-            // turn nothing: the agent does the task (R-FALL-12).
-            logLine("replay.flatten_failed", { scenario: scenario.id, error: errText(err) });
-            return decline("the chain could not be flattened", "flatten_failed");
-        }
-        const entries = flat.entries;
-        if (entries.length === 0)
-            return decline("the chain has no runnable step", "not_ready");
+        // same-request question under it, the intent pass. Scoring it again here
+        // declined matches the service had made (a checked 0.85, a task line at
+        // 0.91), so every match now steers. What a plan cannot do — a step that
+        // keeps failing, a tool nobody wrapped, a target the prompt never named —
+        // the gates below still stop.
+        const steps = scenario.steps;
         // Gate 5 — steps the plan must stop in front of (fallbk.md D3,
         // plan-services.md D8): a step the service parked — failed more than its
-        // limit, retry not due — or one the calculation marked non-deterministic,
-        // on whichever scenario owns it (R-CALL-30). A call the service could not
-        // answer stops the plan the same way, and the earliest of them wins.
-        const badAt = stopIndex(entries.map((e) => e.step), match.fallback?.maxStepFailures);
-        const rawStop = [flat.stopAt, badAt].filter((n) => typeof n === "number");
-        // Clamped to the start of the outermost called frame it falls in: a plan
-        // never runs half a sub-task and leaves its result mapping unevaluated.
-        const stopAt = rawStop.length > 0 ? clampToFrameStart(entries, Math.min(...rawStop)) : undefined;
+        // limit, retry not due — or one the calculation marked non-deterministic.
+        const stopAt = stopIndex(steps, match.fallback?.maxStepFailures);
         if (stopAt === 0) {
-            const unusable = flat.stopAt === 0 && flat.stopReason ? flat.stopReason : undefined;
-            // The step that stops the plan, before the clamp: the reason is its own.
-            const stopping = entries[Math.min(...rawStop)]?.step ?? entries[0].step;
-            // The service never serves a decision at step 0 (segmentsbreakdown.md
-            // SB-5): should one come, the agent decides from the start, as it makes
-            // a judgement there. No new code reaches a service that may not know it.
-            const decisionFirst = stopping.stop?.kind === "decision";
-            const judgement = stopping.stop?.kind === "nondeterministic" || decisionFirst;
-            const why = unusable
-                ? `its first step is a call that cannot run: ${unusable.reason}`
-                : decisionFirst
-                    ? "its first step is a decision the agent makes — the agent does this task"
-                    : judgement
-                        ? "its first step needs a judgement the plan cannot compute — the agent does this task"
-                        : `its first step has failed ${stopping.failureCount ?? 0} times — the agent does this task`;
-            return decline(why, unusable
-                ? "unusable_first_step"
-                : judgement
-                    ? "nondeterministic_first_step"
-                    : "known_bad_first_step");
-        }
-        const planned = stopAt === undefined ? entries : entries.slice(0, stopAt);
+            const stopping = steps[0];
+            const judgement = stopping.stop?.kind === "nondeterministic";
+            return decline(judgement
+                ? "its first step needs a judgement the plan cannot compute — the agent does this task"
+                : `its first step has failed ${stopping.failureCount ?? 0} times — the agent does this task`, judgement ? "nondeterministic_first_step" : "known_bad_first_step");
+        }
+        const planned = stopAt === undefined ? steps : steps.slice(0, stopAt);
         // Another host's adapter steps through a plan call by call and knows no
         // tests (AC5): asked for a step its test left out, it is refused, reads
         // that as the plan's end, and the model's own calls after it are booked as
@@ -530,7 +492,7 @@ export class ReplayController {
         // `mcp__fleet__list` is not the runner's to run or a proxy's to reach.
         const allowServers = host ? undefined : this.opts.allowServers;
         const builtinTools = host ? undefined : this.builtinTools;
-        const mode = modeFor(planned.map((e) => e.step), state.wrapped, allowServers, builtinTools);
+        const mode = modeFor(planned, state.wrapped, allowServers, builtinTools);
         if (mode === "none")
             return decline("no step is executable", "coverage");
         // Tool results feed derivation as context, and they are whatever the agent
@@ -544,7 +506,7 @@ export class ReplayController {
         // command nobody asked for.
         let deriveCtx = ctx;
         if (ctx.recentResults?.length && sinkOfPlan(planned, host?.sinks) === "command") {
-            deriveCtx = { liveCall: ctx.liveCall, agentDay: ctx.agentDay, atDecision: ctx.atDecision };
+            deriveCtx = { liveCall: ctx.liveCall, agentDay: ctx.agentDay };
             logLine("replay.derive_context", {
                 scenario: scenario.id,
                 shell: hasShellStep(planned, host?.sinks) || undefined,
@@ -671,15 +633,14 @@ export class ReplayController {
             }
         }
         // A plan armed by intent runs inside a task the agent is already doing, so
-        // its directive and its bundles say "continue", never "answer the user"
-        // (segmented.md R-OUT-13).
+        // its directive and its bundles say "continue", never "answer the user".
+        // A continuation is the rest of the user's request: it ends with the answer.
         state.plan = new ScenarioReplayPlan({
             scenario,
             params,
             mode,
             stopAt,
-            entries,
-            subTask: armedBy === "intent",
+            subTask: isSubTask(state),
         });
         if (mode === "steer") {
             // A steer directive shows the arguments the steps will run with, so the
@@ -697,17 +658,11 @@ export class ReplayController {
                 await state.plan.ready().catch(() => undefined);
         }
         state.mode = mode;
-        state.stepsPlanned = entries.length;
+        state.stepsPlanned = steps.length;
         // The chain this plan was served at: what its own calls are marked with
         // when they are recorded into a redo of the turn (AC2).
         if (typeof scenario.chainRevision === "number")
             state.chainRevision = scenario.chainRevision;
-        // Why the plan stops, when a call is what stops it: the note names the
-        // sub-task rather than a tool (R-CALL-36).
-        state.flatStop =
-            typeof stopAt === "number" && flat.stopAt !== undefined && stopAt <= flat.stopAt
-                ? flat.stopReason
-                : undefined;
         // Recorded outputs are read only when they may stand in (opt-in), so a
         // plan never fetches a run it will not show.
         if (this.recordedFallback && this.opts.authUrl && this.opts.authToken) {
@@ -724,22 +679,20 @@ export class ReplayController {
             scenario: scenario.id,
             mode,
             host: host?.app,
-            steps: entries.length,
+            steps: steps.length,
             stopsAt: stopAt,
-            by: armedBy === "intent" ? "intent" : undefined,
-            kind: state.kind,
-            key: state.key,
-            verified: state.verified?.verdict,
+            by: armedBy === "intent" ? (state.continuation ? "continuation" : "intent") : undefined,
+            // The plan it continues and the step that plan stopped in front of.
+            continues: state.continuation
+                ? `${state.continuation.ofScenarioId}@${state.continuation.stepIndex}`
+                : undefined,
             similarity: match.similarity.toFixed(3),
-            // What this chain calls, and what answers each call right now (R-CALL-32).
-            calls: callLines(scenario),
-            unusable: flat.stopReason?.reason,
             // Which steps the service told this plan to stop in front of, and why.
-            stops: stopLines(entries),
-            coverage: coverageOf(entries.map((e) => e.step), state.wrapped, allowServers, builtinTools).join(","),
-            tools: entries.map((e) => e.step.toolName ?? "").join(","),
-            // Which steps run only under a test, by flat position (AC5).
-            tests: testLines(entries),
+            stops: stopLines(steps),
+            coverage: coverageOf(steps, state.wrapped, allowServers, builtinTools).join(","),
+            tools: steps.map((s) => s.toolName).join(","),
+            // Which steps run only under a test, by position (AC5).
+            tests: testLines(steps),
         });
         return state;
     }
@@ -748,16 +701,16 @@ export class ReplayController {
      * stops when that is before its end. For a host that steps through the plan
      * itself and must not have to pick the tool names out of a directive
      * written for a model — a reworded sentence would break every adapter in
-     * the field. Built from the same entries the directive lists.
+     * the field. Built from the same steps the directive lists.
      */
     planData(state) {
         const plan = state.plan;
         if (!plan || state.retired)
             return undefined;
         const steps = plan
-            .allEntries()
+            .allSteps()
             .slice(0, plan.stepCount)
-            .map((entry, stepIndex) => ({ stepIndex, toolName: entry.step.toolName ?? "" }));
+            .map((step, stepIndex) => ({ stepIndex, toolName: step.toolName }));
         return {
             scenarioId: state.scenarioId,
             mode: state.mode,
@@ -765,15 +718,6 @@ export class ReplayController {
             ...(plan.stopsEarly() ? { stopAt: plan.stepCount } : {}),
         };
     }
-    /**
-     * Whether the plan's steps end in front of a decision (the service's
-     * segmentsbreakdown.md SB-6): it runs the steps before it, then hands the
-     * task back there. The control server gives such a plan a usage mark, so
-     * that it is billed only up to the stop (SB-26).
-     */
-    stopsAtDecision(state) {
-        return state.plan?.stopEntry()?.step.stop?.kind === "decision";
-    }
     /**
      * Take back a plan that armed and has run nothing, as a decline.
      *
@@ -797,7 +741,6 @@ export class ReplayController {
             run: state.matchedRunId,
             scenario: state.scenarioId ?? undefined,
             similarity: state.similarity.toFixed(3),
-            kind: state.kind,
             why,
         });
         state.plan = undefined;
@@ -828,7 +771,6 @@ export class ReplayController {
         this.handOver(state, {
             kind: "step_failed",
             step: plan.currentStep(),
-            entry: plan.currentEntry(),
             position,
             error: why === "own_call"
                 ? "the model made a call of its own, so the scenario stopped"
@@ -852,7 +794,7 @@ export class ReplayController {
     directiveFor(state, opts = {}) {
         const asked = opts.previewMs;
         return state.plan?.steeringDirective(DIRECT_TOOL_NAME, {
-            subTask: state.armedBy === "intent",
+            subTask: isSubTask(state),
             // NaN is a caller's arithmetic gone wrong: no time known, no preview.
             previewBudgetMs: typeof asked === "number"
                 ? Math.max(0, Math.min(Number.isNaN(asked) ? 0 : asked, PREVIEW_BUDGET_MS))
@@ -889,8 +831,8 @@ export class ReplayController {
             return false;
         if (plan.parametersSettled)
             return true;
-        const planned = plan.allEntries().slice(0, plan.stepCount);
-        if (!planned.some((e) => pinnedToShape(e.step.toolName)))
+        const planned = plan.allSteps().slice(0, plan.stepCount);
+        if (!planned.some((s) => pinnedToShape(s.toolName)))
             return false;
         if (state.deriveOnService && !serviceHealth.canWait())
             return false;
@@ -1023,7 +965,6 @@ export class ReplayController {
             if (step && ready.blame) {
                 this.recordStep(state, {
                     step,
-                    entry: plan.currentEntry(),
                     outcome: "failed",
                     stage: ready.stage,
                     error: ready.error,
@@ -1032,7 +973,6 @@ export class ReplayController {
             this.handOver(state, {
                 kind: "step_failed",
                 step,
-                entry: plan.currentEntry(),
                 position: plan.currentStepIndex,
                 error: ready.error,
                 delivery: "above",
@@ -1136,7 +1076,6 @@ export class ReplayController {
                     const recorded = err instanceof RecordedValueError;
                     this.recordStep(state, {
                         step,
-                        entry: plan.currentEntry(),
                         outcome: recorded ? "skipped" : "failed",
                         stage: "tool_input_logic",
                         error: errText(err),
@@ -1165,7 +1104,6 @@ export class ReplayController {
             this.handOver(state, {
                 kind: "step_failed",
                 step: plan.currentStep(),
-                entry: plan.currentEntry(),
                 position: plan.currentStepIndex,
                 error: `the scenario's next step is ${expected ?? "none"}, and the host asked for ${toolName}`,
                 delivery: "above",
@@ -1213,7 +1151,6 @@ export class ReplayController {
         this.handOver(state, {
             kind: "step_failed",
             step: plan.allSteps()[next],
-            entry: plan.allEntries()[next],
             position: next,
             delivery: "above",
             stopReason: "concurrent",
@@ -1351,10 +1288,6 @@ export class ReplayController {
         // reading it after the call would judge the *next* step, and reading it
         // before assumes no other pin ever moved it.
         const step = plan.allSteps()[pin.stepIndex];
-        // The entry it ran as, so its verdict is kept under the scenario that owns
-        // the step: a called segment numbers its steps from zero too, and without
-        // this its step 0 replaced the caller's (segmented.md R-CALL-13).
-        const entry = plan.allEntries()[pin.stepIndex];
         // THE HOST STOPPED THE STEP, and says so. Read before any failure: a
         // person's "no" arrives as an error result, and booked as one it would be
         // counted against a plan that did nothing wrong — after enough of them the
@@ -1362,11 +1295,10 @@ export class ReplayController {
         // `rejected` the tool never ran, and after `edited` its result answers a
         // call the plan did not plan, which its later steps were not computed for.
         if (how.hostStop && step) {
-            this.hostStopped(state, pin, step, entry, output, how.hostStop);
+            this.hostStopped(state, pin, step, output, how.hostStop);
             this.handOver(state, {
                 kind: "step_failed",
                 step,
-                entry,
                 position: pin.stepIndex,
                 delivery: "above",
                 stopReason: how.hostStop === "edited" ? "host_edited" : "host_rejected",
@@ -1387,7 +1319,6 @@ export class ReplayController {
                 `the plan's cursor is at step ${plan.currentStepIndex}, not the pinned step ${pin.stepIndex}`;
             const info = {
                 step,
-                entry,
                 input: pin.input,
                 output: answerOf(output),
                 outcome: "failed",
@@ -1401,7 +1332,6 @@ export class ReplayController {
             this.handOver(state, {
                 kind: "step_failed",
                 step,
-                entry,
                 position: pin.stepIndex,
                 error,
                 delivery: "above",
@@ -1423,7 +1353,6 @@ export class ReplayController {
             if (step) {
                 this.recordStep(state, {
                     step,
-                    entry,
                     input: pin.input,
                     // What the logic threw on — the output is usually the explanation.
                     output,
@@ -1462,7 +1391,6 @@ export class ReplayController {
         if (step && toolError) {
             const info = {
                 step,
-                entry,
                 input: pin.input,
                 output,
                 outcome: "failed",
@@ -1486,7 +1414,6 @@ export class ReplayController {
         if (step) {
             this.recordStep(state, {
                 step,
-                entry,
                 input: pin.input,
                 output,
                 outcome: "executed",
@@ -1510,19 +1437,17 @@ export class ReplayController {
         return done;
     }
     /**
-     * A steer plan whose cursor reached its end: in front of a parked step (or a
-     * call the service could not answer), which hands over; otherwise it ran to
-     * its end — and from here every call is the model's own.
+     * A steer plan whose cursor reached its end: in front of a parked step,
+     * which hands over; otherwise it ran to its end — and from here every call
+     * is the model's own.
      */
     finishSteer(state, plan) {
         if (plan.atStop()) {
-            // Every planned step ran, and the next one is parked (fallbk.md D3) — or
-            // is a call the service could not answer (segmented.md R-CALL-29).
+            // Every planned step ran, and the next one is parked (fallbk.md D3).
             const parked = plan.stopStep();
             this.handOver(state, {
-                kind: this.stopKindOf(state, plan.stopEntry()),
+                kind: stopKindOf(parked),
                 step: parked,
-                entry: plan.stopEntry(),
                 position: plan.stepCount,
                 delivery: "above",
             });
@@ -1559,34 +1484,28 @@ export class ReplayController {
     settleCursor(state, plan, delivery) {
         if (!plan.hasTests())
             return "ready";
-        // Never throws: a sub-task whose results cannot go back after its last
-        // step was left out is a stop like any other (`result_map`).
         const settled = plan.settleTests(this.observeStep(state));
         // The recorded outputs of the steps left out are passed over, so a
         // divergence's bundle later stands each step's own in (source-run.ts).
         const source = state.sourceRun;
         if (source) {
             for (const l of settled.left) {
-                for (let i = l.flatIndex; i < l.until; i += 1) {
-                    const entry = plan.allEntries()[i];
-                    if (entry)
-                        source.leftOut(entry);
-                }
+                const step = plan.allSteps()[l.position];
+                if (step)
+                    source.leftOut(step);
             }
         }
         if (settled.stop) {
             const stop = settled.stop;
-            const position = stop.flatIndex ?? plan.currentStepIndex;
+            const position = stop.position ?? plan.currentStepIndex;
             this.handOver(state, {
                 kind: stop.kind,
                 step: plan.allSteps()[position],
-                entry: plan.allEntries()[position],
                 position,
                 error: stop.error,
                 delivery,
                 stopReason: stop.reason,
                 whenText: stop.whenText,
-                subTask: stop.subTask,
             });
             return "stopped";
         }
@@ -1599,7 +1518,6 @@ export class ReplayController {
             this.handOver(state, {
                 kind: "other_branch",
                 step: plan.allSteps()[0],
-                entry: plan.allEntries()[0],
                 position: 0,
                 delivery,
                 noneNeeded: true,
@@ -1608,9 +1526,8 @@ export class ReplayController {
         }
         state.skipNote = {
             text: this.skipNoteText(state, plan, settled.left),
-            // Every tool of a sub-task left out whole, not its call's intent: a call
-            // the model makes to any of them is one to a step left out.
-            tools: new Set(settled.left.flatMap((l) => (l.tools.length > 0 ? l.tools : [l.toolName]))),
+            // A call the model makes to any of these tools is one to a step left out.
+            tools: new Set(settled.left.map((l) => l.toolName)),
             delivered: false,
             complete: plan.isDone() && !plan.atStop(),
         };
@@ -1618,20 +1535,19 @@ export class ReplayController {
     }
     /** What the model is told about steps a test left out (AC5). */
     skipNoteText(state, plan, left) {
-        const named = left.map((l) => `step ${l.flatIndex + 1} (${l.toolName})`);
+        const named = left.map((l) => `step ${l.position + 1} (${l.toolName})`);
         const texts = [...new Set(left.map((l) => l.text).filter((t) => !!t))];
         const why = texts.length === 1 ? ` — only for when ${texts[0]}` : "";
         const what = left.length === 1 ? `Not needed for this request: ${named[0]}${why}.` : `Not needed for this request: ${named.join(", ")}${why}.`;
         let next;
         if (plan.isDone() && !plan.atStop()) {
-            next =
-                state.armedBy === "intent"
-                    ? "The sequence is complete: continue your task, calling tools as needed."
-                    : "The sequence is complete: answer the user's request from the tool results.";
+            next = isSubTask(state)
+                ? "The sequence is complete: continue your task, calling tools as needed."
+                : "The sequence is complete: answer the user's request from the tool results.";
         }
         else {
-            const entry = plan.currentEntry();
-            next = `Leave ${left.length === 1 ? "it" : "them"} out, and call step ${plan.currentStepIndex + 1}${entry?.step.toolName ? ` (${entry.step.toolName})` : ""} next.`;
+            const step = plan.currentStep();
+            next = `Leave ${left.length === 1 ? "it" : "them"} out, and call step ${plan.currentStepIndex + 1}${step?.toolName ? ` (${step.toolName})` : ""} next.`;
         }
         return `[BaseInstRunner calculated replay] ${what} ${next}`;
     }
@@ -1693,7 +1609,7 @@ export class ReplayController {
             return;
         if (how.hostStop) {
             // The host stopped it: neither a failure nor work the plan did.
-            this.hostStopped(state, pin, step, plan.allEntries()[pin.stepIndex], output, how.hostStop);
+            this.hostStopped(state, pin, step, output, how.hostStop);
             return;
         }
         const ms = Date.now() - pin.pinnedAt;
@@ -1705,11 +1621,9 @@ export class ReplayController {
                 ? `${failure.error} — it was sent, and may or may not have completed`
                 : failure.error
             : toolResultError(output);
-        const entry = plan.allEntries()[pin.stepIndex];
         if (error !== undefined) {
             const info = {
                 step,
-                entry,
                 input: pin.input,
                 output: answerOf(output),
                 outcome: "failed",
@@ -1721,7 +1635,7 @@ export class ReplayController {
             this.recordStep(state, info);
             return;
         }
-        this.recordStep(state, { step, entry, input: pin.input, output, outcome: "executed", ms });
+        this.recordStep(state, { step, input: pin.input, output, outcome: "executed", ms });
         state.stepsPinned += 1;
         this.upgrade(state, "fell_back");
         logDetail("replay.thread_late", {
@@ -1736,7 +1650,7 @@ export class ReplayController {
      * `failed`: the service counts failures against the plan. And not counted
      * in `stepsPinned`: the plan's own call did not run.
      */
-    hostStopped(state, pin, step, entry, output, stop) {
+    hostStopped(state, pin, step, output, stop) {
         const edited = stop === "edited";
         // After `rejected` nothing later can change what the report may claim.
         if (state.hostStop !== "rejected")
@@ -1752,7 +1666,6 @@ export class ReplayController {
         });
         this.recordStep(state, {
             step,
-            entry,
             // The plan's own arguments are what a refused call was asked with; a
             // changed call ran with other ones, which only the host knows.
             input: edited ? undefined : pin.input,
@@ -1829,7 +1742,6 @@ export class ReplayController {
             if (step && ready.blame) {
                 this.recordStep(state, {
                     step,
-                    entry: plan.currentEntry(),
                     outcome: "failed",
                     stage: ready.stage,
                     error: ready.error,
@@ -1838,7 +1750,6 @@ export class ReplayController {
             this.handOver(state, {
                 kind: "step_failed",
                 step,
-                entry: plan.currentEntry(),
                 position: plan.currentStepIndex,
                 error: ready.error,
                 delivery: "none",
@@ -1872,7 +1783,7 @@ export class ReplayController {
             // them alone is a baseline sample, not a hand-over "saving".
             const ranOk = result.executed - result.errored;
             state.stepsPinned += Math.max(0, ranOk);
-            const position = stop.flatIndex ?? plan.stepCount;
+            const position = stop.position ?? plan.stepCount;
             const step = plan.allSteps()[position];
             // Cut short by the clock, nothing failed: the steps that ran did their
             // work and none is blamed. A divergence for the ledger — a partial
@@ -1890,11 +1801,10 @@ export class ReplayController {
             const live = result.executed > 0;
             this.handOver(state, {
                 // The plan only knows it stopped in front of its end; which kind of
-                // stop that is — parked, a judgement, a call that cannot run — is
-                // decided here, where the served reasons are.
-                kind: stop.kind === "known_bad_step" ? this.stopKindOf(state, plan.stopEntry()) : stop.kind,
+                // stop that is — parked, or a judgement — is decided here, where the
+                // served reasons are.
+                kind: stop.kind === "known_bad_step" ? stopKindOf(plan.stopStep()) : stop.kind,
                 step,
-                entry: plan.allEntries()[position],
                 position,
                 error: stop.error,
                 // A cancelled run's note is kept for the model's next call, alone —
@@ -1905,12 +1815,9 @@ export class ReplayController {
                 ran: live ? undefined : 0,
                 // An output-logic failure stops *after* its step's tool ran: the step
                 // is done, its result is in the bundle, and it must not be run again.
-                // Not a sub-task's result mapping after its last step was left out
-                // (`result_map`): that step did not run (AC5).
-                ranThisStep: stop.stage === "tool_output_logic" && stop.reason !== "result_map",
+                ranThisStep: stop.stage === "tool_output_logic",
                 // The other half (AC5): what the steps from here are for.
                 whenText: stop.whenText,
-                subTask: stop.subTask,
             });
             if (stop.reason === "cancelled") {
                 // The caller is gone and reads nothing. The note stays undelivered: a
@@ -1947,7 +1854,6 @@ export class ReplayController {
             this.handOver(state, {
                 kind: "other_branch",
                 step: plan.allSteps()[0],
-                entry: plan.allEntries()[0],
                 position: 0,
                 delivery: "none",
                 ran: 0,
@@ -1962,7 +1868,6 @@ export class ReplayController {
             this.handOver(state, {
                 kind: "step_failed",
                 step: plan.allSteps()[0],
-                entry: plan.allEntries()[0],
                 position: 0,
                 error: "none of the scenario's steps could run here",
                 delivery: "none",
@@ -2026,23 +1931,20 @@ export class ReplayController {
         if (state.reported || !state.scenarioId)
             return undefined;
         state.reported = true;
-        const total = state.deriveCostUsd + d.sessionCostUsd + state.fallbackCostUsd;
+        const deriveCostUsd = state.deriveCostUsd + Math.max(0, d.chainDeriveUsd ?? 0);
+        const total = deriveCostUsd + d.sessionCostUsd + state.fallbackCostUsd;
         const steps = this.stepResultsOf(state);
         const isBaseline = state.outcome === "not_steered" || state.outcome === "failed";
-        // The plan handed the task back by design, not by a fault: in front of the
-        // other half of an "if … otherwise" (AC5), or at its decision (the
-        // service's segmentsbreakdown.md SB-19). Such a stop is named whatever the
-        // outcome, and the agent's work after it is the service's evidence.
-        const handedBack = state.handover?.kind === "other_branch" || state.handover?.kind === "decision";
         // A costless decline is noise on both sides — *unless* it says something the
         // recording page cannot learn any other way: a step that actually broke, the
-        // gate that declined, or a plan that handed the task back by design. The
-        // service accepts a costless report that carries any of them (its
-        // errorshandling.md).
+        // gate that declined, or a plan that stood in front of the other half of
+        // its task (AC5), which the service takes the agent's work after as its
+        // evidence of that half. The service accepts a costless report that carries
+        // any of them (its errorshandling.md).
         if (isBaseline &&
             total <= 0 &&
             !state.declined &&
-            !handedBack &&
+            state.handover?.kind !== "other_branch" &&
             !steps?.some((s) => s.status === "failed")) {
             return undefined;
         }
@@ -2052,7 +1954,7 @@ export class ReplayController {
             runId: d.runId,
             ticket: state.ticket,
             outcome: state.outcome,
-            deriveCostUsd: state.deriveCostUsd,
+            deriveCostUsd,
             sessionCostUsd: d.sessionCostUsd,
             fallbackCostUsd: state.fallbackCostUsd,
             durationMs: d.durationMs,
@@ -2083,22 +1985,21 @@ export class ReplayController {
             declined: state.declined,
             // Where the plan handed the task to the model (fallbk.md). Only on
             // `fell_back`: a hand-over before any step ran is `failed`, and a parked
-            // step found after a divergence is still a divergence. Except a plan
-            // that handed the task back by design — the other half of an "if …
-            // otherwise" (AC5), or its decision (SB-19) — named whatever the
-            // outcome: the agent's work after it is the service's evidence, whether
+            // step found after a divergence is still a divergence. Except the other
+            // half of an "if … otherwise" (AC5), named whatever the outcome: the
+            // agent's work after it is the service's evidence of that half, whether
             // or not a step ran first.
-            fallbackStepIndex: state.outcome === "fell_back" || handedBack
+            fallbackStepIndex: state.outcome === "fell_back" || state.handover?.kind === "other_branch"
                 ? state.handover?.stepIndex
                 : undefined,
-            fallbackKind: state.outcome === "fell_back" || handedBack
+            fallbackKind: state.outcome === "fell_back" || state.handover?.kind === "other_branch"
                 ? state.handover?.kind
                 : undefined,
             // The agent did not take the plan's result and redid the task (AC1).
             ...(d.redoneBy ? { redoneBy: d.redoneBy } : {}),
-            // Segments of this plan's recording that armed later in the turn
-            // (segmented.md R-MONEY-4): their share comes off this plan's baseline.
-            sharedWith: state.sharedWith.length > 0 ? [...state.sharedWith] : undefined,
+            // A continuation (the service's fallbk.md Part 3): the plan it continued
+            // books the whole turn, so this report books no saving of its own.
+            ...(state.continuation ? { continues: { scenarioId: state.continuation.ofScenarioId } } : {}),
             // A turn in which another plan ran is not a measurement of what this task
             // costs unaided, so it is no baseline sample (segmented.md R-MONEY-5).
             // This covers two plans that both armed, and — the case that was silently
@@ -2142,26 +2043,11 @@ export class ReplayController {
      * there is nothing to be similar *to* and nothing to decline. It books no
      * execution either — there is no ticket, and inventing a saving for a manual
      * invocation is exactly the kind of number a ledger must never contain.
-     *
-     * One served stop is kept: a plan's decision (the service's
-     * segmentsbreakdown.md SB-6). The run stops in front of it, and `stopped`
-     * says so with the reason `decision`.
      */
     async runAdHoc(scenario, prompt, wrapped) {
         if (!isReadyScenario(scenario))
             return { ok: false, why: "scenario is not ready" };
-        // A chain with calls is run by hand the same way it is run by a match: one
-        // flat list, one frame per call (segmented.md R-CALL-37).
-        let flat;
-        try {
-            flat = flattenChain(scenario);
-        }
-        catch (err) {
-            return { ok: false, why: `the chain could not be flattened: ${errText(err)}` };
-        }
-        if (flat.entries.length === 0)
-            return { ok: false, why: "the chain has no runnable step" };
-        const mode = modeFor(flat.entries.map((e) => e.step), wrapped, this.opts.allowServers, this.builtinTools);
+        const mode = modeFor(scenario.steps, wrapped, this.opts.allowServers, this.builtinTools);
         if (mode === "none")
             return { ok: false, why: "no step is executable" };
         const state = {
@@ -2183,15 +2069,11 @@ export class ReplayController {
             reported: true,
             retired: false,
             armedBy: "prompt",
-            // `bir replay` runs a scenario an operator named by id: never a segment
-            // hand-out, and nothing to share a baseline with.
-            kind: "scenario",
-            sharedWith: [],
         };
-        // `bir replay` keeps its own contract on a missing target (segmented.md
-        // R-CALL-37): an operator asked for this run by id, so a sample stands in
-        // and it never declines. It says which, as the console's dry replay does
-        // (R-PARAM-7), so nobody reads the output as proof the values were derived.
+        // `bir replay` keeps its own contract on a missing target: an operator
+        // asked for this run by id, so a sample stands in and it never declines.
+        // It says which, as the console's dry replay does (R-PARAM-7), so nobody
+        // reads the output as proof the values were derived.
         const schema = scenario.paramsObject ?? {};
         const params = this.startDerivation(scenario, prompt, state).then((r) => {
             const out = { ...r.params };
@@ -2210,25 +2092,13 @@ export class ReplayController {
             }
             return out;
         });
-        // The one served stop an operator's run keeps: a decision (the service's
-        // segmentsbreakdown.md SB-6). The steps after it are one half of an "if …
-        // otherwise", the half the recording took, and running them by id would
-        // do that half's writes whatever the request. Every other served stop is
-        // the plan's health, which an operator's run is there to try.
-        const decisionAt = flat.entries.findIndex((e) => e.step.stop?.kind === "decision");
-        const stopAt = decisionAt >= 0 && (flat.stopAt === undefined || decisionAt < flat.stopAt)
-            ? clampToFrameStart(flat.entries, decisionAt)
-            : flat.stopAt;
         const plan = new ScenarioReplayPlan({
             scenario,
             params,
             mode,
-            entries: flat.entries,
-            stopAt,
             fallbackTargets: "samples",
         });
         state.plan = plan;
-        state.flatStop = stopAt === flat.stopAt ? flat.stopReason : undefined;
         if (this.opts.authUrl && this.opts.authToken) {
             state.sourceRun = new SourceRunOutputs({
                 baseUrl: this.opts.authUrl,
@@ -2244,8 +2114,8 @@ export class ReplayController {
             coverage: coverageOf(scenario.steps, wrapped, this.opts.allowServers, this.builtinTools).join(","),
             why: "bir replay — no match, an operator asked for it",
         });
-        // An operator's run keeps its own contract (R-CALL-37): out of time, the
-        // targets too take their samples. What it never does is run on `{}`.
+        // An operator's run keeps its own contract: out of time, the targets too
+        // take their samples. What it never does is run on `{}`.
         const ready = await this.readyFor(state, plan, this.adHocBudgets.deriveMs, { adHoc: true });
         if (!ready.ok)
             return { ok: false, why: ready.error };
@@ -2274,16 +2144,7 @@ export class ReplayController {
                 logDetail("replay.response_model_failed", { error: errText(err) });
             }
             const stop = result.stopped;
-            const stoppedStep = stop ? plan.allSteps()[stop.flatIndex ?? plan.stepCount] : undefined;
-            // The plan's end in front of its decision: said so, by its own word.
-            const atDecision = stop?.kind === "known_bad_step" && stoppedStep?.stop?.kind === "decision";
-            if (atDecision) {
-                logLine("replay.adhoc_decision", {
-                    scenario: scenario.id,
-                    step: stop.stepIndex,
-                    why: "bir replay stops in front of the plan's decision: the steps after it are the half the recording took",
-                });
-            }
+            const stoppedStep = stop ? plan.allSteps()[stop.position ?? plan.stepCount] : undefined;
             return {
                 ok: true,
                 text: result.text,
@@ -2295,7 +2156,7 @@ export class ReplayController {
                     ? {
                         step: stop.stepIndex,
                         tool: stoppedStep?.toolName ?? "",
-                        reason: atDecision ? "decision" : (stop.reason ?? stop.stage ?? stop.kind),
+                        reason: stop.reason ?? stop.stage ?? stop.kind,
                         error: stop.error,
                     }
                     : undefined,
@@ -2358,8 +2219,6 @@ export class ReplayController {
             fetchImpl: this.opts.fetchImpl,
             liveCall: ctx.liveCall,
             recentResults: ctx.recentResults,
-            // A reading for a scenario that follows a plan's decision (offer1.md O4).
-            ...(ctx.atDecision ? { atDecision: ctx.atDecision } : {}),
             // The request itself ends too. Without this a hung service or model held
             // the socket for up to 300 s after every wait on it had given up. Long
             // enough to cover both waits that can use its answer (the arm and the
@@ -2492,16 +2351,7 @@ export class ReplayController {
         // when a step did its work — so the service takes the agent's work after
         // it as that half's evidence. Booked `diverged`, it never did.
         const otherHalf = stop?.kind === "other_branch";
-        // A bundle that ran up to the plan's decision and stopped there (the
-        // service's segmentsbreakdown.md SB-17) is a hand-over too: the plan did
-        // all it was for, and the agent decides. Not one of recorded outputs
-        // only, which is no step done here — that stays a plain divergence.
-        const atDecision = !stop &&
-            plan.stopsEarly() &&
-            composed.endedAt === plan.stepCount &&
-            (composed.executed > 0 || composed.recorded === 0) &&
-            this.stopKindOf(state, plan.stopEntry()) === "decision";
-        this.upgrade(state, broke || !didWork ? "failed" : otherHalf || atDecision ? "fell_back" : "diverged");
+        this.upgrade(state, broke || !didWork ? "failed" : otherHalf ? "fell_back" : "diverged");
         state.stepsPinned += composed.executed;
         // The headline number of this whole design: recovering from a divergence
         // costs nothing, because the proxies were already connected.
@@ -2512,7 +2362,7 @@ export class ReplayController {
             recorded: composed.recorded,
             skipped: composed.skipped,
             errored: composed.errored || undefined,
-            stopped: stop ? `${stop.flatIndex ?? "?"}:${stop.reason ?? stop.stage ?? stop.kind}` : undefined,
+            stopped: stop ? `${stop.position ?? "?"}:${stop.reason ?? stop.stage ?? stop.kind}` : undefined,
             bytes: composed.text.length,
             costUsd: state.fallbackCostUsd.toFixed(2),
         });
@@ -2528,40 +2378,16 @@ export class ReplayController {
             // of recorded outputs only is last week's work. The model's own call goes
             // ahead — unless a step was *sent* and never answered. That one may have
             // done its work, and the model must know before it does the task itself.
-            if (stop?.reason === "uncertain" && stop.flatIndex !== undefined) {
+            if (stop?.reason === "uncertain" && stop.position !== undefined) {
                 const note = this.stopNote(state, plan, stop, "none", composed.left);
                 return this.deliverInstead(note, toolName, state.host !== undefined);
             }
             // The rest is the other half (AC5): the model is told so, in place of
             // its call, before it does any of the plan's remaining steps.
-            if (stop?.kind === "other_branch" && stop.flatIndex !== undefined) {
+            if (stop?.kind === "other_branch" && stop.position !== undefined) {
                 const note = this.stopNote(state, plan, stop, "none", composed.left);
                 return this.deliverInstead(note, toolName, state.host !== undefined);
             }
-            // Every step left before the decision was one this request does not
-            // need: the plan has done its part, and the agent decides. Told in
-            // place of its call, like the other half. The steps that ran are the
-            // model's own calls above; the ones left out are named.
-            if (atDecision) {
-                const parked = plan.stopStep();
-                state.handover = {
-                    kind: "decision",
-                    stepIndex: callerStepIndexOf(plan.stopEntry()) ?? parked.stepIndex,
-                    toolName: parked.toolName ?? undefined,
-                    note: this.noteFor(state, {
-                        kind: "decision",
-                        step: parked,
-                        entry: plan.stopEntry(),
-                        position: plan.stepCount,
-                        delivery: "above",
-                        executedAbove: plan.currentStepIndex,
-                        leftOut: composed.left,
-                    }),
-                    delivered: true,
-                };
-                this.decidedInDivergence(state, plan);
-                return this.deliverInstead(state.handover.note, toolName, state.host !== undefined);
-            }
             // Every remaining step was left out by its test: the steps the session
             // ran were the whole of the plan this request needs, and it ran to its
             // end (newestRun.md N7 reads that).
@@ -2576,13 +2402,13 @@ export class ReplayController {
         // outcome stays as judged above, so the report carries no fallback fields
         // (the other half of an "if … otherwise" excepted: see `buildReport`).
         let text = composed.text;
-        if (stop && (stop.kind === "step_failed" || stop.kind === "other_branch") && stop.flatIndex !== undefined) {
+        if (stop && (stop.kind === "step_failed" || stop.kind === "other_branch") && stop.position !== undefined) {
             const note = this.stopNote(state, plan, stop, "below", composed.left);
             text = `${note}\n\n${composed.text}`;
         }
         else if (plan.stopsEarly() && composed.endedAt === plan.stepCount) {
             const parked = plan.stopStep();
-            const stopKind = this.stopKindOf(state, plan.stopEntry());
+            const stopKind = stopKindOf(parked);
             state.handover = {
                 kind: stopKind,
                 stepIndex: parked.stepIndex,
@@ -2590,7 +2416,6 @@ export class ReplayController {
                 note: this.noteFor(state, {
                     kind: stopKind,
                     step: parked,
-                    entry: plan.stopEntry(),
                     position: plan.stepCount,
                     delivery: "below",
                     executedAbove: plan.currentStepIndex,
@@ -2600,8 +2425,6 @@ export class ReplayController {
                 delivered: true,
             };
             text = `${state.handover.note}\n\n${composed.text}`;
-            if (atDecision)
-                this.decidedInDivergence(state, plan);
         }
         else if (!stop) {
             // The bundle carries the rest of the chain, and its header tells the
@@ -2623,13 +2446,11 @@ export class ReplayController {
     stopNote(state, plan, stop, delivery, 
     /** The steps the bundle left out (AC5): no step that ran. */
     left = []) {
-        const position = stop.flatIndex ?? plan.currentStepIndex;
+        const position = stop.position ?? plan.currentStepIndex;
         const step = plan.allSteps()[position];
-        const entry = plan.allEntries()[position];
         const note = this.noteFor(state, {
             kind: stop.kind,
             step,
-            entry,
             position,
             error: stop.error,
             delivery,
@@ -2639,16 +2460,14 @@ export class ReplayController {
             // steps that ran; "no step ran" would invite the model to run them again.
             ran: delivery === "none" ? plan.currentStepIndex : undefined,
             executedAbove: plan.currentStepIndex,
-            // An output-logic failure stops after its step's tool ran (plan.ts) —
-            // not a sub-task's result mapping after its last step was left out.
-            ranThisStep: stop.stage === "tool_output_logic" && stop.reason !== "result_map",
+            // An output-logic failure stops after its step's tool ran (plan.ts).
+            ranThisStep: stop.stage === "tool_output_logic",
             whenText: stop.whenText,
-            subTask: stop.subTask,
             leftOut: left,
         });
         state.handover ??= {
             kind: stop.kind,
-            stepIndex: callerStepIndexOf(entry) ?? step?.stepIndex ?? position,
+            stepIndex: step?.stepIndex ?? position,
             toolName: step?.toolName ?? undefined,
             error: stop.error,
             note,
@@ -2669,17 +2488,9 @@ export class ReplayController {
             return;
         const ran = state.stepsPinned;
         this.retire(state, ran > 0 ? "fell_back" : "failed");
-        // A plan stopped at its decision did all it was for: its bill ends here,
-        // and the agent's decision and the half it takes are the agent's own
-        // (the service's segmentsbreakdown.md SB-26). Only once a step ran: a
-        // plan that did nothing is a baseline sample of the whole turn.
-        if (h.kind === "decision" && ran > 0)
-            this.markRetired(state);
         state.handover = {
             kind: h.kind,
-            // The *caller's* index: a fragment opens at the call row, not at a step
-            // number the caller's own chain does not have (R-CALL-32, R-FALL-7).
-            stepIndex: callerStepIndexOf(h.entry) ?? h.step?.stepIndex ?? h.position,
+            stepIndex: h.step?.stepIndex ?? h.position,
             toolName: h.step?.toolName ?? undefined,
             error: h.error,
             note: this.noteFor(state, h),
@@ -2690,83 +2501,38 @@ export class ReplayController {
             kind: h.kind,
             step: `${h.position}/${state.plan?.totalSteps ?? state.stepsPlanned}`,
             tool: h.step?.toolName ?? undefined,
-            // The scenario that owns the stopped step, when it is not the matched one.
-            owner: h.entry && h.entry.depth > 0 ? h.entry.scenarioId : undefined,
-            unusable: state.flatStop?.reason,
-            callIntent: state.flatStop?.callIntent ?? undefined,
-            segment: state.flatStop?.segmentId ?? undefined,
             ran,
             outcome: state.outcome,
             why: h.kind === "other_branch"
                 ? h.noneNeeded
                     ? "no step of the plan was needed for this request — the agent does the task"
                     : `this request is the other half: the steps from here are only for when ${h.whenText ?? "their test says so"} — the agent continues`
-                : h.kind === "decision"
-                    ? "the plan ran the steps before its decision — the agent decides which way applies and continues"
-                    : h.kind === "unusable_call"
-                        ? "a sub-task of this chain cannot run — the agent does that part itself"
-                        : h.kind === "known_bad_step"
-                            ? "the next step has failed too often — the agent continues from here"
-                            : h.kind === "nondeterministic_step"
-                                ? "the next step needs a judgement the plan cannot compute — the agent makes it"
-                                : h.stopReason === "concurrent"
-                                    ? "a second call arrived while the pinned step was still running — the agent continues from here"
-                                    : h.stopReason === "budget" || h.stopReason === "cancelled"
-                                        ? "the run was cut short before this step — the agent continues from here"
-                                        : h.stopReason === "host_rejected" || h.stopReason === "host_edited"
-                                            ? "the host stopped this step itself — no fault of the plan; the agent continues from here"
-                                            : h.stopReason === "not_run" || h.stopReason === "uncertain"
-                                                ? "a step produced no result here — the agent continues from here"
-                                                : "a step broke — the agent continues from here",
-        });
-    }
-    /**
-     * Which kind of stop a plan's end is (plan-services.md D8). The stopping
-     * step's own served reason wins — the calculation's verdict is more exact
-     * than a counter — then a call the service could not answer, then a parked
-     * step.
-     */
-    stopKindOf(state, entry) {
-        // The service serves a decision ahead of any other stop of its step
-        // (the service's segmentsbreakdown.md SB-6), and so it is read first.
-        if (entry?.step.stop?.kind === "decision")
-            return "decision";
-        if (entry?.step.stop?.kind === "nondeterministic")
-            return "nondeterministic_step";
-        return state.flatStop ? "unusable_call" : "known_bad_step";
-    }
-    /**
-     * A divergence's bundle that ended at the plan's decision (SB-17): logged
-     * as `handOver` logs every other hand-over, and its usage mark taken there
-     * when a step of the plan ran (SB-26).
-     */
-    decidedInDivergence(state, plan) {
-        if (state.stepsPinned > 0)
-            this.markRetired(state);
-        logLine("replay.handover", {
-            scenario: state.scenarioId ?? undefined,
-            kind: "decision",
-            step: `${plan.stepCount}/${plan.totalSteps}`,
-            via: "divergence",
-            ran: state.stepsPinned,
-            outcome: state.outcome,
-            why: "the plan ran the steps before its decision — the agent decides which way applies and continues",
+                : h.kind === "known_bad_step"
+                    ? "the next step has failed too often — the agent continues from here"
+                    : h.kind === "nondeterministic_step"
+                        ? "the next step needs a judgement the plan cannot compute — the agent makes it"
+                        : h.stopReason === "concurrent"
+                            ? "a second call arrived while the pinned step was still running — the agent continues from here"
+                            : h.stopReason === "budget" || h.stopReason === "cancelled"
+                                ? "the run was cut short before this step — the agent continues from here"
+                                : h.stopReason === "host_rejected" || h.stopReason === "host_edited"
+                                    ? "the host stopped this step itself — no fault of the plan; the agent continues from here"
+                                    : h.stopReason === "not_run" || h.stopReason === "uncertain"
+                                        ? "a step produced no result here — the agent continues from here"
+                                        : "a step broke — the agent continues from here",
         });
     }
     /**
-     * The steps before flat position `bound` that ran, 1-based, and the ones
-     * their tests left out (AC5) — the plan cursor's own, and a divergence
-     * bundle's (`extra`). `left` is empty when no step was left out; `ran` is
-     * then not filled, since every step before `bound` ran.
+     * The steps before position `bound` that ran, 1-based, and the ones their
+     * tests left out (AC5) — the plan cursor's own, and a divergence bundle's
+     * (`extra`). `left` is empty when no step was left out; `ran` is then not
+     * filled, since every step before `bound` ran.
      */
     ranBefore(plan, bound, extra = []) {
-        const left = [...(plan?.leftOut() ?? []), ...extra].filter((l) => l.flatIndex < bound);
+        const left = [...(plan?.leftOut() ?? []), ...extra].filter((l) => l.position < bound);
         if (left.length === 0)
             return { ran: [], left };
-        const out = new Set();
-        for (const l of left)
-            for (let i = l.flatIndex; i < Math.min(l.until, bound); i += 1)
-                out.add(i);
+        const out = new Set(left.map((l) => l.position));
         const ran = [];
         for (let i = 0; i < bound; i += 1)
             if (!out.has(i))
@@ -2777,8 +2543,7 @@ export class ReplayController {
         const plan = state.plan;
         // The steps before the stop — or the bound a caller gives — less the ones
         // their tests left out (AC5): a note must never say a step ran that did not.
-        // A `result_map` stop rests on the step left out, which is then named so.
-        const bound = h.ran ?? (h.ranThisStep || h.stopReason === "result_map" ? h.position + 1 : h.position);
+        const bound = h.ran ?? (h.ranThisStep ? h.position + 1 : h.position);
         const before = this.ranBefore(plan, bound, h.leftOut);
         const skipped = before.left.length > 0;
         const executed = skipped ? before.ran.length : bound;
@@ -2787,50 +2552,31 @@ export class ReplayController {
             : before.ran.filter((n) => n <= h.executedAbove).length;
         // A step its host stopped was dealt with there — refused, answered, or
         // run with a person's arguments — so it is not among what is left to do.
-        // Nor is the step a test left out, after which a sub-task's results could
-        // not go back (`result_map`, AC5).
         const handled = h.ranThisStep === true ||
             h.stopReason === "host_rejected" ||
-            h.stopReason === "host_edited" ||
-            h.stopReason === "result_map";
-        // A chain that holds a decision (the service's segmentsbreakdown.md SB-18)
-        // keeps the decision note's protections in every note, even when the plan
-        // stops earlier for another reason: no intent, no parameters, and no step
-        // from the decision on. Each points at the half the recording took, and an
-        // agent that follows it there runs that half's segment: the plan decided.
-        const decisionAt = plan ? plan.decisionIndex() : -1;
+            h.stopReason === "host_edited";
         let params;
         try {
-            params = decisionAt >= 0 ? undefined : plan?.parameters;
+            params = plan?.parameters;
         }
         catch {
             params = undefined;
         }
         return buildHandoverNote({
-            intent: decisionAt >= 0 ? "" : (plan?.intent ?? ""),
+            intent: plan?.intent ?? "",
             kind: h.kind,
             stepIndex: h.position,
             stepToolName: h.step?.toolName ?? undefined,
             failureCount: h.step?.failureCount,
             error: h.error,
             stopReason: h.stopReason,
-            unusable: state.flatStop
-                ? {
-                    reason: state.flatStop.reason,
-                    callIntent: state.flatStop.callIntent,
-                    segmentId: state.flatStop.segmentId,
-                    ownerScenarioId: state.flatStop.scenarioId,
-                }
-                : undefined,
-            ownerScenarioId: h.entry && h.entry.depth > 0 ? h.entry.scenarioId : undefined,
-            inSubTask: h.entry && h.entry.depth > 0 ? (h.entry.frame.callIntent ?? null) : null,
             executed: Math.max(0, Math.min(executed, plan?.totalSteps ?? executed)),
             ...(skipped
                 ? {
                     ranSteps: before.ran,
                     leftOut: before.left.map((l) => ({
-                        from: l.flatIndex + 1,
-                        to: Math.min(l.until, bound),
+                        from: l.position + 1,
+                        to: l.position + 1,
                         toolName: l.toolName,
                         text: l.text,
                     })),
@@ -2842,17 +2588,12 @@ export class ReplayController {
             totalSteps: plan?.totalSteps ?? state.stepsPlanned,
             // A step that runs only under a test is marked so: the list must not
             // read as steps this request needs (AC5).
-            remainingTools: plan
-                ? plan.remainingFrom(handled ? h.position + 1 : h.position, decisionAt >= 0 ? decisionAt : undefined)
-                : [],
+            remainingTools: plan ? plan.remainingFrom(handled ? h.position + 1 : h.position) : [],
             params,
             delivery: h.delivery,
             whenText: h.whenText ?? null,
-            subTask: h.subTask ?? null,
             // "None was needed" is the note's own wording for the end of the plan.
             ...(h.noneNeeded ? { stepIndex: plan?.totalSteps ?? state.stepsPlanned } : {}),
-            // The request's own words for the choice (SB-18); never the service's.
-            ...(h.kind === "decision" ? { request: state.request ?? null } : {}),
         });
     }
     /**
@@ -2991,8 +2732,8 @@ export class ReplayController {
             return undefined;
         // A step a test left out passes over its recorded output, unless a
         // correction added it (AC5, source-run.ts).
-        return Object.assign((entry) => source.outputFor(entry), {
-            leftOut: (entry) => source.leftOut(entry),
+        return Object.assign((step) => source.outputFor(step), {
+            leftOut: (step) => source.leftOut(step),
         });
     }
     /**
@@ -3071,7 +2812,7 @@ export class ReplayController {
                 }
                 if (!opts.adHoc) {
                     const schema = plan.paramsSchema;
-                    const planned = plan.allEntries().slice(0, plan.stepCount);
+                    const planned = plan.allSteps().slice(0, plan.stepCount);
                     const blocked = blockingTargets(targetKeys(schema), schema, planned, plan.paramsLogic);
                     if (blocked.length > 0) {
                         return {
@@ -3088,7 +2829,7 @@ export class ReplayController {
         const missingAgain = state.rederivedMissing;
         state.rederivedMissing = undefined;
         if (missingAgain && !opts.adHoc) {
-            const planned = plan.allEntries().slice(0, plan.stepCount);
+            const planned = plan.allSteps().slice(0, plan.stepCount);
             const blocked = blockingTargets(missingAgain, plan.paramsSchema, planned, plan.paramsLogic);
             if (blocked.length > 0) {
                 return {
@@ -3101,7 +2842,7 @@ export class ReplayController {
         }
         const sink = opts.adHoc
             ? undefined
-            : sinkOfPlan(plan.allEntries().slice(0, plan.stepCount), state.host?.sinks);
+            : sinkOfPlan(plan.allSteps().slice(0, plan.stepCount), state.host?.sinks);
         if (sink) {
             const bad = unsafeParameter(plan.derivedValues, plan.paramsSchema, sink);
             if (bad) {
@@ -3200,12 +2941,7 @@ export class ReplayController {
      */
     recordStep(state, info) {
         const status = info.outcome === "executed" ? "ok" : info.outcome;
-        // Keyed by the *flat* position, not by the step's own index: two scenarios
-        // in one plan both have a step 0, and one would otherwise overwrite the
-        // other's verdict (segmented.md R-CALL-13).
-        const key = info.entry
-            ? `${info.entry.scenarioId}#${info.entry.stepIndex}`
-            : `#${info.step.stepIndex}`;
+        const key = `#${info.step.stepIndex}`;
         if (state.stepResults.size >= MAX_STEP_RESULTS && !state.stepResults.has(key)) {
             return;
         }
@@ -3214,29 +2950,19 @@ export class ReplayController {
                 ? `${info.error.slice(0, MAX_STEP_ERROR_CHARS)}…`
                 : info.error
             : undefined;
-        // Payloads only for a step of the reported scenario's own chain. The
-        // console still files an execution's verdicts by step number alone
-        // (plan-services.md W1.9), and a called segment numbers its steps from
-        // zero as well: a called step's call would be shown under the caller's
-        // step of the same number — the very mix-up the payloads are there to end.
-        const own = !info.entry || info.entry.depth === 0;
         // A step whose input logic threw never had an input: the `{}` the plan
         // reports there is a placeholder, not a call with no arguments. Nor had a
         // step its test left out or stopped in front of (AC5).
         const noCall = info.stage === "tool_input_logic" || info.stage === "when_logic" || status === "not_taken";
-        const sent = own && !noCall ? info.input : undefined;
-        const received = own && !noCall ? info.output : undefined;
+        const sent = !noCall ? info.input : undefined;
+        const received = !noCall ? info.output : undefined;
         // The call, kept whole for the turn's newest run (AC2): only one that
         // really went out — it answered, or it answered with an error.
         if (state.keepCalls &&
             !noCall &&
             info.input !== undefined &&
             (status === "ok" || (status === "failed" && info.stage === "tool_call"))) {
-            // By frame, not by scenario: a chain that calls the same sub-task twice
-            // makes two calls of each of its steps, and both are the turn's (AC5
-            // review). A frame is one call of one sub-task.
-            const callKey = info.entry ? `${info.entry.frame.id}#${info.entry.stepIndex}` : key;
-            this.keepCall(state, callKey, info, status === "failed");
+            this.keepCall(state, key, info, status === "failed");
         }
         state.stepResults.set(key, {
             stepIndex: info.step.stepIndex,
@@ -3252,10 +2978,6 @@ export class ReplayController {
             // The tool is gone from its server: the service repairs the plan without
             // waiting out the grace (plan-services.md D8, kind 2).
             toolMissing: info.toolMissing || undefined,
-            // A verdict about a called segment's step is counted on that segment, at
-            // the revision it was served (R-CALL-13).
-            scenarioId: info.entry && info.entry.depth > 0 ? info.entry.scenarioId : undefined,
-            chainRevision: info.entry && info.entry.depth > 0 ? info.entry.frame.chainRevision : undefined,
         });
     }
     /**
@@ -3274,14 +2996,11 @@ export class ReplayController {
             ? serializeCapped(redact(info.input ?? {}))
             : reportPayload(serializeCapped(redact(info.input ?? {})), true);
         const answer = info.output === undefined ? undefined : room ? heldPayload(info.output) : reportPayload(info.output);
-        const inSegment = info.entry && info.entry.depth > 0;
         const call = {
-            scenarioId: inSegment ? info.entry.scenarioId : (state.scenarioId ?? info.entry?.scenarioId ?? ""),
+            scenarioId: state.scenarioId ?? "",
             stepIndex: info.step.stepIndex,
-            chainRevision: inSegment
-                ? (info.entry.frame.chainRevision ?? null)
-                : (state.chainRevision ?? null),
-            toolName: info.step.toolName ?? "",
+            chainRevision: state.chainRevision ?? null,
+            toolName: info.step.toolName,
             input,
             ...(failed
                 ? { error: info.error ? capText(redactText(info.error), DEFAULT_MAX_PAYLOAD_BYTES) : answer }
@@ -3305,8 +3024,6 @@ export class ReplayController {
         if (info.outcome === "failed") {
             logLine("replay.step_failed", {
                 n: info.step.stepIndex,
-                scenario: info.entry && info.entry.depth > 0 ? info.entry.scenarioId : undefined,
-                frame: info.entry?.frame.id,
                 tool: info.step.toolName ?? undefined,
                 stage: info.stage,
                 why: info.stage === "tool_call"
@@ -3338,8 +3055,7 @@ export class ReplayController {
             const text = testWords(info.step.when?.text);
             logLine("replay.step_not_taken", {
                 n: info.step.stepIndex,
-                tool: info.step.toolName ?? info.step.callIntent ?? undefined,
-                scenario: info.entry && info.entry.depth > 0 ? info.entry.scenarioId : undefined,
+                tool: info.step.toolName,
                 why: `its test said this request does not need it${text ? ` — only for when ${text}` : ""}; left out, and the plan goes on`,
             });
             return;
@@ -3363,10 +3079,17 @@ export class ReplayController {
             this.upgrade(state, outcome);
         // Only a plan that *finished* stops the clock (segmented.md R-MONEY-3). A
         // hand-over or a divergence takes no mark: the agent's next tokens are the
-        // consequence of this plan stopping, and belong to its bill. (A decision
-        // hand-over takes one of its own: `markRetired`.)
-        if (completing)
-            this.markRetired(state);
+        // consequence of this plan stopping, and belong to its bill.
+        if (completing) {
+            state.retiredAt = Date.now();
+            try {
+                state.retiredMark = state.markUsage?.();
+            }
+            catch {
+                // An unreadable transcript leaves the mark undefined, and the window
+                // falls back to the next arm or the end of the turn.
+            }
+        }
         state.retired = true;
         state.pinned.clear();
         // A note naming a step to call next is void once the plan is: after a
@@ -3378,21 +3101,6 @@ export class ReplayController {
         // A call waiting for a pin to thread has nothing left to wait for.
         this.notifyPins(state);
     }
-    /**
-     * Where the plan's work ended, for its bill: now, and the transcript's
-     * watermark now. Taken at a completing retire, and at a decision hand-over
-     * after a step ran (the service's segmentsbreakdown.md SB-26).
-     */
-    markRetired(state) {
-        state.retiredAt = Date.now();
-        try {
-            state.retiredMark = state.markUsage?.();
-        }
-        catch {
-            // An unreadable transcript leaves the mark undefined, and the window
-            // falls back to the next arm or the end of the turn.
-        }
-    }
 }
 /** Every target of a schema. A parameter with no kind is one (R-PARAM-3). */
 function targetKeys(schema) {
@@ -3530,58 +3238,29 @@ function heldPayload(text) {
     }
     return capText(text, DEFAULT_MAX_PAYLOAD_BYTES, redactText);
 }
-/** Whether an entry runs only under a test (AC5): its own, or a sub-task's it is in. */
-function underTest(entry) {
-    if (entry.step.when)
-        return true;
-    for (let f = entry.frame; f; f = f.parent)
-        if (f.when)
-            return true;
-    return false;
+/** Whether a step runs only under a test (AC5). */
+function underTest(step) {
+    return Boolean(step.when);
 }
-/** The tests of a flat chain, by flat position, for the `plan.armed` line (AC5). */
-function testLines(entries) {
-    // A sub-task's test sits where the sub-task begins — at its callee's first
-    // step when its chain begins with a call.
-    const { startsAt } = frameEdges(entries);
-    const lines = entries
-        .map((e, i) => {
-        const own = e.step.when;
-        const call = (startsAt.get(i) ?? []).find((f) => f.when)?.when;
-        const t = own ?? call;
-        return t ? `${i}:${call && !own ? "call/" : ""}${t.otherwise}` : undefined;
-    })
+/** The tests of a chain, by position, for the `plan.armed` line (AC5). */
+function testLines(steps) {
+    const lines = steps
+        .map((s, i) => (s.when ? `${i}:${s.when.otherwise}` : undefined))
         .filter((s) => s !== undefined);
     return lines.length > 0 ? lines.join(",") : undefined;
 }
 /**
- * The index a hand-over reports, in the *caller's* chain (R-CALL-32).
- *
- * A step inside a called segment has no position in the caller's own chain; the
- * call row that opened its frame does. Reporting the segment's own index would
- * line the execution up against a step the caller's card does not have.
+ * Which kind of stop a plan's end is (plan-services.md D8): the stopping
+ * step's own served reason wins — the calculation's verdict is more exact
+ * than a counter — then a parked step.
  */
-function callerStepIndexOf(entry) {
-    if (!entry || entry.depth === 0)
-        return entry?.stepIndex;
-    let frame = entry.frame;
-    while (frame.parent && frame.depth > 1)
-        frame = frame.parent;
-    return frame.callerStepIndex;
-}
-/** The calls in a served chain, for the `plan.armed` line (R-CALL-32). */
-function callLines(scenario) {
-    const calls = (scenario.steps ?? []).filter((s) => s.kind === "segment");
-    if (calls.length === 0)
-        return undefined;
-    return calls
-        .map((s) => `${s.segmentId ?? "-"}:${s.unusable ?? s.resolution?.state ?? "resolved"}`)
-        .join(",");
+function stopKindOf(step) {
+    return step?.stop?.kind === "nondeterministic" ? "nondeterministic_step" : "known_bad_step";
 }
-/** The served stops in a flat chain, for the `plan.armed` line (plan-services.md D8). */
-function stopLines(entries) {
-    const lines = entries
-        .map((e, i) => e.step.stop ? `${i}:${e.step.stop.kind}${e.step.stop.repairDue ? "/repair" : ""}` : undefined)
+/** The served stops in a chain, for the `plan.armed` line (plan-services.md D8). */
+function stopLines(steps) {
+    const lines = steps
+        .map((s, i) => (s.stop ? `${i}:${s.stop.kind}${s.stop.repairDue ? "/repair" : ""}` : undefined))
         .filter((s) => s !== undefined);
     return lines.length > 0 ? lines.join(",") : undefined;
 }
@@ -3606,8 +3285,7 @@ function isKnownBad(step, maxStepFailures) {
  *
  * A step that carries `stop` was decided by the service — `null` means run it,
  * even when its count is past the limit: its retry is due. A step without the
- * field came from an older service, and the old counter rule decides it. Both
- * can sit in one chain, since a called segment is served on its own terms.
+ * field came from an older service, and the old counter rule decides it.
  */
 export function stopIndex(steps, maxStepFailures) {
     const i = steps.findIndex((s) => s.stop !== undefined ? s.stop !== null : isKnownBad(s, maxStepFailures));