@basein/runner 0.3.21 → 0.3.23

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

@@ -104,22 +104,18 @@
  *                             found (default 5; 0 off)
  *   BIR_INTENT_SOURCES        which text a step's intent may come from
  *                             (default text,thinking,tool)
- *   BIR_INTENT_REQUESTS_PER_TURN  probes one turn may send (default 40).
- *                             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 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           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_INTENT_ARM            1 lets a whole plan whose intent matches the
+ *                             agent's reasoning mid-turn arm in the place of the
+ *                             call. Unset (or 0) is off: no probe is sent and
+ *                             nothing arms mid-turn
+ *   BIR_INTENT_ARM_BUDGET_MS  how long a call waits for that probe (default 500)
+ *   BIR_CONTINUATIONS         0 stops asking, after a plan handed over, for the
+ *                             plan of the work recorded after an earlier
+ *                             hand-over at that step (default on: one request
+ *                             per hand-over; it runs only when the agent's next
+ *                             call is its first step)
+ *   BIR_INTENT_REQUESTS_PER_TURN  probes one turn may send (default 40)
+ *   BIR_INTENT_MATCH_BUDGET_MS  one intent probe's own ceiling (default 1500)
  *   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

@@ -104,22 +104,18 @@
  *                             found (default 5; 0 off)
  *   BIR_INTENT_SOURCES        which text a step's intent may come from
  *                             (default text,thinking,tool)
- *   BIR_INTENT_REQUESTS_PER_TURN  probes one turn may send (default 40).
- *                             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 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           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_INTENT_ARM            1 lets a whole plan whose intent matches the
+ *                             agent's reasoning mid-turn arm in the place of the
+ *                             call. Unset (or 0) is off: no probe is sent and
+ *                             nothing arms mid-turn
+ *   BIR_INTENT_ARM_BUDGET_MS  how long a call waits for that probe (default 500)
+ *   BIR_CONTINUATIONS         0 stops asking, after a plan handed over, for the
+ *                             plan of the work recorded after an earlier
+ *                             hand-over at that step (default on: one request
+ *                             per hand-over; it runs only when the agent's next
+ *                             call is its first step)
+ *   BIR_INTENT_REQUESTS_PER_TURN  probes one turn may send (default 40)
+ *   BIR_INTENT_MATCH_BUDGET_MS  one intent probe's own ceiling (default 1500)
  *   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-scenario.js

