@basein/runner 0.3.20 → 0.3.22

package/README.md

@@ -360,13 +360,13 @@ same command, the same file, the same kind of arguments); any other call runs as
 written and is asked about as usual. A *directly executed* step never reaches the
 permission system at all — it is dispatched to a `bir-proxy` and called on a
 connection that is already open, or, for Claude Code's own `Read`, `Glob`,
-`Grep`, `Edit`, `Write` and `Bash`, run by the recorder itself in the project
-folder — and `run_scenario`, the call that starts the
+`Grep`, `Edit`, `Write` and `Bash`, run by the recorder itself from the project
+folder, on any file the agent could reach — and `run_scenario`, the call that starts the
 run, is answered `allow` while the recorder has announced the plan. In plan mode
 nothing is announced and nothing is approved. Set `BIR_REPLAY_ALLOW_SERVERS` to
 the servers you are content to have called unattended (it also covers a steered
-plan's recovery), `BIR_BUILTIN_TOOLS` and `BIR_BASH_ALLOW` to the built-ins and
-commands, and read [the guide's §5.1](docs/calculatedReplayGuide.md)
+plan's recovery), `BIR_BUILTIN_TOOLS`, `BIR_PATH_ALLOW` and `BIR_BASH_ALLOW` to
+the built-ins, folders and commands, and read [the guide's §5.1](docs/calculatedReplayGuide.md)
 before enabling it anywhere that matters.
 
 What it buys: on a scenario whose every step is a wrapped MCP tool or one of
@@ -489,8 +489,9 @@ what to do when they register, so there is one switch and no second copy of it:
 |---|---|
 | `BIR_REPLAY` | `0` turns replay off and any other value on, over the project's stored switch (`bir replay on` / `off`; a first plain `bir install` stores off). Nothing below matters while it is off. |
 | `BIR_REPLAY_ALLOW_SERVERS` | Server keys bir may call unattended: **direct** execution, and a steered plan's recovery. Unset means the list `bir replay allow` stored for the project, else every wrapped server; narrowing it is the recommendation. |
-| `BIR_BUILTIN_TOOLS` | Built-in tools bir may execute itself during a replay — in the session's own project directory, and confined to it. Default all six: `Read,Glob,Grep,Edit,Write,Bash` (up to 0.3.7 only the read-only `Read,Glob,Grep`). A runner-side step never reaches Claude Code's permission prompts, so leave off the list any tool you want the model to call itself. `none` turns it off, and built-in steps are steered in the session. |
+| `BIR_BUILTIN_TOOLS` | Built-in tools bir may execute itself during a replay — from the session's own project directory; which folders the file tools may touch is `BIR_PATH_ALLOW`. Default all six: `Read,Glob,Grep,Edit,Write,Bash` (up to 0.3.7 only the read-only `Read,Glob,Grep`). A runner-side step never reaches Claude Code's permission prompts, so leave off the list any tool you want the model to call itself. `none` turns it off, and built-in steps are steered in the session. |
 | `BIR_BASH_ALLOW` | Command prefixes a runner-side `Bash` step may run. Unset means any command (`*`); a list such as `git,npm test` narrows it; `none` allows no command, and `Bash` steps are then steered in the session. A plan's Bash steps share a working directory, as Claude Code's do (variables and functions do not persist, also as in Claude Code). |
+| `BIR_PATH_ALLOW` | Folders a runner-side `Read`, `Glob`, `Grep`, `Edit` or `Write` may touch. Unset means any folder (`*`), as the agent's own tools: a plan that reads the agent's memory file under `~/.claude` runs (from 0.3.21; up to 0.3.20 only the project directory). `project` keeps them inside the session's project directory; add folders after a comma, `~` for your home folder: `project,~/.claude`. `none` allows no folder, and file steps are then steered in the session. |
 | `BIR_DERIVE_API_KEY` | **Optional.** Working out what a new request is about — which fleet, which file, which date — is done for you by the service on its own key, as long as you are signed in. Set this (an Anthropic key) only to keep that reading on your machine, on your key. Signed out *and* unset, a scenario whose values change between requests is declined rather than replayed on stale ones. |
 | `ANTHROPIC_API_KEY` | Not used by the background recorder, which has Claude Code's environment and would bill your own key — unless `BIR_USE_ANTHROPIC_API_KEY=1`. A `bir-hooks` run by hand in a terminal uses that terminal's key. |
 | `BIR_DERIVE_MODEL` | Derivation model, when you set a key of your own (default `claude-haiku-4-5-20251001`). |

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

@@ -62,9 +62,9 @@
  *   BIR_REPLAY_ALLOW_SERVERS  comma-separated server keys eligible for *direct*
  *                             execution. Unset means every wrapped server
  *   BIR_BUILTIN_TOOLS         comma-separated built-ins the runner may execute
- *                             itself during a replay, in the session's own
- *                             project directory and confined to it
- *                             (replay/builtins.ts). Default all six:
+ *                             itself during a replay, from the session's own
+ *                             project directory (replay/builtins.ts; which
+ *                             folders: BIR_PATH_ALLOW). Default all six:
  *                             Read,Glob,Grep,Edit,Write,Bash. A runner-side
  *                             step never reaches the host's permission
  *                             prompts; Read,Glob,Grep is the read-only set
@@ -73,6 +73,13 @@
  *   BIR_BASH_ALLOW            command prefixes a runner-side Bash step may run
  *                             (`*` for all). Unset means `*`; `none` means no
  *                             command, and Bash steps are steered
+ *   BIR_PATH_ALLOW            folders a runner-side Read, Glob, Grep, Edit or
+ *                             Write may touch (`*` for any). Unset means `*`:
+ *                             any path, as the agent's own tools (up to 0.3.20
+ *                             the project directory alone). `project` is the
+ *                             session's project directory, `~` the home
+ *                             folder: `project,~/.claude`. `none` means no
+ *                             folder, and the file steps are steered
  *   BIR_DERIVE_API_KEY        OPTIONAL. Derivation — reading what this turn acts
  *                             on — is done by the service for a signed-in
  *                             runner. Set this (an Anthropic key) only to keep
@@ -97,22 +104,13 @@
  *                             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_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

@@ -62,9 +62,9 @@
  *   BIR_REPLAY_ALLOW_SERVERS  comma-separated server keys eligible for *direct*
  *                             execution. Unset means every wrapped server
  *   BIR_BUILTIN_TOOLS         comma-separated built-ins the runner may execute
- *                             itself during a replay, in the session's own
- *                             project directory and confined to it
- *                             (replay/builtins.ts). Default all six:
+ *                             itself during a replay, from the session's own
+ *                             project directory (replay/builtins.ts; which
+ *                             folders: BIR_PATH_ALLOW). Default all six:
  *                             Read,Glob,Grep,Edit,Write,Bash. A runner-side
  *                             step never reaches the host's permission
  *                             prompts; Read,Glob,Grep is the read-only set
@@ -73,6 +73,13 @@
  *   BIR_BASH_ALLOW            command prefixes a runner-side Bash step may run
  *                             (`*` for all). Unset means `*`; `none` means no
  *                             command, and Bash steps are steered
+ *   BIR_PATH_ALLOW            folders a runner-side Read, Glob, Grep, Edit or
+ *                             Write may touch (`*` for any). Unset means `*`:
+ *                             any path, as the agent's own tools (up to 0.3.20
+ *                             the project directory alone). `project` is the
+ *                             session's project directory, `~` the home
+ *                             folder: `project,~/.claude`. `none` means no
+ *                             folder, and the file steps are steered
  *   BIR_DERIVE_API_KEY        OPTIONAL. Derivation — reading what this turn acts
  *                             on — is done by the service for a signed-in
  *                             runner. Set this (an Anthropic key) only to keep
@@ -97,22 +104,13 @@
  *                             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_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.",
@@ -413,7 +399,7 @@ export function localFindings(turn) {
             const elsewhere = names.filter((n) => !EXECUTABLE_BUILTINS.has(n));
             const fixes = [];
             if (offList.length > 0) {
-                fixes.push(`The runner runs ${offList.join(", ")} itself when ${offList.length === 1 ? "it is" : "they are"} on \`BIR_BUILTIN_TOOLS\` (unset means all six, from runner 0.3.8) and, for Bash, \`BIR_BASH_ALLOW\` is not \`none\`: fix those where the recorder starts, then \`bir up --restart\`.`);
+                fixes.push(`The runner runs ${offList.join(", ")} itself when ${offList.length === 1 ? "it is" : "they are"} on \`BIR_BUILTIN_TOOLS\` (unset means all six, from runner 0.3.8) and, for Bash, \`BIR_BASH_ALLOW\` is not \`none\` (for the file tools, \`BIR_PATH_ALLOW\`): fix those where the recorder starts, then \`bir up --restart\`.`);
             }
             if (elsewhere.length > 0) {
                 fixes.push(`Put the data ${elsewhere.join(", ")} ${elsewhere.length === 1 ? "reaches" : "reach"} behind an MCP server, wrap it (\`bir install --server <name>\`), and record the prompt again so its steps are MCP calls.`);
@@ -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/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()`). */