@basein/runner 0.3.21 → 0.3.23

package/dist/control/server.js

@@ -30,19 +30,16 @@ import { join, resolve as resolvePath } from "node:path";
 import { BIR_CALL_ID, fingerprint, newCallId, parseQualifiedName, qualifyToolName, } from "./correlation.js";
 import { StepIndexAllocator } from "./ordering.js";
 import { pidAlive } from "./discovery.js";
-import { pinCompatible } from "./pin-guard.js";
+import { pinCompatible, sameFirstCall } from "./pin-guard.js";
 import { agentDayOf, contextForToolUse, intentForToolUse, markTranscriptUsage, recentToolResults, settledLastAssistantText, settledTextAfterToolUse, thinkingForToolUse, usageSince, } from "./transcript.js";
 import { isHousekeepingCall } from "../record/housekeeping.js";
 import { asSent, userText } from "../record/prompt-text.js";
 import { redact, redactText } from "../record/redact.js";
 import { DEFAULT_MAX_STRING_BYTES, serializeCapped, truncateString, truncateStrings, } from "../record/truncate.js";
 import { StepQueue } from "../record/queue.js";
-import { NullRecorder, isAttentionReader, isIntentMatcher, isMatchAware, isNextScenarioSource, isRecorderHealthReporter, isRunCreationAware, isScenarioDisputer, isScenarioReporter, isServiceProber, isToolListReporter, } from "../record/recorder.js";
+import { NullRecorder, isAttentionReader, isIntentMatcher, isMatchAware, isRecorderHealthReporter, isRunCreationAware, isScenarioDisputer, isScenarioReporter, isServiceProber, isToolListReporter, } from "../record/recorder.js";
 import { ReplayController, POLL_HOLD_MS, REPORT_TOOL_NAME, } from "../replay/controller.js";
 import { localDay } from "../replay/derive.js";
-import { RecordedValueError, markedKey } from "../replay/plan.js";
-import { evalToolInputLogic } from "../replay/logic.js";
-import { callMayChange, readsOnly } from "../replay/reads-only.js";
 import { calculateCostUsd, hasModelPricing } from "../replay/pricing.js";
 import { logDetail, logLine, logOnce, errText } from "../util/log.js";
 import { journal } from "../util/journal.js";
@@ -100,128 +97,36 @@ const PREVIEW_RESERVE_MS = 500;
  */
 const PROMPT_WAIT_MS = 7_500;
 /**
- * How long a `PreToolUse` waits for the intent probe when that probe may arm a
- * plan in the call's place (`BIR_INTENT_ARM_BUDGET_MS`). A clear match or a
- * miss answers well inside it; a probe that also asks the service a live
- * question does not, and is counted without arming (segmented.md R-HIT-11).
+ * How long a `PreToolUse` waits for the intent probe, which may arm a plan in
+ * the call's place (`BIR_INTENT_ARM_BUDGET_MS`). A match or a miss answers
+ * well inside it; a slower answer arms nothing.
  */
 const INTENT_ARM_PROBE_MS = 500;
 /** What an intent-armed plan may spend arming — derivation — inside `PreToolUse`. */
 const INTENT_ARM_DERIVE_MS = 1_500;
+/** How long a fragment's `PreToolUse` waits to learn whether its run was created. */
+const FRAGMENT_CREATE_MS = 300;
 /**
- * How long the agent's call after a decision may wait for a next scenario's
- * values (the service's offer1.md O5): they are read while the agent decides,
- * so this wait is only ever for a reading still on its way, or one read again
- * with the call itself. The call is about to be replaced, so waiting costs the
- * agent nothing; it stays well inside the route's own deadline.
+ * How long the model's first call after a hand-over waits for the service to
+ * say whether the work recorded after an earlier hand-over at that step has a
+ * plan (the service's fallbk.md Part 3). One lookup, no words matched: it
+ * answers in a round trip. Asked once per hand-over, never per call.
  */
-const NEXT_HIT_WAIT_MS = 6_000;
-/** How long the question "what can follow this decision" may take. It is asked in the background. */
-const NEXT_FETCH_MS = 5_000;
-/** How long a next scenario's arm waits for its values to settle, in the background. */
-const NEXT_READY_MS = 8_000;
-/** At most this many scenarios follow one decision (the service sends no more either). */
-const NEXT_MAX = 4;
-/** The turn's request a decision fragment carries, in characters (offer1.md O2). */
-const DECISION_REQUEST_MAX = 4_000;
+const CONTINUATION_PROBE_MS = 1_500;
 /**
- * How long the agent's call after a decision waits for the service's answer
- * to "what can follow it" when it has not come yet. Only that answer: never
- * the arms behind it.
+ * How long the continuation request itself may take — longer than the call
+ * waits for it, so that an answer too late for the call still lands, and the
+ * ticket it may carry is reported as late instead of never.
  */
-const NEXT_ROUTE_WAIT_MS = 1_000;
-/** Tools whose call is its command: the same tool with another command is another call (offer1.md O8). */
-const COMMAND_TOOLS = new Set(["Bash", "PowerShell"]);
-/** A shell call's command, trimmed; empty when it has none. */
-function commandOf(args) {
-    const c = args && typeof args === "object" ? args.command : undefined;
-    return typeof c === "string" ? c.trim() : "";
-}
-/** What `replay.next_miss` says for each way a decision's next scenarios end unused. */
-const NEXT_MISS_WHY = {
-    other_values: "the agent's call has the tool a next scenario starts with, but not its values — it took that way its own way; that work is recorded, and becomes a scenario of its own",
-    own_way: "the agent's call may change something and starts none of them — it is doing a way of its own; that work is recorded, and becomes a scenario of its own, and none of these may start in the middle of it",
-    not_ready: "the scenario that starts with this call's tool was not armed in time, and the call may change something — the agent went on its own way",
-    calls_limit: "the agent's first calls after the decision started none of them — it is doing the work itself; that work is recorded, and becomes a scenario of its own",
-    turn_ended: "the turn ended before any of them was used",
-    no_delivery_tool: "the scenario would be delivered through mcp__bir__run_scenario, which no running bir server serves",
-};
-/** One argument as a call compares it: trimmed text for a scalar, canonical JSON for the rest. */
-function argText(value) {
-    if (value === null || value === undefined)
-        return "";
-    if (typeof value === "string")
-        return value.trim();
-    if (typeof value === "number" || typeof value === "boolean")
-        return String(value);
-    return canonicalJson(value);
-}
-function canonicalJson(value) {
-    if (Array.isArray(value))
-        return `[${value.map(canonicalJson).join(",")}]`;
-    if (value && typeof value === "object") {
-        const o = value;
-        return `{${Object.keys(o)
-            .sort()
-            .map((k) => `${JSON.stringify(k)}:${canonicalJson(o[k])}`)
-            .join(",")}}`;
-    }
-    return JSON.stringify(value ?? null) ?? "null";
-}
+const CONTINUATION_REQUEST_MS = 6_000;
 /**
- * A planned first step's input against the agent's own arguments, value for
- * value (offer1.md O5). `missing` when the only differences are values the
- * plan does not have — empty, or held by a mark — that the agent gave. The
- * runner's reserved arguments (`__bir…`) are never compared.
+ * What a continuation may spend arming — reading its values — inside that
+ * `PreToolUse`. Longer than an intent arm may: it is asked once per hand-over,
+ * the plan it arms does the rest of the task, and a value the request names
+ * is read by the service, which gives a reading 6 s. With the probe it stays
+ * well inside the route's 12 s.
  */
-function sameArguments(planned, agent) {
-    if (!agent || typeof agent !== "object" || Array.isArray(agent))
-        return "other";
-    const a = agent;
-    let missing = false;
-    for (const key of new Set([...Object.keys(planned), ...Object.keys(a)])) {
-        if (key.startsWith("__bir"))
-            continue;
-        const p = argText(planned[key]);
-        const v = argText(a[key]);
-        if (p === v)
-            continue;
-        if (v !== "" && (p === "" || markedKey(planned[key]) !== undefined)) {
-            missing = true;
-            continue;
-        }
-        return "other";
-    }
-    return missing ? "missing" : "hit";
-}
-/** A next scenario's plan that was never announced: it never runs, and is never reported. */
-function dropNextState(state) {
-    state.plan = undefined;
-    state.mode = "none";
-    state.retired = true;
-    state.pinned.clear();
-    state.reported = true;
-}
-/** Drop an entry's plan, now or when its arm lands — all but `kept`, the one that hit. */
-function dropNextEntry(entry, kept) {
-    if (entry.state) {
-        if (entry.state !== kept)
-            dropNextState(entry.state);
-        return;
-    }
-    void entry.arming.then((late) => {
-        if (late && late !== kept)
-            dropNextState(late);
-    });
-}
-/**
- * The agent's calls after a decision that are checked against its next
- * scenarios: a scenario is a hit only on the way the agent starts, never in
- * the middle of work it is already doing.
- */
-const NEXT_CALLS_MAX = 5;
-/** How long a fragment's `PreToolUse` waits to learn whether its run was created. */
-const FRAGMENT_CREATE_MS = 300;
+const CONTINUATION_ARM_MS = 7_000;
 /** What `close()` spends draining the last runs to the service before it lets go. */
 const CLOSE_DRAIN_MS = 5_000;
 /** How long a background drain follows one run before it stops waiting for it. */
