@basein/runner 0.3.18 → 0.3.20

package/dist/bin/bir-hooks.d.ts

@@ -101,15 +101,18 @@
  *                             Separate from BIR_INTENT_MATCHES_PER_TURN: arming
  *                             is a claim on the turn, counting hits is not
  *   BIR_INTENT_MATCH_BUDGET_MS  one intent probe's own ceiling (default 4000).
- *                             Not a wait: PreToolUse does not wait for a probe
- *                             unless arming is on (BIR_SEGMENT_ARM=1 or
- *                             BIR_INTENT_ARM=1), and then at most
+ *                             Not a wait of its own: PreToolUse waits for a
+ *                             probe only while arming is on (the default from
+ *                             0.3.19; off with BIR_SEGMENT_ARM=0 or
+ *                             BIR_INTENT_ARM=0), and then at most
  *                             BIR_INTENT_ARM_BUDGET_MS (default 500)
- *   BIR_SEGMENT_ARM           1 lets a handed-out segment actually run mid-task.
- *                             Unset is observe-only: what would have armed is
- *                             logged and nothing is replaced
- *   BIR_MIN_SEGMENT_STEER_SIMILARITY  minimum similarity to steer a segment
- *                             (default 0.95)
+ *   BIR_SEGMENT_ARM           unset or 1 (the default from 0.3.19): a segment
+ *                             the service hands out runs mid-task — one found
+ *                             by repeated work, or a half after a plan's
+ *                             decision — and so may a whole plan whose intent
+ *                             a step matches (BIR_INTENT_ARM follows it unless
+ *                             set). 0 is observe-only: what would have armed
+ *                             is logged and nothing is replaced
  *   BIR_REPLAY_BUDGET_MS      whole-plan ceiling, direct mode (unset: the
  *                             controller's 100000, BIR_REPLAY_PLAN_BUDGET_MS)
  *   BIR_STEP_TIMEOUT_MS       one direct tools/call (default 60000)

package/dist/bin/bir-hooks.js

@@ -101,15 +101,18 @@
  *                             Separate from BIR_INTENT_MATCHES_PER_TURN: arming
  *                             is a claim on the turn, counting hits is not
  *   BIR_INTENT_MATCH_BUDGET_MS  one intent probe's own ceiling (default 4000).
- *                             Not a wait: PreToolUse does not wait for a probe
- *                             unless arming is on (BIR_SEGMENT_ARM=1 or
- *                             BIR_INTENT_ARM=1), and then at most
+ *                             Not a wait of its own: PreToolUse waits for a
+ *                             probe only while arming is on (the default from
+ *                             0.3.19; off with BIR_SEGMENT_ARM=0 or
+ *                             BIR_INTENT_ARM=0), and then at most
  *                             BIR_INTENT_ARM_BUDGET_MS (default 500)
- *   BIR_SEGMENT_ARM           1 lets a handed-out segment actually run mid-task.
- *                             Unset is observe-only: what would have armed is
- *                             logged and nothing is replaced
- *   BIR_MIN_SEGMENT_STEER_SIMILARITY  minimum similarity to steer a segment
- *                             (default 0.95)
+ *   BIR_SEGMENT_ARM           unset or 1 (the default from 0.3.19): a segment
+ *                             the service hands out runs mid-task — one found
+ *                             by repeated work, or a half after a plan's
+ *                             decision — and so may a whole plan whose intent
+ *                             a step matches (BIR_INTENT_ARM follows it unless
+ *                             set). 0 is observe-only: what would have armed
+ *                             is logged and nothing is replaced
  *   BIR_REPLAY_BUDGET_MS      whole-plan ceiling, direct mode (unset: the
  *                             controller's 100000, BIR_REPLAY_PLAN_BUDGET_MS)
  *   BIR_STEP_TIMEOUT_MS       one direct tools/call (default 60000)

package/dist/bin/bir.js

@@ -3118,13 +3118,20 @@ async function doctor(args) {
                                 "For headless runs (`claude -p`) allow them in permissions.allow or --allowedTools, or set " +
                                 "BIR_CORRELATION_DECISION=allow where the recorder starts");
         }
-        // Whether a recurring sub-task the service found may actually run mid-task
-        // (segmented.md R-LIFE-8). Observe-only is the default and must be visible
-        // without reading a log: an operator turns arming on by reading what *would*
-        // have armed, and needs to know which of the two states this machine is in.
-        notes.push(health.segmentArm === true
-            ? "recurring sub-tasks MAY run mid-task (BIR_SEGMENT_ARM=1)"
-            : "recurring sub-tasks are observed only — nothing is replaced (BIR_SEGMENT_ARM unset)");
+        // Whether a segment the service hands out may run mid-task (segmented.md
+        // R-LIFE-8). On by default from 0.3.19 (the service's segmentsbreakdown.md
+        // SB-21); either state must be visible without reading a log, and an older
+        // recorder still running here keeps the old default until it is replaced.
+        // A segment starts only where the probe is waited on, so `intentArm: false`
+        // (BIR_INTENT_ARM=0) starts nothing mid-task, segments included; a
+        // recorder older than that field says nothing of it.
+        notes.push(health.segmentArm === true && health.intentArm !== false
+            ? "segments run mid-task — recurring sub-tasks, and the halves after a plan's decision — and so may whole plans (the default; BIR_SEGMENT_ARM=0 turns this off)"
+            : health.segmentArm === true
+                ? "segments are observed only — nothing starts mid-task (BIR_INTENT_ARM=0 where the recorder started)"
+                : theirs && theirs !== VERSION
+                    ? `segments are observed only — this recorder (${theirs}) is older than this bir, which runs them by default: \`bir up --restart\``
+                    : `segments are observed only — nothing is replaced (BIR_SEGMENT_ARM=0 where the recorder started)${health.intentArm === true ? "; whole plans may still start mid-task (BIR_INTENT_ARM=1)" : ""}`);
         const sessions = health.sessions ?? [];
         const probes = sessions.reduce((n, s) => n + (s.intent?.probes ?? 0), 0);
         const armed = sessions.reduce((n, s) => n + (s.intent?.armed ?? 0), 0);
@@ -3714,6 +3721,12 @@ async function replayCommand(args) {
     }
     out(`response    ${JSON.stringify(result.responseModel ?? {})}`);
     out(`steps       ${result.steps ?? 0}${result.partial ? " (partial — budget reached)" : ""}`);
+    // A plan's decision (the service's segmentsbreakdown.md SB-6): the steps
+    // from there are the half the recording took, so the run stops before them.
+    if (result.stopped?.reason === "decision") {
+        out(`stopped     before step ${result.stopped.step}${result.stopped.tool ? ` (${result.stopped.tool})` : ""}: ` +
+            "the plan's decision, which the agent makes — the steps from there did not run");
+    }
     return 0;
 }
 // ── wrap ───────────────────────────────────────────────────────────────────