@@ -488,7 +488,7 @@ class BadArguments extends Error {
 }
 const TARGET = {
     type: "string",
-    description: "A scn_ id, or the run_ id of a whole-run scenario (a sub-task scenario has only its scn_ id) — as investigate and scenario_show print them.",
+    description: "A scn_ id, or the run_ id of the recording it was calculated from — as investigate and scenario_show print them.",
 };
 const STEP = {
     type: "integer",

package/dist/bin/bir.js

@@ -114,7 +114,7 @@ Commands:
                                     a scenario: intent, params, steps (--step: just that one)
   scenario calc <runId|scnId> [--force [--discard-edits]]
                                     calculate (or re-derive) a run's scenario; a scn_ id
-                                    (a sub-task's too) is recalculated in place, with --force
+                                    is recalculated in place, with --force
   scenario check <runId|scnId> --step <n> [--input-logic <file|->] [--output-logic <file|->] [--unfreeze]
                                     try a change to one step against the recording; saves nothing
   scenario edit <runId|scnId> --step <n> [--input-logic <file|->] [--output-logic <file|->]
@@ -3118,20 +3118,6 @@ 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 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);
@@ -3721,12 +3707,6 @@ 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,13 +245,6 @@ 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;
@@ -272,8 +265,6 @@ 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

@@ -35,7 +35,6 @@ const INCIDENTS = new Set([
     "replay.arm_failed",
     "replay.derive_failed",
     "replay.compose_failed",
-    "replay.flatten_failed",
     "replay.thread_failed",
     "replay.step_failed",
     "replay.failed",
@@ -203,8 +202,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 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`.",
+        cause: "calculated replay was off in this bir-hooks (BIR_REPLAY=0).",
+        fix: "start bir-hooks with BIR_REPLAY=1 (the default).",
     },
     not_ready: {
         cause: "the matched recording had no ready scenario at that moment.",
@@ -222,16 +221,12 @@ export const DECLINES = {
     },
     known_bad_first_step: {
         cause: "the chain's first step is parked after repeated failures.",
-        fix: "wait: the service retries it once an hour for a day, then repairs the plan from the next run of the prompt — unless the plan has steps edited by hand, or is a sub-task, which it does not repair on its own. To repair now: `bir scenario calc <scnId> --force` (add --discard-edits to drop hand edits), or fix the step: `bir scenario edit <scnId> --step 0 --input-logic <file>`. `bir investigate <scnId>` names the scenario id.",
+        fix: "wait: the service retries it once an hour for a day, then repairs the plan from the next run of the prompt — unless the plan has steps edited by hand, which it does not repair on its own. To repair now: `bir scenario calc <scnId> --force` (add --discard-edits to drop hand edits), or fix the step: `bir scenario edit <scnId> --step 0 --input-logic <file>`. `bir investigate <scnId>` names the scenario id.",
     },
     nondeterministic_first_step: {
         cause: "the chain's first step needs a judgement the calculation could not write code for, so the plan cannot start.",
         fix: "if its code only has a slip, fix the step yourself: read it with `bir scenario show <scnId> --step 0`, write the input logic to a file, and run `bir scenario edit <scnId> --step 0 --input-logic <file>`; the service checks it against the recording before it saves it. A real judgement — a choice with no fixed rule — stays with the agent until a model step exists (plan-services.md W3.1).",
     },
-    unusable_first_step: {
-        cause: "the first step calls a sub-task that is gone, switched off or stale.",
-        fix: "enable or recalculate that sub-task, or recalculate this scenario.",
-    },
     missing_target: {
         cause: "the plan needs a target — a value a prompt must name, such as a file, a table or a region — and the prompt did not name it. A replay never takes a target from the recording.",
         fix: 'name it in the prompt. If the value is the same every time — a database, a host, a working folder — it is a setting, not a target: `bir scenario edit <scnId> --param <name> --kind setting --note "why"` lets the runner use its recorded value when a prompt names none (`bir scenario show <scnId>` lists the parameters and their kinds).',
@@ -246,11 +241,6 @@ 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.",
@@ -264,10 +254,6 @@ export const DECLINES = {
         cause: "the service matched the prompt and handed over no plan: this runner is older than its plans need.",
         fix: "update the runner (`bir update`), then run `bir setup` in each project that uses it; `bir doctor` says when the service is satisfied.",
     },
-    flatten_failed: {
-        cause: "the chain could not be flattened — a sub-task it calls no longer resolves.",
-        fix: "recalculate the scenario.",
-    },
     // The gates of a host that is not Claude Code (a LangChain application).
     host_records_only: {
         cause: "the runner in that application's folder is older than replay for LangChain needs, so the LangChain package only records.",
@@ -439,11 +425,9 @@ 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" : decisionStop ? "info" : "warn",
+            severity: i.event.endsWith("_failed") || i.event === "replay.failed" ? "problem" : "warn",
             title: `${i.event}${i.error ? `: ${String(i.error)}` : ""}`,
             cause: Object.entries(fields)
                 .map(([k, v]) => `${k}=${String(v)}`)
@@ -454,15 +438,13 @@ 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."
-                    : 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.",
+                    : 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;
@@ -545,12 +527,6 @@ 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));
@@ -653,10 +629,6 @@ 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);
@@ -674,7 +646,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)}  ${outcomeOf(e).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)}  ${e.outcome.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)}` : ""}`);
@@ -702,7 +674,7 @@ function stepLines(steps) {
         if (st.correctionId)
             parts.push(`${st.correctionKind ?? "changed"} by correction ${st.correctionId}`);
         if (parts.length > 0)
-            lines.push(`step ${st.stepIndex} ${st.toolName ?? "(a sub-task)"}: ${parts.join("; ")}`);
+            lines.push(`step ${st.stepIndex} ${st.toolName ?? "?"}: ${parts.join("; ")}`);
     }
     return lines;
 }
@@ -809,7 +781,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}  ${outcomeOf(e).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}  ${e.outcome.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

@@ -100,9 +100,8 @@ export async function scenarioEditCommand(args, deps) {
 }
 /**
  * The raw JSON, as it always was — scripts and the guide read it. A `scn_` id
- * goes to `GET /scenarios/:id`, which also serves sub-task scenarios (they have
- * no run of their own); `--step` narrows the print to that one step object,
- * with the scenario's id and `chainRevision` put in front of it. The revision
+ * goes to `GET /scenarios/:id`; `--step` narrows the print to that one step
+ * object, with the scenario's id and `chainRevision` put in front of it. The revision
  * is a scenario's, not a step's, and it is what `edit --revision` (and the MCP
  * `scenario_edit`'s `revision`) takes: a step printed without it sent the model
  * that had just read the step off to guess one (C20).
@@ -130,7 +129,7 @@ async function show(args, deps) {
     const served = reply.body;
     const scenario = served?.scenario;
     if (!scenario)
-        return noWholeRunScenario(target, served?.segments, args, deps);
+        return noScenario(target, args, deps);
     if (!Array.isArray(scenario.steps)) {
         out(`${scenario.id ?? target} is ${scenario.state ?? "not ready"}, so it has no steps to show yet.`);
         return 1;
@@ -510,7 +509,7 @@ function inputPhrase(status, verifiable) {
         case "not_checked":
             return verifiable
                 ? "not checked: the recorded call is plain text, not an object"
-                : "not checked: the step comes after a sub-task call, whose outputs the check cannot rebuild";
+                : "not checked: the recording holds no call to check this step against";
         case "differs":
             return "differs from the recorded call";
         case "throws":
@@ -955,12 +954,10 @@ function paramUndone(answer, editId, target, args, deps) {
  * step from the recording, so the service refuses `--force` on a plan with
  * hand edits (D4) unless `--discard-edits` says to throw them away.
  *
- * A `run_` id posts `/recordings/runs/:id/calculate`, which reaches only the
- * run's **whole-run** scenario. A `scn_` id posts `/scenarios/:id/recalculate`
- * — the only way to recalculate a sub-task (segment) scenario from here, and
- * so the only way to take a segment's hand edits back once undo cannot (C12).
- * A scenario id always names one that exists, so it is always a
- * recalculation in place, and asks for `--force` as the run form does.
+ * A `run_` id posts `/recordings/runs/:id/calculate`. A `scn_` id posts
+ * `/scenarios/:id/recalculate`. A scenario id always names one that exists,
+ * so it is always a recalculation in place, and asks for `--force` as the run
+ * form does.
  */
 async function calc(args, deps) {
     const { out } = deps;
@@ -1106,28 +1103,13 @@ function localFailure(args, deps, code, text, extra = {}) {
     deps.out(args.json ? jsonText({ error: code, details: text, ...extra }) : text);
     return 1;
 }
-/**
- * A run with no whole-run scenario. When sub-task (segment) scenarios were
- * calculated from it, they are listed with their `scn_` ids — the only ids
- * they have — instead of suggesting a calculation, which would start a new
- * whole-run plan beside them rather than reach the one the person meant (C21).
- */
-function noWholeRunScenario(target, segments, args, deps) {
-    const listed = (Array.isArray(segments) ? segments : []).filter((s) => typeof s?.id === "string");
-    if (listed.length === 0) {
-        return localFailure(args, deps, "no_scenario", `${target} has no calculated scenario yet — \`bir scenario calc ${target}\` first.`);
-    }
-    const range = (s) => typeof s.stepFrom === "number" && typeof s.stepTo === "number" ? `  steps ${s.stepFrom}–${s.stepTo} of the recording` : "";
-    const text = [
-        `${target} has no whole-run scenario, only sub-task scenarios — and a sub-task scenario is addressed by its own scn_ id:`,
-        ...listed.map((s) => `  ${s.id}${range(s)}`),
-    ].join("\n");
-    return localFailure(args, deps, "no_whole_run_scenario", text, { segments: listed.map((s) => s.id) });
+/** A run with no calculated scenario yet. */
+function noScenario(target, args, deps) {
+    return localFailure(args, deps, "no_scenario", `${target} has no calculated scenario yet — \`bir scenario calc ${target}\` first.`);
 }
 /**
  * A `run_` id is the recording's; the routes that change a scenario take its
- * `scn_` id (D7). A `run_` id reaches only the run's **whole-run** scenario; a
- * `scn_` id is used as it is — sub-task scenarios have nothing else.
+ * `scn_` id (D7), and a `scn_` id is used as it is.
  */
 async function resolveTarget(target, args, deps, clock = new ReadClock()) {
     if (target.startsWith("scn_"))
@@ -1145,7 +1127,7 @@ async function resolveTarget(target, args, deps, clock = new ReadClock()) {
     const served = reply.body;
     const id = served?.scenario?.id;
     if (typeof id !== "string")
-        return { code: noWholeRunScenario(target, served?.segments, args, deps) };
+        return { code: noScenario(target, args, deps) };
     return { id };
 }
 /**
@@ -1199,9 +1181,6 @@ function explain(reply, args, deps, e) {
             out(`${e.verb} (invalid_input): the service found the request invalid${details ? ` — ${details}` : ""}.`);
             return 1;
         }
-        case "not_a_tool_step":
-            out(`${e.verb} (not_a_tool_step): step ${e.step ?? "?"} is a sub-task call row, not a tool step. Call rows belong to the service; only tool steps can be edited.`);
-            return 1;
         case "nothing_to_change":
             // The empty command is refused on this side before any request, so a
             // service `nothing_to_change` always means the change is already the
@@ -1231,16 +1210,6 @@ 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/pin-guard.d.ts

@@ -85,4 +85,20 @@ export declare function commandShape(command: string, depth?: number, escape?: s
  * only the general rule is applied there.
  */
 export declare function pinCompatible(toolName: string, modelArgs: unknown, pinnedArgs: unknown, otherHost?: boolean): PinVerdict;
+/**
+ * Whether the model's own call is a continuation's first step: the same call,
+ * not only the same kind of call (the service's fallbk.md Part 3).
+ *
+ * Stricter than {@link pinCompatible}, on purpose. A pin takes a call the
+ * model was told to make — the directive named the step — and one argument in
+ * common is enough to know it is that call. A continuation starts on a call
+ * nobody told the model to make: after a hand-over, the call is the model's
+ * own choice of what to do next, and the plan may run only when that choice
+ * is the one the recording made. Looking up another person, restarting
+ * another worker, reading another file is another choice. So the call must
+ * pass the pin guard, share at least one argument with the step, and hold
+ * the same value in every argument they share — text compared without
+ * surrounding space or letter case, anything else exactly.
+ */
+export declare function sameFirstCall(toolName: string, modelArgs: unknown, stepArgs: unknown): PinVerdict;
 //# sourceMappingURL=pin-guard.d.ts.map

package/dist/control/pin-guard.js

@@ -545,4 +545,40 @@ export function pinCompatible(toolName, modelArgs, pinnedArgs, otherHost = false
         ? { ok: true }
         : { ok: false, why: "it shares no argument with the step" };
 }
+/**
+ * Whether the model's own call is a continuation's first step: the same call,
+ * not only the same kind of call (the service's fallbk.md Part 3).
+ *
+ * Stricter than {@link pinCompatible}, on purpose. A pin takes a call the
+ * model was told to make — the directive named the step — and one argument in
+ * common is enough to know it is that call. A continuation starts on a call
+ * nobody told the model to make: after a hand-over, the call is the model's
+ * own choice of what to do next, and the plan may run only when that choice
+ * is the one the recording made. Looking up another person, restarting
+ * another worker, reading another file is another choice. So the call must
+ * pass the pin guard, share at least one argument with the step, and hold
+ * the same value in every argument they share — text compared without
+ * surrounding space or letter case, anything else exactly.
+ */
+export function sameFirstCall(toolName, modelArgs, stepArgs) {
+    const verdict = pinCompatible(toolName, modelArgs, stepArgs);
+    if (!verdict.ok)
+        return verdict;
+    const model = record(modelArgs);
+    const step = record(stepArgs);
+    const shared = Object.keys(model).filter((key) => Object.prototype.hasOwnProperty.call(step, key));
+    if (shared.length === 0) {
+        return stableStringify(model) === stableStringify(step)
+            ? { ok: true }
+            : { ok: false, why: "it shares no argument with the step" };
+    }
+    const differs = shared.find((key) => !sameValue(model[key], step[key]));
+    return differs === undefined ? { ok: true } : { ok: false, why: `its ${differs} is not the step's` };
+}
+function sameValue(a, b) {
+    if (typeof a === "string" && typeof b === "string") {
+        return a.trim().toLowerCase() === b.trim().toLowerCase();
+    }
+    return stableStringify(a) === stableStringify(b);
+}
 //# sourceMappingURL=pin-guard.js.map

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

@@ -52,21 +52,6 @@ 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

@@ -85,9 +85,8 @@ function wrappedServersFor(cwd) {
  * `BIR_INTENT_SOURCES` — which text a step's intent may be read from
  * (segmented.md R-INTENT-3). Unset or unparseable means all three.
  *
- * It governs only what is *sent*. Turning every source off does not stop a
- * probe: the request still goes out with an empty text and the server builds a
- * line from the tool name and arguments (R-HIT-4).
+ * It governs only what is *sent*. With every source off, a step goes out with
+ * no text, and no intent probe is sent for it.
  */
 function parseIntentSources(value) {
     if (value === undefined)
@@ -152,33 +151,12 @@ 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).
  *
  * There is no steer threshold: a match the service hands out is steered
  * (controller.ts, gate 4). A recorder started with `BIR_MIN_STEER_SIMILARITY`
- * or `BIR_MIN_SEGMENT_STEER_SIMILARITY` set ignores them.
+ * set ignores it.
  */
 function buildReplayOptions(keeper, policy, key) {
     // The environment still wins — an operator at a terminal is the most
@@ -227,22 +205,14 @@ function buildReplayOptions(keeper, policy, key) {
         // BIR_INTENT_MATCH=0 turns it off on its own.
         intentMatch: {
             enabled: process.env.BIR_INTENT_MATCH !== "0",
-            // The probe's own ceiling, not a wait on the hook's path: `PreToolUse`
-            // waits for it only while arming is on — the default, unless
-            // BIR_SEGMENT_ARM=0 or BIR_INTENT_ARM=0 — and then at most
+            // The probe's own ceiling, not a wait on the hook's path: a probe is sent
+            // only with BIR_INTENT_ARM=1, and `PreToolUse` waits for it at most
             // BIR_INTENT_ARM_BUDGET_MS (500 ms), never while the service is failing
-            // (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),
+            // (control/server.ts).
+            budgetMs: positiveInt(process.env.BIR_INTENT_MATCH_BUDGET_MS, 1_500),
             maxPerTurn: positiveInt(process.env.BIR_INTENT_MATCHES_PER_TURN, 3),
             maxRequestsPerTurn: positiveInt(process.env.BIR_INTENT_REQUESTS_PER_TURN, 40),
         },
-        // 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
@@ -282,8 +252,6 @@ 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 " +