@@ -587,6 +492,17 @@ function reportedArgs(args) {
 function score(value) {
     return typeof value === "number" && Number.isFinite(value) ? value.toFixed(3) : undefined;
 }
+/**
+ * The tool a served scenario starts with, or undefined when the payload does
+ * not say. Untyped JSON from the service, read without trusting its shape.
+ */
+function firstStepTool(scenario) {
+    const steps = scenario?.steps;
+    if (!Array.isArray(steps) || steps.length === 0)
+        return undefined;
+    const name = steps[0]?.toolName;
+    return typeof name === "string" ? name : undefined;
+}
 function positiveEnv(name, fallback) {
     const n = Number(process.env[name]);
     return Number.isFinite(n) && n > 0 ? n : fallback;
@@ -751,14 +667,6 @@ function priceUsage(usage) {
  * through it, because the checks a replay in another host needs are here.
  */
 export const HOST_FIELDS = 2;
-/** One MCP call, as seen from up to two sides. */
-/**
- * Field separator for the probe's dedupe hash (segmented.md R-HIT-5). A NUL,
- * so that a text ending where a tool name begins can never hash the same as the
- * other way round. Built rather than written as an escape, because a literal
- * NUL in source is a trap for every tool that reads the file.
- */
-const PROBE_SEP = String.fromCharCode(0);
 export class ControlServer {
     token;
     sessionId = "birsess_" + randomUUID();
@@ -908,8 +816,8 @@ export class ControlServer {
     deriveRecentResults;
     /**
      * Which rungs of R-INTENT-1 the runner may send (`BIR_INTENT_SOURCES`). It
-     * governs only what is *sent*: with every source off, the probe still goes out
-     * with an empty text and the server builds the tool line (R-HIT-4).
+     * governs only what is *sent*: with every source off, a step goes out with no
+     * text, and no intent probe is sent for it.
      */
     intentSources;
     constructor(opts) {
@@ -1044,35 +952,33 @@ export class ControlServer {
                     unannounced: s.run.pendingDirective?.state === s.run.replay ? true : undefined,
                     running: this.runningPlans.has(s.run.replay) ? true : undefined,
                     armedBy: s.run.replay.armedBy,
+                    // A continuation (the service's fallbk.md Part 3): the plan it
+                    // continues, and the step that plan stopped in front of.
+                    continues: s.run.replay.continuation
+                        ? {
+                            scenarioId: s.run.replay.continuation.ofScenarioId,
+                            stepIndex: s.run.replay.continuation.stepIndex,
+                        }
+                        : null,
                     handover: s.run.replay.handover
                         ? { kind: s.run.replay.handover.kind, stepIndex: s.run.replay.handover.stepIndex }
                         : null,
                     plans: s.run.replays.length,
-                    kind: s.run.replay.kind,
                 }
                 : null,
-            // Present whether or not a plan is armed (segmented.md R-LIFE-8): the
-            // whole point of the observe-only period is that it is visible, and
-            // "nothing armed" and "nothing even probed" are different problems.
+            // Present whether or not a plan is armed: "nothing armed" and "nothing
+            // even probed" are different problems.
             intent: s.run
                 ? {
                     probes: s.run.intent.requests,
                     armed: s.run.intent.armed,
-                    lastStepHit: s.run.intent.lastStepHit ?? null,
                 }
                 : null,
             fragment: s.run?.fragment
-                ? { state: s.run.fragment.state, ...(s.run.fragment.decision ? { decision: true } : {}) }
-                : null,
-            // The calculated scenarios that can follow a decision of this turn
-            // (offer1.md O3): how many are ready for the agent's next call, and why
-            // the set ended once it has.
-            next: s.run?.next
                 ? {
-                    entries: s.run.next.entries.length,
-                    armed: s.run.next.entries.filter((e) => e.state?.plan && !e.state.retired).length,
-                    calls: s.run.next.calls,
-                    ended: s.run.next.ended ?? null,
+                    state: s.run.fragment.state,
+                    ...(s.run.fragment.asked ? { asked: true } : {}),
+                    ...(s.run.fragment.counted ? { counted: true } : {}),
                 }
                 : null,
             // The service's offer to record the turn as a recording's newest run,
@@ -1087,15 +993,6 @@ export class ControlServer {
             // The authoritative answer to "is anything actually being saved?".
             recording: this.opts.recording ?? !(this.recorder instanceof NullRecorder),
             account: this.opts.account ?? null,
-            // Whether a handed-out segment may actually run mid-task, or whether the
-            // runner is only watching (R-OUT-10, R-LIFE-8). Observe-only must never
-            // be invisible: an operator has to be able to see which of the two this
-            // machine is doing without reading a log file.
-            segmentArm: this.replay.segmentArm,
-            // And whether a step's intent may start a plan in its own PreToolUse,
-            // which means waiting for the probe there (it follows segmentArm unless
-            // BIR_INTENT_ARM says otherwise). For `bir doctor`.
-            intentArm: this.intentArming(),
             authUrl: resolveAuthUrl() || null,
             sessionId: this.sessionId,
             pid: process.pid,
@@ -2227,12 +2124,6 @@ export class ControlServer {
         if (!otherHost(session))
             state.reportTool = () => this.reportToolServed();
         this.declineWithoutDeliveryTool(state);
-        // A plan that stops at its decision is billed only up to the stop (the
-        // service's segmentsbreakdown.md SB-26): its hand-over takes this mark. A
-        // plan of the prompt without one keeps the window it always had.
-        if (!otherHost(session) && this.replay.stopsAtDecision(state)) {
-            state.markUsage = () => markTranscriptUsage(session.transcriptPath);
-        }
         // A steer plan with a shell or file-write step can only be followed if the
         // directive shows its computed arguments (the pin guard holds those steps
         // to their exact shape), so give its parameters a moment to settle —
@@ -2950,9 +2841,6 @@ export class ControlServer {
         run.pendingDirective = undefined;
         if (unannounced)
             this.shelveUnannounced(unannounced);
-        // The scenarios that could have followed a decision and were never used:
-        // never announced, never reported (offer1.md O7).
-        this.endNext(run, "turn_ended");
         // A `run_scenario` still waiting for this run's plan will never get it.
         this.directCalls = this.directCalls.filter((c) => c.run !== run);
         const durationMs = Date.now() - run.startedAtMs;
@@ -3147,36 +3035,50 @@ export class ControlServer {
             ? { runId: r.openedRunId, ownCalls: r.ownCalls ?? 0 }
             : undefined;
         const prompt = states.find((s) => s.armedBy === "prompt");
+        // The plans that continued a plan in this turn (the service's fallbk.md
+        // Part 3), directly or through one another: its hand-over's follow-on
+        // work. Its baseline is the whole task, theirs only the part after the
+        // hand-over, so its report bills the whole turn — its window runs through
+        // theirs, and their readings are booked on it — and theirs book no saving.
+        // Billed apart, the part after the hand-over would be saved twice.
+        const continuedBy = (state, from) => {
+            const chain = [];
+            const ids = new Set(state.scenarioId ? [state.scenarioId] : []);
+            for (const s of states.slice(from + 1)) {
+                if (s.continuation && ids.has(s.continuation.ofScenarioId)) {
+                    chain.push(s);
+                    if (s.scenarioId)
+                        ids.add(s.scenarioId);
+                }
+            }
+            // A continuation declined after its values were read spent that reading
+            // on this turn too, and its own report books nothing.
+            const declined = (run.declinedContinuations ?? []).filter((s) => s.continuation !== undefined && ids.has(s.continuation.ofScenarioId));
+            const deriveUsd = [...chain, ...declined].reduce((usd, s) => usd + s.deriveCostUsd, 0);
+            return { chain, deriveUsd };
+        };
         // One report per plan armed this turn (fallbk.md §Runner 4). Each is billed
         // for its own window of the transcript — from when it armed to when the next
         // one did — so the turn's tokens are split between them, never counted twice.
         // A turn with a single prompt-armed plan is exactly the report it always was.
         states.forEach((state, i) => {
-            const next = states[i + 1];
+            const { chain, deriveUsd: chainDeriveUsd } = continuedBy(state, i);
+            // The plan whose arm ends this one's window: never one that continued it.
+            const next = states.slice(i + 1).find((s) => !chain.includes(s));
             const nextMark = next?.armedBy === "intent" ? next.usageMark : undefined;
             let windowCost = cost;
             let windowMs = durationMs;
             // An intent-armed plan's window *ends* where its work ended (segmented.md
             // R-MONEY-3): at its own retire mark when it completed, else at the next
-            // plan's arm, else at the end of the turn. Without the first, a segment
+            // plan's arm, else at the end of the turn. Without the first, a plan
             // that finished in three steps would be billed for everything the agent
             // did afterwards, and its saving would read as a loss.
             let end = nextMark;
-            // A plan of the prompt stopped at its decision after a step ran: its
-            // window ends at the hand-over (the service's segmentsbreakdown.md
-            // SB-26), and the agent's decision and the half it took are not on its
-            // bill. Every other plan of the prompt keeps its window: the answer is
-            // still the plan's work.
-            const atDecision = state.handover?.kind === "decision" && state.retiredMark !== undefined;
             if (state.armedBy === "intent") {
                 windowCost = this.costSince(session, state.usageMark);
                 windowMs = (state.retiredAt ?? next?.armedAt ?? Date.now()) - state.armedAt;
                 end = state.retiredMark ?? nextMark;
             }
-            else if (atDecision) {
-                windowMs = (state.retiredAt ?? Date.now()) - run.startedAtMs;
-                end = state.retiredMark;
-            }
             else if (next) {
                 windowMs = next.armedAt - run.startedAtMs;
             }
@@ -3195,18 +3097,15 @@ export class ControlServer {
                 runId: run.runId,
                 cutShort: cutShort || undefined,
                 redoneBy: state === prompt && state.ranToEnd === true ? redoneBy : undefined,
+                chainDeriveUsd,
             });
             if (!report)
                 return;
-            if (state.armedBy === "intent" || atDecision) {
+            if (state.armedBy === "intent") {
                 logDetail("replay.done", {
                     scenario: state.scenarioId ?? undefined,
                     windowMs: Math.max(0, windowMs),
-                    billedTo: atDecision
-                        ? "its decision"
-                        : state.retiredMark !== undefined
-                            ? "its own retire"
-                            : "the next arm or the turn",
+                    billedTo: state.retiredMark !== undefined ? "its own retire" : "the next arm or the turn",
                 });
             }
             // The plan ran to its end, and no redo of the model's own was recorded:
@@ -3259,6 +3158,23 @@ export class ControlServer {
             if (report)
                 this.queue.push(() => recorder.reportExecution(report));
         }
+        // Continuations handed out and not armed (the service's fallbk.md Part 3):
+        // a report for each ticket, with the reason, so the console says why and
+        // not "no report". Nothing of theirs ran: unmeasured and costless.
+        for (const declined of run.declinedContinuations ?? []) {
+            if (states.includes(declined))
+                continue;
+            const report = this.replay.buildReport(declined, {
+                sessionCostUsd: 0,
+                measured: false,
+                durationMs: 0,
+                prompt: run.input || undefined,
+                siblings: [...states, declined],
+                runId: run.runId,
+            });
+            if (report)
+                this.queue.push(() => recorder.reportExecution(report));
+        }
     }
     /**
      * The plan's own calls of the turn, whole, as an answered turn's report
@@ -3767,7 +3683,6 @@ export class ControlServer {
                 // A hand-over inside `preTool` (an input logic that threw) must still
                 // schedule the fragment, even though this call ends here.
                 this.noteHandover(run);
-                this.noteDecision(session, run);
                 if (action.kind === "pin") {
                     // The same tool is not the same call. A pin swaps the model's
                     // arguments for the step's and approves them, so it is kept only for
@@ -3830,45 +3745,62 @@ export class ControlServer {
             const note = planning ? undefined : this.replay.takeNote(run.replay);
             if (note) {
                 this.noteHandover(run);
-                this.noteDecision(session, run);
                 return this.preToolAnswer(this.replay.deliverInstead(note, toolName));
             }
-            // If the deadline answers first, it answers `{}`: the call runs as
-            // written, and a plan armed in its place below was never announced.
+            // The model is doing the matched task itself, and the service asked for
+            // that run to be recorded as the recording's newest (newestRun.md N1).
+            // Opened before the probe below, so the turn is recorded from this call
+            // on like any recording turn — a plan an intent match arms in it too.
+            if (this.repeatDue(run))
+                this.openRepeat(session, run);
+            // 2. The model is driving: look for a scenario by this iteration's intent.
+            //    Never in plan mode, where nothing may run on the user's behalf.
+            //    If the deadline answers first, it answers `{}`: the call runs as
+            //    written, and a plan armed in its place was never announced.
             if (!planning && !lateSet) {
                 onLate?.(() => {
                     overran = true;
                     return {};
                 });
             }
-            // 2. The agent's call after a plan's decision: the first step of a
-            //    calculated scenario that can follow it (the service's offer1.md
-            //    O4–O6)? Then that scenario runs in this call's place. Before the
-            //    probe below: this check is exact (the same tool, the same values)
-            //    and asks the service nothing at this call. Never in plan mode.
-            if (!planning) {
-                this.noteDecision(session, run);
-                const hit = await this.tryNextScenarios(session, run, toolName, modelArgs, () => overran);
-                if (hit)
-                    return hit;
+            // 2a. The model's first call after a plan handed over: the work recorded
+            //     after an earlier hand-over at the same step may have a plan of its
+            //     own (the service's fallbk.md Part 3). Asked with the hand-over, not
+            //     with words, and armed only when this call is its first step.
+            const dueFragment = run.fragment;
+            const before = run.replay;
+            const continued = planning
+                ? undefined
+                : await this.tryContinuation(session, run, toolName, intent, modelArgs);
+            if (continued) {
+                if (!overran)
+                    return continued;
+                // The deadline answered first: the call ran as the model wrote it, and
+                // the plan was never announced. The model's own work from this call is
+                // the fragment, as it would have been with no plan.
+                const late = run.replay;
+                if (late && late !== before && late.continuation) {
+                    logLine("replay.decision", {
+                        verdict: "no-steer",
+                        code: "arm_unannounced",
+                        run: run.runId,
+                        scenario: late.scenarioId ?? undefined,
+                        why: "the call had to go ahead before this continuation's directive could replace it — retired unannounced, so never run",
+                    });
+                    const at = run.replays.indexOf(late);
+                    if (at >= 0)
+                        run.replays.splice(at, 1);
+                    run.replay = before;
+                    this.keepDeclinedContinuation(session, run, late, "arm_unannounced");
+                    run.fragment = dueFragment;
+                }
             }
-            // The model is doing the matched task itself, and the service asked for
-            // that run to be recorded as the recording's newest (newestRun.md N1).
-            // Opened before the probe below, so the turn is recorded from this call
-            // on like any recording turn — a plan an intent match arms in it too.
-            if (this.repeatDue(run))
-                this.openRepeat(session, run);
-            // 3. The model is driving: look for a scenario by this iteration's intent.
-            //    Never in plan mode, where nothing may run on the user's behalf, and
-            //    not once the deadline has answered: nothing new may start then.
-            const armed = planning || overran ? undefined : await this.tryIntentMatch(session, run, toolName, intent, modelArgs);
+            const armed = planning || continued
+                ? undefined
+                : await this.tryIntentMatch(session, run, toolName, intent, modelArgs);
             if (armed) {
-                if (!overran) {
-                    // The plan answers in this call's place: the agent's work from here
-                    // is that plan's, never the other half after a decision (SB-16).
-                    this.dropDecisionFragment(run, run.replay);
+                if (!overran)
                     return armed;
-                }
                 const late = run.replay;
                 if (late && late.armedBy === "intent" && late.plan && !late.retired) {
                     logLine("replay.decision", {
@@ -3882,17 +3814,12 @@ export class ControlServer {
                 }
                 // The call ran as the model wrote it: recorded below as its own.
             }
-            // 4. No scenario took over: the model's own work after a hand-over is
+            // 3. No scenario took over: the model's own work after a hand-over is
             //    recorded as a fragment, starting with this call.
             // Not for the call an intent match just armed a plan beside: the plan
-            //    runs next, and the fragment opens on the model's own work after it
-            //    — unless it was scheduled at a decision, whose fragment is the
-            //    other half only when the agent's own call opens it (SB-16).
-            if (run.fragment?.state === "due") {
-                if (!run.pendingDirective)
-                    await this.openFragment(session, run, reasoning, toolName, modelArgs);
-                else
-                    this.dropDecisionFragment(run, run.pendingDirective.state);
+            //    runs next, and the fragment opens on the model's own work after it.
+            if (run.fragment?.state === "due" && !run.pendingDirective) {
+                await this.openFragment(session, run, reasoning, toolName, modelArgs);
             }
         }
         // The arguments that will actually run — which is what must be correlated and
@@ -4465,104 +4392,17 @@ export class ControlServer {
         return this.preToolAnswer(this.replay.deliverInstead(note, toolName)) ?? {};
     }
     /**
-     * Recordings this turn must not count a step hit against (segmented.md
-     * R-HIT-7).
-     *
-     * A repeat of a recording's own prompt is *prompt* recurrence, counted as
-     * `iterations`, never step recurrence. Without this, three prompt repeats
-     * would reach `SEGMENT_MIN_HITS` on every step of the whole recording and the
-     * detector would build a whole-run-sized segment beside the whole-run
-     * scenario.
-     */
-    excludeRunsFor(run) {
-        const out = new Set();
-        if (run.recording)
-            out.add(run.runId);
-        const prompt = run.replays.find((s) => s.armedBy === "prompt")?.matchedRunId;
-        if (prompt)
-            out.add(prompt);
-        if (run.fragment?.hitRunId)
-            out.add(run.fragment.hitRunId);
-        // The recording the match offered a repeat of: the same recording, and
-        // known even when the match landed too late to be armed (newestRun.md).
-        if (run.repeat)
-            out.add(run.repeat.runId);
-        return [...out];
-    }
-    /**
-     * Per plan of this turn, its recording and how far the plan got in its own
-     * chain (segmented.md R-OUT-6).
+     * Intent matching in the ReAct loop (fallbk.md §Runner 4).
      *
-     * The server uses it to refuse a segment that starts *before* where this turn
-     * already is: re-running steps the turn has just done is worse than not
-     * replaying at all. The position is the plan's own: the step it handed over
-     * at (its decision included), or its last step when it ran to its end. The
-     * server maps it onto the recording — a segment's first position, a
-     * decision's step before it — and takes the largest per recording (the
-     * service's segmentsbreakdown.md D18). One entry per plan, so that two plans
-     * of one recording, whose own positions are on different scales, never
-     * hide each other. A plan declined for anything but a known-bad first step
-     * reports nothing — it ran none of the recording, so it blocks none of it.
+     * Called only while the model is driving, and only when a match may arm a
+     * plan in the call's place ({@link intentArming}, off unless
+     * `BIR_INTENT_ARM=1`): the reasoning the call was made with is sent, and the
+     * service may hand back a whole scenario whose intent it matches. A call made
+     * with no reasoning sends nothing — there is no intent to match. Every
+     * failure is a miss.
      *
-     * Rebuilt on every probe rather than cached: a plan that hands over between
-     * two calls changes the answer.
-     */
-    ranThroughFor(run) {
-        const best = new Map();
-        for (const state of run.replays) {
-            if (!state.scenarioId)
-                continue;
-            const recording = state.matchedRunId;
-            if (!recording)
-                continue;
-            let position;
-            if (!state.plan) {
-                // Only a first step the plan cannot start on — parked, or a judgement
-                // — means the turn is committed to doing this recording's work itself
-                // from position 0 (R-HIT-14); every other decline leaves the recording
-                // untouched.
-                if (state.declined === "known_bad_first_step" ||
-                    state.declined === "nondeterministic_first_step") {
-                    position = 0;
-                }
-            }
-            else if (state.handover) {
-                position = state.handover.stepIndex;
-            }
-            else {
-                // Ran to its end: the last position it planned.
-                position = Math.max(0, state.plan.stepCount - 1);
-            }
-            if (position === undefined)
-                continue;
-            const seen = best.get(state.scenarioId);
-            if (!seen || position > seen.position) {
-                best.set(state.scenarioId, { runId: recording, position });
-            }
-        }
-        return [...best].map(([scenarioId, v]) => ({
-            runId: v.runId,
-            position: v.position,
-            scenarioId,
-        }));
-    }
-    /**
-     * Intent matching in the ReAct loop (fallbk.md §Runner 4, segmented.md 10.3).
-     *
-     * Called only while the model is driving. Every unsteered, non-housekeeping
-     * tool call is sent: the service counts it as a hit on whatever recorded step
-     * it matches, and may hand back a scenario or a segment to run in its place.
-     *
-     * A call made with **no reasoning at all** still probes (R-HIT-4): the server
-     * builds an intent from the tool name and arguments, and a step the agent took
-     * without narrating it is exactly as much a recurrence as one it explained.
-     * Every failure is a miss.
-     *
-     * THE PROBE IS NOT WAITED ON unless it may arm ({@link intentArming}). Hit
-     * counting needs no answer at all, and waiting for one put a service round
-     * trip — 70-450 ms healthy, the whole 4 s budget on a hung service — in front
-     * of every Read, Grep, Edit and Bash of every signed-in user. When it may arm,
-     * the wait is {@link intentArmBudgetMs} at most, and none while the service is
+     * The probe sits in front of the call, so it is waited on
+     * {@link intentArmBudgetMs} at most, and not at all while the service is
      * failing. Delivering a match on a *later* call instead is not an option: the
      * matched call has run by then, and the plan's first step would repeat it.
      */
@@ -4570,122 +4410,82 @@ export class ControlServer {
         const opts = this.replay.intentMatch;
         if (!this.replay.enabled || !opts.enabled)
             return undefined;
-        // A run of another host that only records is a run with replay off: no
-        // probe is sent, so it adds nothing to the step counts either.
+        // Off unless asked for: arming in a call's place means waiting in front of
+        // it. Never in a session of another host either: a plan is started there by
+        // the prompt, and stepped through by an adapter that was told of it then.
+        // Nothing could announce one that armed in the middle of a run.
+        if (!this.intentArming() || otherHost(session))
+            return undefined;
+        // A run of another host that only records is a run with replay off.
         if (this.recordsOnly(session, run))
             return undefined;
         if (!isIntentMatcher(this.recorder))
             return undefined;
         if (this.replay.isDirectTool(toolName))
             return undefined;
+        // No reasoning, no intent to match.
         const text = (intent?.text ?? "").trim().slice(0, 4_000);
-        const source = intent?.source ?? "tool";
-        // Valid JSON with the serializer's own truncation marker, never a raw slice:
-        // the same string feeds the dedupe hash, the server's live question and the
-        // live call handed to derivation (R-HIT-4).
-        const toolInput = serializeCapped(redact(modelArgs), {
-            maxPayloadBytes: 2048,
-            maxStringBytes: 256,
-        });
-        // A retried identical call is not sent again; two different calls under one
-        // reasoning line both are (R-HIT-5).
-        const probeHash = createHash("sha1")
-            .update([text, toolName, toolInput].join(PROBE_SEP))
-            .digest("hex");
-        if (probeHash === run.intent.lastProbeHash)
+        if (!text)
+            return undefined;
+        // The match depends on the text alone: the same reasoning line is not sent
+        // twice in one turn.
+        if (text === run.intent.lastText)
             return undefined;
         if (run.intent.requests >= opts.maxRequestsPerTurn)
             return undefined;
-        // A service in its cool-down is not asked at all. The probe would only add
-        // a socket to an outage, and the hits it counts are lost with it anyway.
-        // Neither the hash nor the cap is spent, so the same call probes again once
-        // the service answers.
+        // A turn that has armed all it may arm asks for no more.
+        if (run.intent.armed >= opts.maxPerTurn)
+            return undefined;
+        // A service in its cool-down is not asked at all: the probe would only add
+        // a socket to an outage. Neither the text nor the cap is spent, so the same
+        // call probes again once the service answers.
         if (!this.service.canWait()) {
             logDetail("replay.intent_skipped", { run: run.runId, tool: toolName, why: "service unhealthy" });
             return undefined;
         }
-        run.intent.lastProbeHash = probeHash;
+        run.intent.lastText = text;
         run.intent.requests += 1;
         // Every scenario armed this turn, so a continuation cannot re-arm the plan
         // that just handed over.
-        const exclude = run.replays
-            .map((s) => s.scenarioId)
-            .filter((id) => typeof id === "string");
+        const exclude = this.armedScenarioIds(run);
         const startedAt = Date.now();
         const framework = frameworkOf(session);
         const probe = this.recorder
             .matchIntent({
             text,
-            source,
-            // The same value twice: `currentToolName` is what today's server reads,
-            // `toolName` is what the new one reads beside `toolInput`.
             currentToolName: toolName,
-            toolName,
-            toolInput,
             exclude,
-            turnId: run.turnId,
-            stepPosition: run.ordering.next,
-            excludeRuns: this.excludeRunsFor(run),
-            ranThrough: this.ranThroughFor(run),
-            // Segments are asked for only where one can arm: a probe that is
-            // waited on, in Claude Code (below). Any other probe gets the
-            // service's `segmentWouldArm` instead, logged as observe-only.
-            ...(this.replay.segmentArm && this.intentArming() && !otherHost(session) ? { acceptSegments: true } : {}),
-            supportsCalls: true,
             // Left out for Claude Code: a missing framework means Claude Code to
-            // the service, which matches a step only inside its own host.
+            // the service, which matches a scenario only inside its own host.
             ...(framework ? { framework } : {}),
         }, 
         // The probe's own budget (`BIR_INTENT_MATCH_BUDGET_MS`) ends the request
-        // itself — waited on or not — so an abandoned probe releases its socket
-        // rather than holding it for as long as the service takes to answer.
+        // itself, so an abandoned probe releases its socket rather than holding
+        // it for as long as the service takes to answer.
         { timeoutMs: opts.budgetMs })
             .catch(() => null);
-        // In a session of another host a probe only counts: a plan is started
-        // there by the prompt, and stepped through by an adapter that was told of
-        // it then. Nothing could announce one that armed in the middle of a run.
-        if (!this.intentArming() || otherHost(session)) {
-            // Counted, never waited on: whatever the answer says is bookkeeping.
-            void probe.then((late) => {
-                if (late)
-                    this.noteProbe(run, toolName, source, late, startedAt, "not waited on — counting only");
-            });
-            return undefined;
-        }
         const answer = await this.withinBudget(probe, this.intentArmBudgetMs());
         if (!answer) {
+            // A miss, or too slow to arm here.
             logDetail("replay.intent_miss", { run: run.runId, tool: toolName });
-            // A miss, or too slow to arm here. A late answer's hit still counts
-            // where health shows it; a miss resolves null and notes nothing.
-            void probe.then((late) => {
-                if (late)
-                    this.noteProbe(run, toolName, source, late, startedAt, "answered after the call went ahead");
-            });
             return undefined;
         }
-        this.noteProbe(run, toolName, source, answer, startedAt);
+        this.noteProbe(run, toolName, answer, startedAt);
         const match = answer.matched;
         if (!match)
             return undefined;
         if (match.scenarioId && exclude.includes(match.scenarioId))
             return undefined;
-        // The arms cap is checked *after* the response, not before it (R-HIT-5):
-        // hit counting must not stop just because the turn has already armed three
-        // plans. The ticket the server issued goes unredeemed and is swept
-        // (R-OUT-12).
-        if (run.intent.armed >= opts.maxPerTurn) {
-            logLine("replay.intent_arm_capped", {
-                scenario: match.scenarioId ?? undefined,
-                kind: match.kind ?? "scenario",
-                similarity: score(match.similarity),
-                tool: toolName,
-            });
-            return undefined;
-        }
+        // Valid JSON with the serializer's own truncation marker, never a raw
+        // slice: the live call handed to derivation.
+        const toolInput = serializeCapped(redact(modelArgs), {
+            maxPayloadBytes: 2048,
+            maxStringBytes: 256,
+        });
         // Bounded like the probe: derivation for a scenario with a target can take
         // seconds, and this call is waiting. A plan not armed in time is dropped
         // unused — it was never announced, so it never steers — and its ticket is
-        // swept like any unredeemed one (R-OUT-12).
+        // swept like any unredeemed one.
         const arming = this.armOrLog(run, this.replay.arm(match, text, this.wrapped, "intent", {
             liveCall: { toolName, toolInput },
             recentResults: this.recentResultsFor(session, "call"),
@@ -4700,7 +4500,6 @@ export class ControlServer {
                 code: "arm_timeout",
                 run: run.runId,
                 scenario: match.scenarioId ?? undefined,
-                kind: match.kind ?? "scenario",
                 ms: INTENT_ARM_DERIVE_MS,
                 why: "the plan was not ready before this call had to go ahead — never delivered, so never run",
             });
@@ -4718,9 +4517,6 @@ export class ControlServer {
         // what its relative paths resolve against (replay/builtins.ts). The
         // session's own cwd from the hook payloads, never the daemon's.
         state.sessionCwd = session.cwd ?? this.opts.cwd;
-        // The request this plan serves, for a note at its decision (SB-18): the
-        // turn's prompt. `arm` was given this step's intent instead.
-        state.request = run.input || undefined;
         this.declineWithoutDeliveryTool(state);
         if (!state.plan) {
             // A declined intent hit reports nothing: the turn's cost is not a
@@ -4728,6 +4524,14 @@ export class ControlServer {
             state.reported = true;
             return undefined;
         }
+        state.usageMark = markTranscriptUsage(session.transcriptPath);
+        // The closure, not the mark: only the control server holds the transcript
+        // path, and a completing retire happens in the controller (R-MONEY-3).
+        state.markUsage = () => markTranscriptUsage(session.transcriptPath);
+        run.replays.push(state);
+        run.replay = state;
+        run.intent.armed += 1;
+        const directive = this.replay.directiveFor(state) ?? "";
         // HOW THE DIRECTIVE REACHES THE MODEL. Mid-task, the call that matched is
         // usually the model's own ordinary work — a `git status`, a file read —
         // and denying it, or swapping its output for a directive, shows the user a
@@ -4741,50 +4545,6 @@ export class ControlServer {
         // it is held to the pin guard's rule (control/pin-guard.ts), so a `git
         // status` is never swapped for a deploy that happens to be a Bash step.
         const inPlace = this.isFirstStep(state, toolName, modelArgs);
-        // NEVER TWICE (the service's offer1.md O8). A plan that starts after this
-        // call — not in its place — and calls the same tool somewhere would make
-        // that call again: the agent's e-mail, then the plan's own e-mail (issue
-        // fx2). It is not started; the agent goes on. A read the runner knows is
-        // only a read may repeat: reading twice changes nothing.
-        if (!inPlace && this.planCallsTool(state, toolName, modelArgs)) {
-            logLine("replay.decision", {
-                verdict: "no-steer",
-                code: "would_repeat",
-                run: run.runId,
-                scenario: state.scenarioId ?? undefined,
-                kind: match.kind ?? "scenario",
-                tool: toolName,
-                why: "the plan would start after this call and make a call of the same tool again — never twice; the agent goes on",
-            });
-            state.plan = undefined;
-            state.mode = "none";
-            state.retired = true;
-            state.pinned.clear();
-            state.reported = true;
-            return undefined;
-        }
-        state.usageMark = markTranscriptUsage(session.transcriptPath);
-        // The closure, not the mark: only the control server holds the transcript
-        // path, and a completing retire happens in the controller (R-MONEY-3).
-        state.markUsage = () => markTranscriptUsage(session.transcriptPath);
-        // A segment of a recording whose whole-run plan already armed this turn
-        // takes its share off that plan's baseline (R-MONEY-4). One recording's
-        // steps are never counted in two baselines of one turn.
-        if (state.kind === "segment" && state.segment && state.scenarioId) {
-            for (const earlier of run.replays) {
-                if (earlier === state || !earlier.plan)
-                    continue;
-                if (earlier.kind !== "scenario")
-                    continue;
-                if (earlier.matchedRunId !== state.segment.runId)
-                    continue;
-                earlier.sharedWith.push(state.scenarioId);
-            }
-        }
-        run.replays.push(state);
-        run.replay = state;
-        run.intent.armed += 1;
-        const directive = this.replay.directiveFor(state) ?? "";
         logLine("replay.intent_armed", {
             run: run.runId,
             scenario: state.scenarioId ?? undefined,
@@ -4792,9 +4552,6 @@ export class ControlServer {
             mode: state.mode,
             instead: inPlace ? toolName : undefined,
             after: inPlace ? undefined : toolName,
-            kind: match.kind ?? "scenario",
-            key: match.key,
-            verified: match.verified?.verdict,
             why: "the model's reasoning matched a calculated scenario's intent",
         });
         if (inPlace)
@@ -4803,526 +4560,318 @@ export class ControlServer {
         return undefined;
     }
     /**
-     * Whether the model's call is plausibly `state`'s first step: its tool, and
-     * arguments the pin guard would pin to that step's input. The input is
-     * computed only for a step of the plan's own frame (a called segment's first
-     * step would build that segment's parameters here); anything that cannot be
-     * computed is "no" — the directive then rides on the call's PostToolUse.
-     */
-    isFirstStep(state, toolName, modelArgs) {
-        const plan = state.plan;
-        if (!plan || plan.expectedTool() !== toolName)
-            return false;
-        try {
-            const entry = plan.currentEntry();
-            if (!entry || entry.depth !== 0)
-                return false;
-            const first = plan.toolInputForCurrentStep();
-            return pinCompatible(toolName, modelArgs, first).ok;
-        }
-        catch (err) {
-            logDetail("replay.first_step_unknown", { tool: toolName, error: errText(err) });
-            return false;
-        }
-    }
-    /**
-     * The agent's call against `state`'s first step, value for value (the
-     * service's offer1.md O5): `hit` when every argument is the step's own,
-     * `missing` when the only differences are values the plan does not have
-     * (a target the reading left empty, which the agent's call may hold), and
-     * `other` otherwise.
+     * A continuation (the service's fallbk.md Part 3), on the model's first call
+     * after a plan handed over.
+     *
+     * The model's work after an earlier hand-over of the same plan at the same
+     * step was recorded once, as a fragment, and the service may have calculated
+     * it into a plan. Until 0.3.23 nothing asked for that plan: the only way a
+     * plan started mid-task was a match of the model's words against plan
+     * intents ({@link tryIntentMatch}, off by default), and a one-line note
+     * after a hand-over does not read like a plan's intent paragraph. Here the
+     * hand-over itself is the question — the plan and the step — so the service
+     * names one recording and matches no words.
+     *
+     * It arms only when the call the model is making is that plan's first step —
+     * its tool, and arguments the pin guard would pin to the step's input — and
+     * is then answered in that call's place, as an intent plan whose first step
+     * the call is. The plan before it stopped because the next step needed a
+     * judgement. This call is the model's judgement; a plan that starts with
+     * another call is a way the model did not take, and must not run.
+     *
+     * Its values are read from the turn's own request — the rest of the task is
+     * the one the user asked for — with the model's words, the call it was about
+     * to make and this turn's tool results beside it, as for any plan started at
+     * a tool call.
+     *
+     * Asked once per hand-over, waited on {@link CONTINUATION_PROBE_MS} and
+     * {@link CONTINUATION_ARM_MS} at most, and not at all while the service is
+     * failing. Every way it does not arm leaves the turn as it was: the model's
+     * call runs, and its work is recorded as the fragment. A plan handed out and
+     * not armed is reported for its ticket, with the reason.
      */
-    firstStepVerdict(state, toolName, modelArgs) {
-        const plan = state.plan;
-        if (!plan || plan.expectedTool() !== toolName)
-            return "other";
-        let first;
-        try {
-            const entry = plan.currentEntry();
-            if (!entry || entry.depth !== 0)
-                return "other";
-            first = plan.toolInputForCurrentStep();
-        }
-        catch (err) {
-            // A value the request did not give, or one only a step works out: the
-            // agent's call may hold it.
-            if (err instanceof RecordedValueError)
-                return "missing";
-            logDetail("replay.first_step_unknown", { tool: toolName, error: errText(err) });
-            return "other";
+    async tryContinuation(session, run, toolName, intent, modelArgs) {
+        const f = run.fragment;
+        if (!f || f.state !== "due" || f.asked)
+            return undefined;
+        if (!this.replay.enabled || !this.replay.intentMatch.enabled || !this.continuationsOn())
+            return undefined;
+        // Never in a session of another host: a plan is started there by the
+        // prompt, and stepped through by an adapter that was told of it then.
+        if (otherHost(session) || this.recordsOnly(session, run))
+            return undefined;
+        if (!isIntentMatcher(this.recorder))
+            return undefined;
+        // The model calling the delivery tool itself is no step of a plan.
+        if (this.replay.isDirectTool(toolName))
+            return undefined;
+        if (!this.service.canWait()) {
+            logDetail("replay.continuation_skipped", { run: run.runId, tool: toolName, why: "service unhealthy" });
+            return undefined;
         }
-        return sameArguments(first, modelArgs);
-    }
-    /**
-     * Whether `state`'s plan calls `toolName` in a step it would run: what makes
-     * a plan started after a call of that tool make it a second time (the
-     * service's offer1.md O8). A tool that only reads never counts — reading
-     * twice changes nothing — by the service's own rule ({@link readsOnly}): a
-     * `crm_search_customers` mid-task never keeps a plan that searches later from
-     * starting.
-     */
-    planCallsTool(state, toolName, modelArgs) {
-        const plan = state.plan;
-        if (!plan || readsOnly(toolName))
-            return false;
-        const same = plan
-            .allEntries()
-            .slice(0, plan.stepCount)
-            .filter((e) => e.step.toolName === toolName);
-        if (same.length === 0)
-            return false;
-        if (!COMMAND_TOOLS.has(toolName))
-            return true;
-        // A shell's call is its command: a `git status` is not repeated by a plan
-        // that deploys. Only a step that would run this very command repeats it —
-        // judged on the values the plan has now; a step whose command needs a
-        // result first cannot be told, and does not count.
-        const live = commandOf(modelArgs);
-        if (!live)
-            return false;
-        const params = plan.parameters;
-        return same.some((e) => {
-            try {
-                return commandOf(evalToolInputLogic(e.step.toolInputLogic ?? "return {};", params, e.frame.intent ?? "", {})) === live;
-            }
-            catch {
-                return false;
-            }
+        f.asked = true;
+        const text = (intent?.text ?? "").trim().slice(0, 4_000);
+        const framework = frameworkOf(session);
+        const handover = { scenarioId: f.scenarioId, stepIndex: f.stepIndex };
+        let landed = false;
+        const probe = this.recorder
+            .matchIntent({
+            text,
+            currentToolName: toolName,
+            exclude: this.armedScenarioIds(run),
+            handover,
+            ...(framework ? { framework } : {}),
+        }, { timeoutMs: CONTINUATION_REQUEST_MS })
+            .catch(() => null)
+            .then((answer) => {
+            landed = true;
+            return answer;
         });
-    }
-    // ── what can follow a decision (the service's offer1.md) ──────────────────
-    /**
-     * A plan of this turn stopped at its decision: ask the service, once per
-     * plan, which calculated scenarios can follow it, and arm each in the
-     * background while the agent reads the note and decides (offer1.md O3, O4).
-     * Called wherever a hand-over is first seen; a second call for the same plan
-     * does nothing.
-     */
-    noteDecision(session, run) {
-        if (run.finished || otherHost(session))
-            return;
-        if (!this.replay.enabled || !this.intentArming())
-            return;
-        if (!isNextScenarioSource(this.recorder))
-            return;
-        for (const state of run.replays) {
-            const h = state.handover;
-            if (h?.kind !== "decision" || !state.scenarioId)
-                continue;
-            const next = (run.next ??= { asked: new Set(), round: 0, answered: false, entries: [], calls: 0 });
-            if (next.asked.has(state.scenarioId))
-                continue;
-            next.asked.add(state.scenarioId);
-            // A new decision starts a new round: what could follow an earlier one is
-            // no longer checked (its unused plans are dropped), and the agent's next
-            // calls are checked against what can follow this one.
-            for (const e of next.entries)
-                dropNextEntry(e);
-            next.entries = [];
-            next.round += 1;
-            next.answered = false;
-            next.ended = undefined;
-            next.calls = 0;
-            next.asking = this.fetchNext(session, run, state.scenarioId, h.stepIndex, next.round);
-        }
-    }
-    /**
-     * Ask for a decision's next scenarios (offer1.md O3): each is checkable as
-     * soon as the service answers, and armed in the background, each on its own
-     * (O4). Resolves when the service has answered, not when the arms have.
-     * Never rejects.
-     */
-    async fetchNext(session, run, planId, stepIndex, round) {
-        const startedAt = Date.now();
-        let answer = null;
-        try {
-            if (isNextScenarioSource(this.recorder)) {
-                answer = await this.recorder.nextScenarios(planId, { turnId: run.turnId, supportsCalls: true }, { timeoutMs: NEXT_FETCH_MS });
+        const answer = await this.withinBudget(probe, CONTINUATION_PROBE_MS);
+        if (!answer) {
+            if (!landed) {
+                // Too slow, not failed: the service most likely counted the hand-over
+                // already, so the fragment says so. A plan its late answer hands out
+                // is reported as late, for its ticket.
+                f.counted = true;
+                void probe.then((late) => this.noteLateContinuation(run, handover, late));
             }
-        }
-        catch {
-            answer = null;
-        }
-        const next = run.next;
-        // A later decision of the turn has its own round: this answer is no one's.
-        if (!next || next.round !== round || next.ended || run.finished)
-            return;
-        next.answered = true;
-        next.asking = undefined;
-        const offered = (answer?.next ?? []).filter((m) => !!m && typeof m.scenarioId === "string");
-        // A plan already armed this turn is never armed again from here (the
-        // probe's own `exclude`): the plan that just stopped, above all.
-        const taken = new Set(run.replays.map((s) => s.scenarioId).filter((id) => typeof id === "string"));
-        const fresh = [];
-        for (const match of offered) {
-            if (next.entries.length + fresh.length >= NEXT_MAX)
-                break;
-            if (taken.has(match.scenarioId))
-                continue;
-            if ([...next.entries, ...fresh].some((e) => e.match.scenarioId === match.scenarioId))
-                continue;
-            const entry = {
-                planId,
-                stepIndex,
-                // `arm` reads a numeric similarity, and the key says how it was found.
-                match: { ...match, similarity: typeof match.similarity === "number" ? match.similarity : 1, key: "decision" },
-                firstTool: typeof match.firstTool === "string" && match.firstTool ? match.firstTool : null,
-                arming: Promise.resolve(undefined),
-            };
-            entry.arming = this.armNext(session, run, entry);
-            fresh.push(entry);
-        }
-        // Checkable at once: a call waits only for the arm of a scenario that
-        // starts with its own tool, never for the others.
-        next.entries.push(...fresh);
-        if (fresh.length === 0) {
-            logDetail("replay.next_none", {
-                run: run.runId,
-                plan: planId,
-                offered: offered.length,
-                why: answer
-                    ? "no calculated scenario follows this decision yet — what the agent does next is recorded, and becomes one"
-                    : "the service did not say what follows this decision — the agent goes on",
-            });
-            return;
-        }
-        // The audit line once every arm has answered; nobody waits for it.
-        void Promise.all(fresh.map((e) => e.arming)).then(() => {
-            if (run.finished || next.round !== round)
-                return;
-            logLine("replay.next_ready", {
+            logDetail("replay.continuation_miss", {
                 run: run.runId,
-                plan: planId,
-                n: fresh.filter((e) => e.state?.plan).length,
-                of: fresh.length,
-                ms: Date.now() - startedAt,
-                scenarios: fresh
-                    .map((e) => `${e.match.scenarioId}:${e.firstTool ?? "?"}:${e.state?.plan ? "ready" : (e.state?.declined ?? "failed")}`)
-                    .join(","),
-                why: "the calculated scenarios that can follow this decision are ready for the agent's next call",
+                tool: toolName,
+                why: landed ? "the request failed" : "no answer in time",
             });
-        });
-    }
-    /**
-     * Arm one next scenario in the background (offer1.md O4): its values read
-     * from the turn's request and its results so far — or, once more, with the
-     * agent's own call (O5) — and settled, so a call is compared with the first
-     * step as it would really run. Never rejects.
-     */
-    async armNext(session, run, entry, liveCall) {
-        try {
-            const state = await this.replay.arm(entry.match, run.input, this.wrapped, "intent", {
-                ...(liveCall ? { liveCall } : {}),
-                recentResults: this.recentResultsFor(session, "call"),
-                agentDay: this.agentDayFor(session),
-                atDecision: { scenarioId: entry.planId, stepIndex: entry.stepIndex },
-            }, this.hostContext(session, run));
-            if (state.plan)
-                await this.withinBudget(state.plan.ready().catch(() => undefined), NEXT_READY_MS);
-            entry.state = state;
-            return state;
-        }
-        catch (err) {
-            logDetail("replay.next_arm_failed", { scenario: entry.match.scenarioId ?? undefined, error: errText(err) });
             return undefined;
         }
-    }
-    /**
-     * The agent's call after a decision, against the scenarios that can follow
-     * it (offer1.md O5, O6). A hit — the call is a scenario's first step, value
-     * for value — is answered in the call's place with that scenario's directive:
-     * the agent calls `run_scenario`, and the scenario runs every step, this one
-     * included, once. Undefined otherwise: the call runs as the agent wrote it.
-     */
-    async tryNextScenarios(session, run, toolName, modelArgs, overran) {
-        const next = run.next;
-        if (!next || next.ended || run.finished || otherHost(session))
+        // Only a service that knows continuations answers one. An older service
+        // matched the text by words instead, and that is no continuation.
+        if (answer.continuation === undefined)
             return undefined;
-        if (this.replay.isDirectTool(toolName))
+        f.counted = answer.continuation?.counted === true;
+        const match = answer.matched;
+        if (!answer.continuation || !match) {
+            logDetail("replay.continuation_none", {
+                run: run.runId,
+                continues: `${f.scenarioId}@${f.stepIndex}`,
+                recording: answer.continuation?.runId,
+                why: answer.continuation
+                    ? "the work recorded after an earlier hand-over here has no plan ready"
+                    : "no hand-over at this step was recorded before",
+            });
             return undefined;
-        const deadline = Date.now() + positiveEnv("BIR_NEXT_HIT_WAIT_MS", NEXT_HIT_WAIT_MS);
-        const left = () => Math.max(0, deadline - Date.now());
-        // The service has not answered yet — the agent decided quickly. Its answer
-        // only is waited for, and briefly: not the arms that follow it.
-        if (!next.answered && next.asking) {
-            await this.withinBudget(next.asking, Math.min(left(), NEXT_ROUTE_WAIT_MS));
-            if (overran() || next.ended || run.finished)
-                return undefined;
         }
-        next.calls += 1;
-        /** A scenario that starts with this call's tool was compared, value for value, and missed. */
-        let compared = false;
-        /** One that starts with this call's tool was not armed in time: it misses this call only. */
-        let notReady = false;
-        /** Read the scenario's values once more, with the agent's call (O5); undefined when not ready in time. */
-        const readAgain = async (entry, old) => {
-            entry.rearmed = true;
-            dropNextState(old);
-            entry.state = undefined;
-            const toolInput = serializeCapped(redact(modelArgs), { maxPayloadBytes: 2048, maxStringBytes: 256 });
-            entry.arming = this.armNext(session, run, entry, { toolName, toolInput });
-            return (await this.withinBudget(entry.arming, left())) ?? undefined;
+        const continuation = {
+            ofScenarioId: f.scenarioId,
+            stepIndex: f.stepIndex,
+            runId: answer.continuation.runId,
         };
-        for (const entry of next.entries) {
-            if (entry.unhittable)
-                continue;
-            let state = entry.state;
-            if (!state) {
-                // Waited for only when the service named this call's tool as its first
-                // step; any other is compared only once it is armed.
-                if (entry.firstTool !== toolName)
-                    continue;
-                state = (await this.withinBudget(entry.arming, left())) ?? undefined;
-                if (overran() || next.ended)
-                    return undefined;
-                if (!state) {
-                    notReady = true;
-                    continue;
-                }
-            }
-            if (!state.plan || state.retired) {
-                // Declined at the decision for a value the request never names (an
-                // address a look-up returned): the agent's own call may hold it.
-                if (entry.rearmed || state.declined !== "missing_target" || entry.firstTool !== toolName)
-                    continue;
-                const again = await readAgain(entry, state);
-                if (overran() || next.ended)
-                    return undefined;
-                if (!again)
-                    notReady = true;
-                else if (again.plan && !again.retired && this.firstStepVerdict(again, toolName, modelArgs) === "hit") {
-                    return this.nextHit(session, run, entry, again, toolName);
-                }
-                else if (again.plan?.expectedTool() === toolName)
-                    compared = true;
-                continue;
-            }
-            if (state.plan.expectedTool() !== toolName)
-                continue;
-            // A first step inside a sub-task (a call row) is never the agent's call in place.
-            const first = state.plan.currentEntry();
-            if (!first || first.depth !== 0) {
-                entry.unhittable = true;
-                continue;
-            }
-            // Value for value (O5): the pin guard's "plausibly the step" is not
-            // enough here — the scenario would run its own values, and an e-mail to
-            // carlos must never become the recorded e-mail to olga.
-            const verdict = this.firstStepVerdict(state, toolName, modelArgs);
-            if (verdict === "hit")
-                return this.nextHit(session, run, entry, state, toolName);
-            // Only a value the plan lacks is read again, never one it read differently.
-            if (verdict === "missing" && !entry.rearmed) {
-                const again = await readAgain(entry, state);
-                if (overran() || next.ended)
-                    return undefined;
-                if (!again) {
-                    notReady = true;
-                    continue;
-                }
-                if (again.plan && !again.retired && this.firstStepVerdict(again, toolName, modelArgs) === "hit") {
-                    return this.nextHit(session, run, entry, again, toolName);
-                }
-            }
-            compared = true;
-        }
-        // No hit.
-        if (compared) {
-            // The agent took a way a scenario starts with, with other values: its
-            // own way, recorded, and a scenario of its own later (O7).
-            this.endNext(run, "other_values", toolName);
-        }
-        else if (callMayChange(toolName, modelArgs)) {
-            // Its first call that may change something and starts none of them: the
-            // agent is doing a way of its own (O7), and from here a scenario must
-            // never start in the middle of it.
-            this.endNext(run, notReady ? "not_ready" : "own_way", toolName);
+        // Before anything is read: the plan starts with another tool than the
+        // model's call, so the model chose another way.
+        const first = firstStepTool(match.scenario);
+        if (match.scenario && first !== undefined && first !== toolName) {
+            this.keepDeclinedContinuation(session, run, this.replay.declinedContinuation(match, "not_first_step", continuation));
+            return undefined;
         }
-        else {
-            if (notReady) {
-                logDetail("replay.next_not_ready", {
-                    run: run.runId,
-                    tool: toolName,
-                    why: "a scenario that starts with this tool was not armed in time — it misses this call only",
-                });
-            }
-            // A look leaves them in place, for a while.
-            if (next.calls >= NEXT_CALLS_MAX)
-                this.endNext(run, "calls_limit", toolName);
+        const startedAt = Date.now();
+        // Valid JSON with the serializer's own truncation marker, never a raw
+        // slice: the live call handed to the reading.
+        const toolInput = serializeCapped(redact(modelArgs), {
+            maxPayloadBytes: 2048,
+            maxStringBytes: 256,
+        });
+        // The rest of the task the user asked for: its values are in the turn's
+        // request, and the model's words say what it is doing next.
+        const prompt = [run.input, text].filter((s) => s.trim().length > 0).join("\n\n");
+        const arming = this.armOrLog(run, this.replay.arm(match, prompt, this.wrapped, "intent", {
+            liveCall: { toolName, toolInput },
+            recentResults: this.recentResultsFor(session, "call"),
+            agentDay: this.agentDayFor(session),
+        }, undefined, { continuation }));
+        const state = await this.withinBudget(arming, CONTINUATION_ARM_MS);
+        if (state === undefined)
+            return undefined; // it threw, and said so
+        if (state === null) {
+            logLine("replay.decision", {
+                verdict: "no-steer",
+                code: "arm_timeout",
+                run: run.runId,
+                scenario: match.scenarioId ?? undefined,
+                continues: `${f.scenarioId}@${f.stepIndex}`,
+                ms: CONTINUATION_ARM_MS,
+                why: "the continuation's values were not read before this call had to go ahead — never delivered, so never run",
+            });
+            void arming.then((late) => {
+                if (late)
+                    this.keepDeclinedContinuation(session, run, late, "arm_timeout");
+            });
+            return undefined;
         }
-        return undefined;
-    }
-    /** A next scenario's hit: bookkeeping as for any plan armed mid-task, then its directive in the call's place. */
-    nextHit(session, run, entry, state, toolName) {
         state.sessionId = session.sessionId;
         state.sessionCwd = session.cwd ?? this.opts.cwd;
-        // The request this plan serves, for a note at a decision of its own (SB-18).
-        state.request = run.input || undefined;
-        if (this.declineWithoutDeliveryTool(state)) {
-            state.reported = true;
-            this.endNext(run, "no_delivery_tool", toolName);
+        this.declineWithoutDeliveryTool(state);
+        if (!state.plan) {
+            // A gate declined it, and said why (`state.declined`).
+            this.keepDeclinedContinuation(session, run, state);
+            return undefined;
+        }
+        // Its values are in: the model's call must be its first step, arguments
+        // and all — the same call, not merely one the pin guard would take over
+        // (pin-guard.ts `sameFirstCall`).
+        await this.withinBudget(state.plan.ready().catch(() => undefined), Math.max(0, CONTINUATION_ARM_MS - (Date.now() - startedAt)));
+        if (!this.isContinuationFirstCall(state, toolName, modelArgs)) {
+            this.keepDeclinedContinuation(session, run, state, "not_first_step");
             return undefined;
         }
         state.usageMark = markTranscriptUsage(session.transcriptPath);
         state.markUsage = () => markTranscriptUsage(session.transcriptPath);
-        if (state.kind === "segment" && state.segment && state.scenarioId) {
-            for (const earlier of run.replays) {
-                if (earlier === state || !earlier.plan || earlier.kind !== "scenario")
-                    continue;
-                if (earlier.matchedRunId !== state.segment.runId)
-                    continue;
-                earlier.sharedWith.push(state.scenarioId);
-            }
-        }
         run.replays.push(state);
         run.replay = state;
-        run.intent.armed += 1;
-        // The agent's work from here is this scenario's, never recorded as the
-        // agent's own after the decision: a fragment still due is dropped, and
-        // one the agent's own looks opened ends with them.
-        this.closeDecisionFragment(session, run, state);
-        this.dropDecisionFragment(run, state);
-        this.endNext(run, "hit", toolName, state);
+        // From here the continuation is this turn's plan. A hand-over of its own,
+        // if it makes one, schedules its own fragment: the one the plan before it
+        // left due is not opened.
+        run.fragment = undefined;
         const directive = this.replay.directiveFor(state) ?? "";
-        logLine("replay.next_hit", {
+        logLine("replay.continuation_armed", {
             run: run.runId,
             scenario: state.scenarioId ?? undefined,
-            plan: entry.planId,
-            kind: state.kind,
+            continues: `${continuation.ofScenarioId}@${continuation.stepIndex}`,
+            recording: continuation.runId,
             mode: state.mode,
-            tool: toolName,
-            rearmed: entry.rearmed || undefined,
-            why: "the agent's call is the first step of a calculated scenario that follows the decision — it runs in the call's place",
+            instead: toolName,
+            ms: Date.now() - startedAt,
+            why: "the model's call after the hand-over is the first step of the plan calculated from the work recorded after an earlier hand-over at this step",
         });
         return this.preToolAnswer(this.replay.deliverInstead(directive, toolName));
     }
     /**
-     * A next scenario hit after the agent's own calls — looks — opened the
-     * fragment of its work after the decision: the fragment ends here, with what
-     * the agent did itself, and nothing more of this turn is recorded into it.
-     * The scenario's own calls, pinned in steer mode or run in direct mode, are
-     * not the agent's work, and would make the fragment a copy of that scenario
-     * (offer1.md O7). A fragment still due is dropped instead
-     * ({@link dropDecisionFragment}).
+     * A continuation handed out and not armed: kept, retired, for its ticket's
+     * report at the seal (`not_steered`, with the reason, unmeasured). `code`
+     * says why when no gate did.
      */
-    closeDecisionFragment(session, run, by) {
-        const f = run.fragment;
-        if (!f || f.state !== "open" || !f.decision || !run.recording)
-            return;
-        const runId = run.runId;
-        const cost = this.costSince(session, f.usageMark);
-        const durationMs = f.startedAtMs ? Date.now() - f.startedAtMs : 0;
-        // Behind the fragment's own steps in the queue, as every finish is.
-        this.queue.push(() => {
-            this.recorder.finishRun(runId, undefined, {
-                durationMs,
-                costUsd: cost.measured ? cost.usd : undefined,
+    keepDeclinedContinuation(session, run, state, code) {
+        if (code) {
+            state.declined = code;
+            logLine("replay.decision", {
+                verdict: "no-steer",
+                code,
+                run: run.runId,
+                scenario: state.scenarioId ?? undefined,
+                continues: state.continuation
+                    ? `${state.continuation.ofScenarioId}@${state.continuation.stepIndex}`
+                    : undefined,
+                why: code === "not_first_step"
+                    ? "the model's call after the hand-over is not this continuation's first step — the model chose another way"
+                    : "the continuation was not armed in time",
             });
+        }
+        state.sessionId = session.sessionId;
+        state.plan = undefined;
+        state.mode = "none";
+        state.stepsPlanned = 0;
+        state.retired = true;
+        state.pinned.clear();
+        // A seal has reported already: nothing more can be said for this turn.
+        if (run.finished)
+            return;
+        (run.declinedContinuations ??= []).push(state);
+    }
+    /** A continuation request's answer that came after the call it was for went ahead. */
+    noteLateContinuation(run, handover, late) {
+        const match = late?.matched;
+        if (!late?.continuation || !match?.executionTicket || run.finished)
+            return;
+        const state = this.replay.declinedContinuation(match, "match_late", {
+            ofScenarioId: handover.scenarioId,
+            stepIndex: handover.stepIndex,
+            runId: late.continuation.runId,
         });
-        run.recording = false;
-        f.state = "closed";
-        logLine("run.fragment_closed", {
-            run: runId,
-            scenario: f.scenarioId,
-            step: f.stepIndex,
-            by: by.scenarioId ?? undefined,
-            why: "a scenario that follows the decision takes over after the agent's own first calls — the fragment ends with what the agent did itself",
-        });
+        (run.declinedContinuations ??= []).push(state);
     }
     /**
-     * End this turn's next scenarios (offer1.md O6): every one but the hit is
-     * never announced, so never runs and is never reported.
+     * Every scenario this turn was handed and armed or declined: never handed
+     * out again in it. A plan that handed over is among them, so its own
+     * continuation request can never return it.
      */
-    endNext(run, why, toolName, kept) {
-        const next = run.next;
-        if (!next || next.ended)
-            return;
-        next.ended = why;
-        for (const e of next.entries)
-            dropNextEntry(e, kept);
-        if (why !== "hit" && next.entries.length > 0) {
-            logLine("replay.next_miss", {
-                run: run.runId,
-                reason: why,
-                tool: toolName,
-                calls: next.calls,
-                scenarios: next.entries.map((e) => e.match.scenarioId).join(","),
-                why: NEXT_MISS_WHY[why] ?? "none of the scenarios that follow the decision was used",
-            });
+    armedScenarioIds(run) {
+        return [...run.replays, ...(run.declinedContinuations ?? [])]
+            .map((s) => s.scenarioId)
+            .filter((id) => typeof id === "string");
+    }
+    /**
+     * Whether the model's call is a continuation's first step: its tool, and
+     * the step's own input in every argument the two share (pin-guard.ts
+     * `sameFirstCall`). Anything that cannot be computed is "no".
+     */
+    isContinuationFirstCall(state, toolName, modelArgs) {
+        const plan = state.plan;
+        if (!plan || plan.expectedTool() !== toolName)
+            return false;
+        try {
+            const verdict = sameFirstCall(toolName, modelArgs, plan.toolInputForCurrentStep());
+            if (!verdict.ok) {
+                logDetail("replay.continuation_other_call", { tool: toolName, why: verdict.why });
+            }
+            return verdict.ok;
         }
-        next.entries = [];
+        catch (err) {
+            logDetail("replay.first_step_unknown", { tool: toolName, error: errText(err) });
+            return false;
+        }
+    }
+    /** Whether continuations are asked for: on unless `BIR_CONTINUATIONS=0`. */
+    continuationsOn() {
+        if (this.opts.continuations !== undefined)
+            return this.opts.continuations;
+        return process.env.BIR_CONTINUATIONS !== "0";
     }
     /**
-     * Whether an intent probe may arm a plan in its own `PreToolUse` — and so
-     * whether that hook waits for it. See {@link ControlServerOptions.intentArm}.
+     * Whether the model's call is plausibly `state`'s first step: its tool, and
+     * arguments the pin guard would pin to that step's input. Anything that
+     * cannot be computed is "no" — the directive then rides on the call's
+     * PostToolUse.
+     */
+    isFirstStep(state, toolName, modelArgs) {
+        const plan = state.plan;
+        if (!plan || plan.expectedTool() !== toolName)
+            return false;
+        try {
+            const first = plan.toolInputForCurrentStep();
+            return pinCompatible(toolName, modelArgs, first).ok;
+        }
+        catch (err) {
+            logDetail("replay.first_step_unknown", { tool: toolName, error: errText(err) });
+            return false;
+        }
+    }
+    /**
+     * Whether a match found mid-turn may arm a plan in its own `PreToolUse` — and
+     * so whether a probe is sent and waited for at all. Off unless
+     * `BIR_INTENT_ARM=1`. See {@link ControlServerOptions.intentArm}.
      */
     intentArming() {
         if (this.opts.intentArm !== undefined)
             return this.opts.intentArm;
-        const env = process.env.BIR_INTENT_ARM;
-        if (env === "1")
-            return true;
-        if (env === "0")
-            return false;
-        return this.replay.segmentArm;
+        return process.env.BIR_INTENT_ARM === "1";
     }
     /** How long an arming probe is waited on: `BIR_INTENT_ARM_BUDGET_MS`, never past the probe's own budget. */
     intentArmBudgetMs() {
         return Math.min(this.replay.intentMatch.budgetMs, positiveEnv("BIR_INTENT_ARM_BUDGET_MS", INTENT_ARM_PROBE_MS));
     }
-    /** The bookkeeping half of a probe's answer: what `/health` and the log show. */
-    noteProbe(run, toolName, source, answer, startedAt, late) {
-        // Bookkeeping only, and often run from a floating `.then` after the hook
-        // answered: a malformed answer is a log line, never an unhandled rejection
-        // (which crashes any embedder without a handler) or a failed route.
+    /** A probe's answer, for the log. Never throws: a malformed answer is a log line. */
+    noteProbe(run, toolName, answer, startedAt) {
         try {
-            this.noteProbeUnsafe(run, toolName, source, answer, startedAt, late);
+            logDetail("replay.intent_probe", {
+                run: run.runId,
+                tool: toolName,
+                elapsedMs: Date.now() - startedAt,
+                matched: answer.matched?.scenarioId ?? "none",
+                bestSimilarity: typeof answer.bestSimilarity === "number" ? score(answer.bestSimilarity) : undefined,
+            });
         }
         catch (err) {
             logDetail("replay.intent_note_failed", { run: run.runId, tool: toolName, error: errText(err) });
         }
     }
-    noteProbeUnsafe(run, toolName, source, answer, startedAt, late) {
-        if (answer.stepHit) {
-            run.intent.lastStepHit = { ...answer.stepHit, at: Date.now() };
-        }
-        // What *would* have armed, had segments been armed (segmented.md R-OUT-10).
-        // Logged at line level, not detail: this is the whole observe-only period,
-        // and the decision to turn arming on is made by reading these. The turn
-        // then carries on with whatever else the answer holds (R-OUT-15).
-        if (answer.segmentWouldArm) {
-            const w = answer.segmentWouldArm;
-            logLine("replay.segment_would_arm", {
-                scenario: w.scenarioId,
-                run: w.runId,
-                key: w.key,
-                similarity: score(w.similarity),
-                band: w.band,
-                verified: w.verified
-                    ? w.verified.verdict === "skipped"
-                        ? `skipped:${w.verified.reason}`
-                        : `${w.verified.verdict}: ${w.verified.reason}`
-                    : undefined,
-                tool: w.tool ?? toolName,
-                firstTool: w.firstTool,
-                stepFrom: w.stepFrom,
-                stepTo: w.stepTo,
-                hitCount: w.hitCount,
-            });
-        }
-        const match = answer.matched;
-        logDetail("replay.intent_probe", {
-            run: run.runId,
-            tool: toolName,
-            source,
-            stepHit: answer.stepHit ? `${answer.stepHit.runId}:${answer.stepHit.stepIndex}` : "none",
-            bestStepSimilarity: answer.bestStepSimilarity,
-            elapsedMs: Date.now() - startedAt,
-            matched: match?.scenarioId ?? "none",
-            kind: match?.kind,
-            late,
-        });
-    }
     /**
      * Schedule a fragment once a matched turn's plan has handed over (fallbk.md
      * D7). Only a turn that is not already recording needs one: an unmatched turn
@@ -5335,35 +4884,7 @@ export class ControlServer {
         const h = state?.handover;
         if (!h || !state?.scenarioId)
             return;
-        run.fragment = {
-            scenarioId: state.scenarioId,
-            stepIndex: h.stepIndex,
-            state: "due",
-            ...(h.kind === "decision" ? { decision: true } : {}),
-        };
-    }
-    /**
-     * Drop a fragment scheduled at a decision (the service's
-     * segmentsbreakdown.md SB-16) when a plan the intent check armed takes the
-     * agent's next call: what follows is that plan's half, not the other one,
-     * and recorded as the other half it would become a wrong segment C. Cleared
-     * rather than ended, so a later hand-over of that plan schedules its own
-     * fragment, as any plan's does in a turn with none. Any other fragment is
-     * left as it is.
-     */
-    dropDecisionFragment(run, by) {
-        const f = run.fragment;
-        if (!f || f.state !== "due" || !f.decision)
-            return;
-        run.fragment = undefined;
-        logLine("run.fragment_dropped", {
-            run: run.runId,
-            scenario: f.scenarioId,
-            step: f.stepIndex,
-            by: by?.scenarioId ?? undefined,
-            kind: by?.kind,
-            why: "a plan the intent check armed takes the agent's next step after the decision — that work is not the other half",
-        });
+        run.fragment = { scenarioId: state.scenarioId, stepIndex: h.stepIndex, state: "due" };
     }
     /**
      * Open the fragment run and record from this call on (fallbk.md D7).
@@ -5383,21 +4904,12 @@ export class ControlServer {
             return;
         const input = reasoning.trim() || `${toolName} ${serializeCapped(redact(args))}`.slice(0, 2_000);
         const fallbackOf = { scenarioId: f.scenarioId, stepIndex: f.stepIndex };
-        // The agent's own call after a plan's decision (SB-16): this runner's word
-        // that the work that follows is the agent's choice, not a plan's half.
-        // The service reads it beside its own mark of the fragment (the
-        // service's segmentsbreakdown.md D14).
-        // With the turn's own request (offer1.md O2): the service calculates what
-        // the agent does here with it, so the values the request names are read
-        // from the next request instead of being fixed. Redacted and cut, as the
-        // prompt itself is wherever it leaves this machine.
-        const request = run.input ? redactText(run.input).slice(0, DECISION_REQUEST_MAX) : "";
-        const decisionOf = f.decision
-            ? { scenarioId: f.scenarioId, stepIndex: f.stepIndex, ...(request ? { request } : {}) }
-            : undefined;
+        // The service counted this hand-over already, when it was asked for its
+        // continuation (Part 3): the create says so, and is not counted again.
+        const sent = f.counted ? { ...fallbackOf, counted: true } : fallbackOf;
         // The fragment is a run of the same host as the turn it continues.
         const framework = frameworkOf(session);
-        const id = this.recorder.startRun(input, { ...this.runMetadata(session), fallbackOf, ...(decisionOf ? { decisionOf } : {}) }, framework ? { fallbackOf, framework } : { fallbackOf });
+        const id = this.recorder.startRun(input, { ...this.runMetadata(session), fallbackOf }, framework ? { fallbackOf: sent, framework } : { fallbackOf: sent });
         for (const c of run.correlations.values()) {
             c.settled = true;
             if (c.fallback)
@@ -5414,7 +4926,6 @@ export class ControlServer {
             run: id,
             scenario: f.scenarioId,
             step: f.stepIndex,
-            decision: f.decision || undefined,
             why: "recording the agent's own work after the scenario handed over",
         });
         if (!isRunCreationAware(this.recorder))
@@ -5431,21 +4942,12 @@ export class ControlServer {
     /** What the fragment's create call said: `created: false` is a hit, not a recording. */
     applyFragmentCreation(run, id, created) {
         const f = run.fragment;
-        if (!f || run.runId !== id)
-            return;
-        if (created.created) {
-            // Recorded as the newest run of the fragment it is a hit on (the
-            // service's newestRun.md N2): still that fragment's repeat, so no step
-            // hit may be counted against it (R-HIT-7).
-            if (created.fragmentOf)
-                f.hitRunId = created.fragmentOf.runId;
+        // Recorded — as a fragment of its own, or as the newest run of the
+        // fragment it is a hit on (the service's newestRun.md N2): it records on.
+        if (!f || run.runId !== id || created.created)
             return;
-        }
         run.recording = false;
         f.state = "hit";
-        // Which run it hit matters from here on: this turn must not count step
-        // hits against the fragment it is a repeat of (segmented.md R-HIT-7).
-        f.hitRunId = created.fragmentOf?.runId;
         logLine("run.fragment_hit", {
             run: id,
             scenario: f.scenarioId,
@@ -5654,17 +5156,12 @@ export class ControlServer {
         const stashed = this.claimStashedNote(payload.session_id);
         if (stashed)
             context.push(stashed);
-        const postSession = this.sessions.get(payload.session_id ?? "unknown-session");
-        const run = postSession?.run;
+        const run = this.sessions.get(payload.session_id ?? "unknown-session")?.run;
         if (run && !run.finished) {
             // The answer, if one comes, is written after this call (AC11).
             if (typeof payload.tool_use_id === "string" && payload.tool_use_id)
                 run.lastToolUseId = payload.tool_use_id;
             this.noteHandover(run);
-            // A plan that stopped at its decision on this call: what can follow it is
-            // asked for now, while the agent reads the note and decides (offer1.md O4).
-            if (postSession)
-                this.noteDecision(postSession, run);
             const note = this.replay.takeNote(run.replay);
             if (note)
                 context.push(note);
@@ -6229,11 +5726,6 @@ export class ControlServer {
             const result = await this.replay.runArmed(state, signal);
             if (signal?.aborted)
                 this.stashCancelledNote(call.sessionId, state);
-            // A direct plan that stopped at its decision: what can follow it is asked
-            // for at once, before the agent has even read the results (offer1.md O4).
-            const runSession = this.sessions.get(call.sessionId);
-            if (runSession && runSession.run === call.run && !signal?.aborted)
-                this.noteDecision(runSession, call.run);
             return result;
         }
         finally {