package/dist/bin/investigate.d.ts

@@ -245,6 +245,13 @@ interface ServiceInvestigation {
             runId?: string | null;
         } | null;
         corrections?: ServiceCorrection[];
+        /**
+         * The step the plan stops in front of so that the agent decides, and the
+         * condition in words (the service's segmentsbreakdown.md SB-6). Null when
+         * the plan has none; absent from an older service.
+         */
+        decisionStep?: number | null;
+        decisionText?: string | null;
     } | null;
     executions?: Array<{
         id: string;
@@ -265,6 +272,8 @@ interface ServiceInvestigation {
             status: string;
             error?: string;
         }> | null;
+        /** Where a `fell_back` run handed over, and why (`decision`, …): null for any other run. */
+        fallbackKind?: string | null;
         /** The repeat the agent redid the task in, and its own calls there (AC1). */
         redoneByRunId?: string | null;
         redoneOwnCalls?: number | null;

package/dist/bin/investigate.js

@@ -203,8 +203,8 @@ export function findTurn(turns, id) {
 /** The runner's own gate vocabulary, with the cause and the fix (guide §9). */
 export const DECLINES = {
     replay_disabled: {
-        cause: "calculated replay was off in this bir-hooks (BIR_REPLAY=0), or a sub-task was handed out with BIR_SEGMENT_ARM off.",
-        fix: "start bir-hooks with BIR_REPLAY=1 (the default); for sub-tasks set BIR_SEGMENT_ARM=1.",
+        cause: "calculated replay was off in this bir-hooks (BIR_REPLAY=0), or a sub-task was handed out to a recorder that only observes sub-tasks (BIR_SEGMENT_ARM=0, or a recorder older than 0.3.19).",
+        fix: "start bir-hooks with BIR_REPLAY=1 (the default); for sub-tasks leave BIR_SEGMENT_ARM unset (on from 0.3.19), then `bir up --restart`.",
     },
     not_ready: {
         cause: "the matched recording had no ready scenario at that moment.",
@@ -246,6 +246,11 @@ export const DECLINES = {
         cause: "the plan was not ready before the hook that would have announced it had to answer: the prompt hook waits 7.5 s in all, match included, and a tool call that starts a plan mid-task waits 1.5 s. What arming waits for is the reading of the prompt's values (the derivation). A plan that was not announced is never run.",
         fix: "run the prompt again. If it keeps happening the reading is slow: the recorder's log (`bir status` names the file) shows when its `replay.derived` line landed, and a dry replay shows what the service's reading took, under `reading` (`bir scenario replay <scnId> --prompt \"…\" --dry --json`). BIR_HOOK_DERIVE_BUDGET_MS does not help here, because the hook's own limit was reached first. To read values on this machine instead of asking the service, set BIR_DERIVE_API_KEY where Claude Code starts.",
     },
+    // Nor this one: the control server's own rule (the service's offer1.md O8).
+    would_repeat: {
+        cause: "a plan the intent check matched would have started after the agent's call, not in its place, and its steps call that same tool: it would have made the call a second time — an e-mail sent twice (issue fx2). Never twice: it was not started, and the agent went on.",
+        fix: "nothing to fix in the plan. A scenario starts in the call's place only when the agent's call is its first step, value for value; one recorded in the order the agent works in (the agent's own run after a decision becomes one) is what starts there.",
+    },
     // Nor is this one: the match itself was late, so nothing was armed at all.
     match_late: {
         cause: "the service's answer to the match landed too late: after the prompt hook had stopped waiting for it (3 s, BIR_MATCH_BUDGET_MS); while prompts were not waiting on the match at all — after one slow answer they stop waiting for a few minutes (`replay.match_gate state=holding`); or with the hook not waiting from the start, because a failure to reach the service was still on record (a `service.degraded` line, perhaps hours before, and no `service.recovered` until after this prompt) or the match request's first attempt failed. The agent did the task itself.",
@@ -434,9 +439,11 @@ export function localFindings(turn) {
     }
     for (const i of turn.incidents) {
         const fields = Object.fromEntries(Object.entries(i).filter(([k]) => k !== "at" && k !== "event"));
+        // A stop at the plan's decision is the plan working as split: no fault.
+        const decisionStop = i.event === "replay.handover" && i.kind === "decision";
         out.push({
             code: i.event.replace(/\./g, "_"),
-            severity: i.event.endsWith("_failed") || i.event === "replay.failed" ? "problem" : "warn",
+            severity: i.event.endsWith("_failed") || i.event === "replay.failed" ? "problem" : decisionStop ? "info" : "warn",
             title: `${i.event}${i.error ? `: ${String(i.error)}` : ""}`,
             cause: Object.entries(fields)
                 .map(([k, v]) => `${k}=${String(v)}`)
@@ -447,13 +454,15 @@ export function localFindings(turn) {
                     : "the turn's cost could not be read from the transcript, or the runner has no price for the model: update it. Its report is unmeasured; run bir-hooks where the Claude Code transcript is readable."
                 : i.event === "replay.handover" && i.kind === "other_branch"
                     ? "this request was the other half of the task the plan holds (a step's test said so), and the agent did it; that run is how the service learns the other half."
-                    : i.event === "replay.diverge" || i.event === "replay.handover"
-                        ? "the model left the script or the runner handed the turn back; the service section shows what the fallback cost."
-                        : i.event === "run.incomplete"
-                            ? "the recording is not the whole run, so it is never calculated and no longer catches its prompt; run the task again to record it whole."
-                            : i.event === "run.host_failed"
-                                ? "the application's run failed; its recording is closed with that error and never becomes a plan."
-                                : "see the guide's troubleshooting table for this line.",
+                    : decisionStop
+                        ? "nothing to fix: the plan stopped at its decision, as planned. It ran the steps before it, and the agent chose the way. A segment of the half it chose may have run next (a `replay.intent_armed` line with kind segment); a `run.fragment` line with decision=true is the agent's own work, from which the service makes the other half."
+                        : i.event === "replay.diverge" || i.event === "replay.handover"
+                            ? "the model left the script or the runner handed the turn back; the service section shows what the fallback cost."
+                            : i.event === "run.incomplete"
+                                ? "the recording is not the whole run, so it is never calculated and no longer catches its prompt; run the task again to record it whole."
+                                : i.event === "run.host_failed"
+                                    ? "the application's run failed; its recording is closed with that error and never becomes a plan."
+                                    : "see the guide's troubleshooting table for this line.",
         });
     }
     const r = turn.reported;
@@ -536,6 +545,12 @@ export function savedPct(turn) {
     return baseline > 0 ? r.savedUsd / baseline : null;
 }
 const short = (id) => (id ? id.slice(0, 13) : "—");
+/**
+ * An execution's outcome, and where it handed the task over when the service
+ * says (`fell_back · decision`). The service sends `fallbackKind: null` for a
+ * run that did not hand over, and an older one sends nothing.
+ */
+const outcomeOf = (e) => typeof e.fallbackKind === "string" && e.fallbackKind !== "" ? `${e.outcome} · ${e.fallbackKind}` : e.outcome;
 /** 4624 → "4,624", whatever the machine's locale. */
 const count = (n) => String(n).replace(/\B(?=(\d{3})+(?!\d))/g, ",");
 const money = (v) => (v == null ? "—" : usd(v));
@@ -638,6 +653,10 @@ export function renderService(out, s, viewerIsOwner) {
         if (sc.held) {
             out(`            HELD since ${when(sc.held.at ?? undefined)}${sc.held.reason ? ` (${sc.held.reason})` : ""}: not handed out — the agent does the task until the plan is corrected or let go${sc.held.runId ? `; the redo is ${sc.held.runId}` : ""}`);
         }
+        if (typeof sc.decisionStep === "number") {
+            const text = typeof sc.decisionText === "string" ? sc.decisionText.replace(/\s+/g, " ").trim() : "";
+            out(`            decision at step ${sc.decisionStep}: the plan stops in front of it, and the agent decides${text ? ` (${text.length > 160 ? `${text.slice(0, 160)}…` : text})` : ""}`);
+        }
         for (const line of stepLines(sc.steps))
             out(`            ${line}`);
         const correction = newestCorrection(sc.corrections);
@@ -655,7 +674,7 @@ export function renderService(out, s, viewerIsOwner) {
     if (ex.length > 0) {
         out(`  executions (${ex.length}, newest first)`);
         for (const e of ex.slice(0, 10)) {
-            out(`    ${when(e.createdAt)}  ${short(e.id)}  ${e.outcome.padEnd(13)} cost ${usd(e.costUsd)}  saved ${money(e.savedUsd)}${e.savedPct != null ? ` (${pct(e.savedPct)})` : ""}${e.measured ? "" : "  unmeasured"}`);
+            out(`    ${when(e.createdAt)}  ${short(e.id)}  ${outcomeOf(e).padEnd(13)} cost ${usd(e.costUsd)}  saved ${money(e.savedUsd)}${e.savedPct != null ? ` (${pct(e.savedPct)})` : ""}${e.measured ? "" : "  unmeasured"}`);
             const failed = e.steps?.filter((st) => st.status === "failed") ?? [];
             for (const st of failed)
                 out(`        step ${st.stepIndex} ${st.toolName ?? ""} failed${st.error ? `: ${st.error.slice(0, 120)}` : ""}`);
@@ -790,7 +809,7 @@ export async function investigateCommand(args, deps) {
         if (rows.length === 0)
             out("  none yet");
         for (const e of rows) {
-            out(`  ${when(e.createdAt)}  ${e.id}  ${e.outcome.padEnd(13)} cost ${usd(e.costUsd)}  saved ${money(e.savedUsd)}${e.savedPct != null ? ` (${pct(e.savedPct)})` : ""}${e.measured ? "" : "  unmeasured"}`);
+            out(`  ${when(e.createdAt)}  ${e.id}  ${outcomeOf(e).padEnd(13)} cost ${usd(e.costUsd)}  saved ${money(e.savedUsd)}${e.savedPct != null ? ` (${pct(e.savedPct)})` : ""}${e.measured ? "" : "  unmeasured"}`);
             out(`      scenario ${e.scenarioId}${e.runId ? `  run ${e.runId}` : ""}${e.intent ? `  "${e.intent.slice(0, 60)}"` : ""}`);
         }
         out();

package/dist/bin/scenario-edit.js

@@ -1231,6 +1231,16 @@ function explain(reply, args, deps, e) {
             // newer entry puts the step back as this one left it, and then this one
             // can be undone. It used to loop, when undo only toggled (C23).
             const latest = typeof body.latestEditId === "string" ? body.latestEditId : "<the newer edit>";
+            if (latest.startsWith("ssplit_")) {
+                // The plan was split at its decision since (the service's
+                // segmentsbreakdown.md). No `--edit` takes a split back: its Undo is
+                // on the recording page's Split card, and only then can this go.
+                const what = aboutCorrection ? "correction" : "edit";
+                out(`${e.verb} (not_latest_edit): the plan was split at its decision after that ${what} (${latest}). ` +
+                    `It cannot be taken back while the split is in use: undo the split first (Undo on the Split card of the plan's recording page), then this ${what}:`);
+                out(`  bir scenario undo ${target} --edit ${e.editId ?? "<this edit>"}`);
+                return 1;
+            }
             out(aboutCorrection
                 ? `${e.verb} (not_latest_edit): the plan has changed since that correction — ${latest} changed it after. Undo the newer one first, then this one:`
                 : `${e.verb} (not_latest_edit): the ${aboutParam ? "parameter" : "step"} has changed since that edit — ${latest} changed it after. Undo the newer one first, then this one:`);

package/dist/control/recorder-main.d.ts

@@ -52,6 +52,21 @@ export declare function derivationKey(daemon?: boolean): {
     apiKey?: string;
     source?: string;
 };
+/**
+ * `BIR_SEGMENT_ARM`: whether a segment the service hands out may run mid-task.
+ * On unless it is `0`, from runner 0.3.19 (the service's segmentsbreakdown.md
+ * SB-21): segments found by repeated work, and the halves after a plan's
+ * decision. `0` is observe-only: what would have armed is logged, and nothing
+ * is replaced. While it is on, whole plans may start mid-task by intent too:
+ * `BIR_INTENT_ARM` follows it unless that is set.
+ */
+export declare function segmentArmFromEnv(env?: NodeJS.ProcessEnv): boolean;
+/**
+ * What the `replay.enabled` startup line says segments do. A segment starts
+ * only where the probe is waited on, so `BIR_INTENT_ARM=0` starts nothing
+ * mid-task, segments included — the rule `bir doctor` words from /health.
+ */
+export declare function segmentsAtStartup(segmentArm: boolean, env?: NodeJS.ProcessEnv): string;
 /** Where the two replay switches came from, for `/health` and `bir doctor`. */
 export type ReplaySource = "env" | "sidecar" | "default";
 /** What a recorder still serves (K4, `ControlServer.activity()`). */

package/dist/control/recorder-main.js

@@ -152,6 +152,27 @@ export function derivationKey(daemon = process.env[DAEMON_ENV] === "1") {
     }
     return {};
 }
+/**
+ * `BIR_SEGMENT_ARM`: whether a segment the service hands out may run mid-task.
+ * On unless it is `0`, from runner 0.3.19 (the service's segmentsbreakdown.md
+ * SB-21): segments found by repeated work, and the halves after a plan's
+ * decision. `0` is observe-only: what would have armed is logged, and nothing
+ * is replaced. While it is on, whole plans may start mid-task by intent too:
+ * `BIR_INTENT_ARM` follows it unless that is set.
+ */
+export function segmentArmFromEnv(env = process.env) {
+    return env.BIR_SEGMENT_ARM !== "0";
+}
+/**
+ * What the `replay.enabled` startup line says segments do. A segment starts
+ * only where the probe is waited on, so `BIR_INTENT_ARM=0` starts nothing
+ * mid-task, segments included — the rule `bir doctor` words from /health.
+ */
+export function segmentsAtStartup(segmentArm, env = process.env) {
+    if (!segmentArm)
+        return "observed only (BIR_SEGMENT_ARM=0)";
+    return env.BIR_INTENT_ARM === "0" ? "observed only (BIR_INTENT_ARM=0)" : "run mid-task";
+}
 /**
  * Assemble the replay configuration (docs/calculatedReplay.md §5.3 of the guide).
  *
@@ -204,19 +225,21 @@ function buildReplayOptions(keeper, policy, key) {
         intentMatch: {
             enabled: process.env.BIR_INTENT_MATCH !== "0",
             // The probe's own ceiling, not a wait on the hook's path: `PreToolUse`
-            // sends it and answers without it (hit counting only) unless arming is
-            // on (BIR_SEGMENT_ARM=1 or BIR_INTENT_ARM=1), and then waits at most
+            // waits for it only while arming is on — the default, unless
+            // BIR_SEGMENT_ARM=0 or BIR_INTENT_ARM=0 — and then at most
             // BIR_INTENT_ARM_BUDGET_MS (500 ms), never while the service is failing
-            // (control/server.ts). 4 000 leaves a request whose best segment lands
-            // in the not-clear band its one live question under the service's own
-            // 2 500 ms attempt (segmented.md R-HIT-11).
+            // (control/server.ts); otherwise it answers without it (hit counting
+            // only). 4 000 leaves a request whose best segment lands in the
+            // not-clear band its one live question under the service's own 2 500 ms
+            // attempt (segmented.md R-HIT-11).
             budgetMs: positiveInt(process.env.BIR_INTENT_MATCH_BUDGET_MS, 4_000),
             maxPerTurn: positiveInt(process.env.BIR_INTENT_MATCHES_PER_TURN, 3),
             maxRequestsPerTurn: positiveInt(process.env.BIR_INTENT_REQUESTS_PER_TURN, 40),
         },
-        // Observe-only until an operator has read the logs and turned it on
-        // (segmented.md R-OUT-10, R-LIFE-7). Arming is never the way to find out.
-        segmentArm: process.env.BIR_SEGMENT_ARM === "1",
+        // On by default from 0.3.19 (the service's segmentsbreakdown.md SB-21): a
+        // plan that stops at its decision hands the rest to segments of each half,
+        // and they run only mid-task. BIR_SEGMENT_ARM=0 brings back observe-only.
+        segmentArm: segmentArmFromEnv(),
         // Both read live, never captured (C5). The recorder signs in after it
         // listens, refreshes the token as the session outlives it, and may sign
         // in or out while it runs; replay reads whatever holds *now*. The old
@@ -247,6 +270,8 @@ function buildReplayOptions(keeper, policy, key) {
                     ? "the service"
                     : "recorded sample values — sign in, or a scenario with a target will not run"),
             intentMatch: opts.intentMatch?.enabled ? "on" : "off",
+            // Whether a segment the service hands out runs, or is only logged.
+            segments: segmentsAtStartup(opts.segmentArm === true),
             source,
             why: "a prompt that matches a calculated scenario runs it: the scenario's own steps run without a " +
                 "permission prompt of their own (never in plan mode); every other tool call is asked about as " +

package/dist/control/server.d.ts

@@ -276,12 +276,13 @@ export interface ControlServerOptions {
      * (fallbk.md §Runner 4).
      *
      * Arming there means *waiting* there, on every unsteered tool call, for a
-     * service round trip — so by default the probe is sent without waiting, for
-     * hit counting only, and nothing arms mid-turn. It waits (at most
-     * `BIR_INTENT_ARM_BUDGET_MS`, 500 ms, and never while the service is failing)
-     * when segment arming is on (`BIR_SEGMENT_ARM=1`), or when `BIR_INTENT_ARM=1`
-     * asks for whole-scenario intent arming as before. `BIR_INTENT_ARM=0` never
-     * waits.
+     * service round trip. It waits (at most `BIR_INTENT_ARM_BUDGET_MS`, 500 ms,
+     * and never while the service is failing) when segment arming is on — the
+     * recorder's default from 0.3.19, `BIR_SEGMENT_ARM` unset or `1` — or when
+     * `BIR_INTENT_ARM=1` asks for whole-scenario intent arming. `BIR_INTENT_ARM=0`
+     * never waits. Otherwise, as in a server built with neither (a test, an
+     * embedder), the probe is sent without waiting, for hit counting only, and
+     * nothing arms mid-turn.
      */
     intentArm?: boolean;
     /**
@@ -1154,14 +1155,19 @@ export declare class ControlServer {
      */
     private excludeRunsFor;
     /**
-     * Per recording a plan of this turn came from, how far that plan got
-     * (segmented.md R-OUT-6).
+     * Per plan of this turn, its recording and how far the plan got in its own
+     * chain (segmented.md R-OUT-6).
      *
      * 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 largest position per recording wins, and 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.
+     * 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.
      *
      * Rebuilt on every probe rather than cached: a plan that hands over between
      * two calls changes the answer.
@@ -1196,6 +1202,70 @@ export declare class ControlServer {
      * computed is "no" — the directive then rides on the call's PostToolUse.
      */
     private isFirstStep;
+    /**
+     * 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.
+     */
+    private firstStepVerdict;
+    /**
+     * 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.
+     */
+    private planCallsTool;
+    /**
+     * 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.
+     */
+    private noteDecision;
+    /**
+     * 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.
+     */
+    private fetchNext;
+    /**
+     * 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.
+     */
+    private armNext;
+    /**
+     * 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.
+     */
+    private tryNextScenarios;
+    /** A next scenario's hit: bookkeeping as for any plan armed mid-task, then its directive in the call's place. */
+    private nextHit;
+    /**
+     * 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}).
+     */
+    private closeDecisionFragment;
+    /**
+     * End this turn's next scenarios (offer1.md O6): every one but the hit is
+     * never announced, so never runs and is never reported.
+     */
+    private endNext;
     /**
      * Whether an intent probe may arm a plan in its own `PreToolUse` — and so
      * whether that hook waits for it. See {@link ControlServerOptions.intentArm}.
@@ -1212,6 +1282,16 @@ export declare class ControlServer {
      * whose intent-armed plan handed over is recording the model's work anyway.
      */
     private noteHandover;
+    /**
+     * 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.
+     */
+    private dropDecisionFragment;
     /**
      * Open the fragment run and record from this call on (fallbk.md D7).
      *