@basein/runner 0.3.18 → 0.3.19

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.",
@@ -434,9 +434,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 +449,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 +540,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 +648,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 +669,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 +804,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.
@@ -1212,6 +1218,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).
      *

package/dist/control/server.js

@@ -946,7 +946,9 @@ export class ControlServer {
                     lastStepHit: s.run.intent.lastStepHit ?? null,
                 }
                 : null,
-            fragment: s.run?.fragment ? { state: s.run.fragment.state } : null,
+            fragment: s.run?.fragment
+                ? { state: s.run.fragment.state, ...(s.run.fragment.decision ? { decision: true } : {}) }
+                : null,
             // The service's offer to record the turn as a recording's newest run,
             // and what became of it (newestRun.md).
             repeat: s.run?.repeat ? { state: s.run.repeat.state, of: s.run.repeat.runId } : null,
@@ -964,6 +966,10 @@ export class ControlServer {
             // 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,
@@ -2095,6 +2101,12 @@ 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 —
@@ -3021,11 +3033,21 @@ export class ControlServer {
             // 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;
             }
@@ -3047,11 +3069,15 @@ export class ControlServer {
             });
             if (!report)
                 return;
-            if (state.armedBy === "intent") {
+            if (state.armedBy === "intent" || atDecision) {
                 logDetail("replay.done", {
                     scenario: state.scenarioId ?? undefined,
                     windowMs: Math.max(0, windowMs),
-                    billedTo: state.retiredMark !== undefined ? "its own retire" : "the next arm or the turn",
+                    billedTo: atDecision
+                        ? "its decision"
+                        : 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:
@@ -3696,8 +3722,12 @@ export class ControlServer {
                 ? undefined
                 : await this.tryIntentMatch(session, run, toolName, intent, modelArgs);
             if (armed) {
-                if (!overran)
+                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);
                     return armed;
+                }
                 const late = run.replay;
                 if (late && late.armedBy === "intent" && late.plan && !late.retired) {
                     logLine("replay.decision", {
@@ -3714,9 +3744,14 @@ export class ControlServer {
             // 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.
-            if (run.fragment?.state === "due" && !run.pendingDirective) {
-                await this.openFragment(session, run, reasoning, toolName, modelArgs);
+            //    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);
             }
         }
         // The arguments that will actually run — which is what must be correlated and
@@ -4314,14 +4349,19 @@ export class ControlServer {
         return [...out];
     }
     /**
-     * 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.
@@ -4354,15 +4394,15 @@ export class ControlServer {
             }
             if (position === undefined)
                 continue;
-            const seen = best.get(recording);
+            const seen = best.get(state.scenarioId);
             if (!seen || position > seen.position) {
-                best.set(recording, { position, scenarioId: state.scenarioId });
+                best.set(state.scenarioId, { runId: recording, position });
             }
         }
-        return [...best].map(([runId, v]) => ({
-            runId,
+        return [...best].map(([scenarioId, v]) => ({
+            runId: v.runId,
             position: v.position,
-            scenarioId: v.scenarioId,
+            scenarioId,
         }));
     }
     /**
@@ -4446,7 +4486,10 @@ export class ControlServer {
             stepPosition: run.ordering.next,
             excludeRuns: this.excludeRunsFor(run),
             ranThrough: this.ranThroughFor(run),
-            ...(this.replay.segmentArm ? { acceptSegments: true } : {}),
+            // 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.
@@ -4534,6 +4577,9 @@ export class ControlServer {
         // the jail it may not leave (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
@@ -4699,7 +4745,35 @@ export class ControlServer {
         const h = state?.handover;
         if (!h || !state?.scenarioId)
             return;
-        run.fragment = { scenarioId: state.scenarioId, stepIndex: h.stepIndex, state: "due" };
+        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",
+        });
     }
     /**
      * Open the fragment run and record from this call on (fallbk.md D7).
@@ -4719,9 +4793,14 @@ 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).
+        const decisionOf = f.decision ? { scenarioId: f.scenarioId, stepIndex: f.stepIndex } : undefined;
         // 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 }, framework ? { fallbackOf, framework } : { fallbackOf });
+        const id = this.recorder.startRun(input, { ...this.runMetadata(session), fallbackOf, ...(decisionOf ? { decisionOf } : {}) }, framework ? { fallbackOf, framework } : { fallbackOf });
         for (const c of run.correlations.values()) {
             c.settled = true;
             if (c.fallback)
@@ -4738,6 +4817,7 @@ 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))