@basein/runner 0.3.14 → 0.3.16

package/dist/replay/source-run.d.ts

@@ -17,7 +17,9 @@
  * The queue semantics deliberately match the server's own dry replay
  * (`recordedOutputsByTool` in `scenarios/replay.ts`): a FIFO per tool name, drawn
  * in order, with a per-tool cursor. A scenario that behaved one way under
- * `bir scenario replay --dry` and another way here would be untestable.
+ * `bir scenario replay --dry` and another way here would be untestable. A step
+ * a test leaves out passes over its own recorded output — unless a correction
+ * added it, and it made no call in the recording ({@link SourceRunCache.leftOut}).
  *
  * Fetched **lazily** — only when a step actually needs it — and cached for the
  * turn, so a fully-executable replay never makes this call at all.
@@ -63,6 +65,17 @@ export declare class SourceRunCache {
      * skipped, which the caller already handles.
      */
     outputFor(entry: FlatEntry): Promise<string | undefined>;
+    /**
+     * A step its test left out (the service's autocorrect.md AC5). Every step
+     * of a plan was in the recording, and made its call there — unless a
+     * correction added it from the agent's redo (`correctionKind: "added"`),
+     * which made none. So one that was in it passes over its recorded output,
+     * and the next step of its tool takes its own; an added one passes over
+     * nothing. Nothing is fetched: the cursor is a count of this frame's calls
+     * of the tool, whichever of them are read later (docs/calculatedReplay.md
+     * §9.2).
+     */
+    leftOut(entry: FlatEntry): void;
     private load;
     private fetchRun;
 }

package/dist/replay/source-run.js

@@ -17,7 +17,9 @@
  * The queue semantics deliberately match the server's own dry replay
  * (`recordedOutputsByTool` in `scenarios/replay.ts`): a FIFO per tool name, drawn
  * in order, with a per-tool cursor. A scenario that behaved one way under
- * `bir scenario replay --dry` and another way here would be untestable.
+ * `bir scenario replay --dry` and another way here would be untestable. A step
+ * a test leaves out passes over its own recorded output — unless a correction
+ * added it, and it made no call in the recording ({@link SourceRunCache.leftOut}).
  *
  * Fetched **lazily** — only when a step actually needs it — and cached for the
  * turn, so a fully-executable replay never makes this call at all.
@@ -80,11 +82,28 @@ export class SourceRunCache {
                 (o.position >= entry.stepFrom && o.position <= entry.stepTo)));
         if (inRange.length === 0)
             return undefined;
-        const key = `${entry.frame.id}#${toolName}`;
+        const key = cursorKey(entry, toolName);
         const at = this.cursor.get(key) ?? 0;
         this.cursor.set(key, at + 1);
         return inRange[at]?.output;
     }
+    /**
+     * A step its test left out (the service's autocorrect.md AC5). Every step
+     * of a plan was in the recording, and made its call there — unless a
+     * correction added it from the agent's redo (`correctionKind: "added"`),
+     * which made none. So one that was in it passes over its recorded output,
+     * and the next step of its tool takes its own; an added one passes over
+     * nothing. Nothing is fetched: the cursor is a count of this frame's calls
+     * of the tool, whichever of them are read later (docs/calculatedReplay.md
+     * §9.2).
+     */
+    leftOut(entry) {
+        const toolName = entry.step.toolName;
+        if (!toolName || entry.step.correctionKind === "added")
+            return;
+        const key = cursorKey(entry, toolName);
+        this.cursor.set(key, (this.cursor.get(key) ?? 0) + 1);
+    }
     load(runId) {
         let pending = this.loading.get(runId);
         if (!pending) {
@@ -166,6 +185,10 @@ export class SourceRunCache {
  * recording. Kept so nothing outside has to change its import.
  */
 export { SourceRunCache as SourceRunOutputs };
+/** One frame's queue of one tool's recorded outputs: a sub-task called twice replays from its start twice. */
+function cursorKey(entry, toolName) {
+    return `${entry.frame.id}#${toolName}`;
+}
 /**
  * Report a service answer to the breaker with the time its request started:
  * an answer to a request sent before a hot path gave up on the service does

package/dist/replay/targets.js

@@ -130,15 +130,22 @@ function callerBodies(planned) {
                 bodies.push(entry.step.toolInputLogic);
             if (entry.step.toolOutputLogic)
                 bodies.push(entry.step.toolOutputLogic);
+            // A step's test reads the parameters too (autocorrect.md AC5): a test
+            // that decides on a target nobody named decides on nothing.
+            if (entry.step.when?.logic)
+                bodies.push(entry.step.when.logic);
             continue;
         }
-        // The frame's own mapping, once, and only when its caller is frame 0.
+        // The frame's own mapping, once, and only when its caller is frame 0 —
+        // and the call row's test, which is decided in the caller's scope.
         const frame = entry.frame;
         if (frame.depth !== 1 || seenFrames.has(frame.id))
             continue;
         seenFrames.add(frame.id);
         if (frame.paramMapLogic)
             bodies.push(frame.paramMapLogic);
+        if (frame.when?.logic)
+            bodies.push(frame.when.logic);
     }
     return bodies;
 }

package/dist/replay/types.d.ts

@@ -56,8 +56,40 @@ export interface StepStop {
     /** For `parked` past its grace, or whose tool is gone: a repair is due. */
     repairDue?: boolean;
 }
+/**
+ * A step's test (the service's autocorrect.md AC5, contract 2): the step runs
+ * only when `logic` says `true`. When it says `false`, `otherwise` decides —
+ * `skip` leaves the step out and the plan goes on with the next one;
+ * `hand_over` stops the plan in front of the step and the agent does the rest
+ * (the other half of an "if … otherwise"). A test that throws, or answers
+ * anything but `true` or `false`, stops the plan: nothing is guessed.
+ */
+export interface StepTest {
+    /** JS body: `(parameters, intent, respParams) => true | false`. */
+    logic: string;
+    otherwise: "skip" | "hand_over";
+    /** The test in words ("engaged users went over the threshold since the start date"). */
+    text?: string | null;
+}
+/** Whether a served test is one this runner can run; anything else is no plan to arm. */
+export declare function isStepTest(value: unknown): value is StepTest;
 export interface SerializedScenarioStep {
     stepIndex: number;
+    /**
+     * Run this step only when its test says so (autocorrect.md AC5). Absent or
+     * null on a step with no test — every step of an older service. On a call
+     * row the test decides the whole sub-task.
+     */
+    when?: StepTest | null;
+    /**
+     * The correction that wrote this step, and what it did (the service's
+     * autocorrect.md AC6). `"added"` is a step taken from the agent's redo: it
+     * made no call in the recording the plan was calculated from, so it pairs
+     * with no recorded output (source-run.ts). Absent or null on every other
+     * step, and on every step of an older service.
+     */
+    correctionId?: string | null;
+    correctionKind?: "added" | "tested" | "changed" | null;
     /**
      * `"segment"` is a call: a sub-task this chain runs by calling a recorded
      * scenario instead of carrying a copy of its steps (R-CALL-1). Absent means
@@ -171,6 +203,12 @@ export interface SerializedScenario {
     paramsLogic: string | null;
     /** JS body: `(respParams, parameters, intent) => object`. The final model. */
     responseParamsLogic: string | null;
+    /**
+     * The chain's revision as served. Carried on the plan's own calls when they
+     * are recorded into the turn's newest run (autocorrect.md AC2), so the
+     * service can tell which chain made them. Absent from an older service.
+     */
+    chainRevision?: number;
     outParamsObject?: unknown;
     originalCostUsd: number | null;
     originalMs: number | null;
@@ -207,7 +245,13 @@ export type FallbackKind =
  * non-deterministic: its input needs a judgement no code computes
  * (plan-services.md D8, kind 3). Never tried, counts nothing.
  */
- | "nondeterministic_step";
+ | "nondeterministic_step"
+/**
+ * The plan stopped in front of a step whose test said no, with `hand_over`
+ * (autocorrect.md AC5): this request is the other half of an "if …
+ * otherwise", and the agent does it. No fault of the plan; counts nothing.
+ */
+ | "other_branch";
 /**
  * Upgrade order. `not_steered` is the floor — the control group, and the safe
  * answer if a turn dies mid-flight — and each later decision point can only move
@@ -228,18 +272,23 @@ export declare const OUTCOME_RANK: Record<ExecutionOutcome, number>;
  *   `failed`   — the *scenario's own logic* threw, or its tool ran and reported
  *                an error (stage `tool_call`). Either way the step's work did
  *                not happen, and a plan cannot claim success past it.
+ *   `not_taken` — its test said this request does not need it, and it was
+ *                left out on purpose (autocorrect.md AC5): no call, no output
+ *                logic. The plan went on with the next step.
  *
  * A step the run never reached is simply absent from the report. The console
  * renders those as "not run" — asserting anything about a step that never
  * started would be inventing a result.
  */
-export type ExecutionStepStatus = "ok" | "recorded" | "skipped" | "failed";
+export type ExecutionStepStatus = "ok" | "recorded" | "skipped" | "failed" | "not_taken";
 /**
  * Where inside a step (or a run) something broke. Mirrors the service's
  * `ExecutionStage` (its `src/db.ts`) — a closed vocabulary, so the console can
  * say which part failed without parsing an error message.
  */
-export type ExecutionStage = "derive_params" | "params_logic" | "tool_input_logic" | "tool_call" | "tool_output_logic" | "response_logic" | "setup" | "unknown";
+export type ExecutionStage = "derive_params" | "params_logic"
+/** A step's test threw, or answered neither true nor false (autocorrect.md AC5). */
+ | "when_logic" | "tool_input_logic" | "tool_call" | "tool_output_logic" | "response_logic" | "setup" | "unknown";
 /**
  * One step's verdict, as reported to the service alongside the execution.
  *

package/dist/replay/types.js

@@ -10,6 +10,16 @@
  * everywhere and nothing is assumed present. A scenario whose `state` is not
  * `"ready"` carries an **empty** `steps` array, by the service's own rule.
  */
+/** Whether a served test is one this runner can run; anything else is no plan to arm. */
+export function isStepTest(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const t = value;
+    return (typeof t.logic === "string" &&
+        t.logic.trim().length > 0 &&
+        (t.otherwise === "skip" || t.otherwise === "hand_over") &&
+        (t.text === undefined || t.text === null || typeof t.text === "string"));
+}
 /** Whether this schema has anything the runner may not guess (R-PARAM-4). */
 export function hasTargets(schema) {
     if (!schema)
@@ -51,6 +61,10 @@ export function isReadyScenario(value) {
 function readyStep(step) {
     if (!step)
         return false;
+    // A test this runner cannot read is a step it cannot decide: the plan is
+    // not armed rather than run with the step always in, or always out.
+    if (step.when !== undefined && step.when !== null && !isStepTest(step.when))
+        return false;
     if (step.kind === "segment") {
         if (step.unusable)
             return true;

package/dist/util/service-headers.d.ts

@@ -5,8 +5,14 @@
  *
  * - **1** — stops in front of a step that carries `stop`, and reads
  *   `withheld: "runner_update_required"` on a match.
+ * - **2** — runs a step (or a sub-task's call row) only when its test, `when`,
+ *   says so: leaves it out (`not_taken`) or stops in front of it
+ *   (`other_branch`) when the test says no, and stops when the test cannot
+ *   answer (stage `when_logic`). The service's autocorrect.md AC5: a plan
+ *   holding a test is handed only to a runner that names contract 2 or newer,
+ *   because an older one would run every step — both halves of the task.
  */
-export declare const CONTRACT = 1;
+export declare const CONTRACT = 2;
 /** Spread into the `headers` of a request to the service. */
 export declare function serviceHeaders(): Record<string, string>;
 /**

package/dist/util/service-headers.js

@@ -22,8 +22,14 @@ import { packageVersion } from "./version.js";
  *
  * - **1** — stops in front of a step that carries `stop`, and reads
  *   `withheld: "runner_update_required"` on a match.
+ * - **2** — runs a step (or a sub-task's call row) only when its test, `when`,
+ *   says so: leaves it out (`not_taken`) or stops in front of it
+ *   (`other_branch`) when the test says no, and stops when the test cannot
+ *   answer (stage `when_logic`). The service's autocorrect.md AC5: a plan
+ *   holding a test is handed only to a runner that names contract 2 or newer,
+ *   because an older one would run every step — both halves of the task.
  */
-export const CONTRACT = 1;
+export const CONTRACT = 2;
 /** Spread into the `headers` of a request to the service. */
 export function serviceHeaders() {
     return {

package/docs/BaseInstRunner.md

@@ -475,7 +475,9 @@ What the control server does for such a session:
   text) has every request answered `{}`, and nothing of it is recorded or
   replayed (`session.host_refused`).
 - **The plan.** One starts only for a prompt that said `replay: true`.
-  Otherwise a match is declined with `host_records_only`. The plan's mode is
+  Otherwise a match is declined with `host_records_only`, and a plan with
+  steps that run only when a test says so with `host_tests_unsupported`: the
+  adapter reads no tests yet (calculatedReplay.md §9.2). The plan's mode is
   always `steer`, and the runner runs no step itself: the host runs its own
   tools. The prompt's answer carries the plan as data (`plan`), because the
   directive beside it is a text written for a model.

package/docs/calculatedReplay.md

@@ -219,7 +219,9 @@ plan is declined when no running `bir-scenario` has said it serves `run_scenario
 (`no_delivery_tool`, §6.3). In plan mode (`permission_mode: "plan"`) nothing is announced at all.
 In a session of another host (§7.4) a plan that armed is taken back, before any step of it runs,
 when it names a tool the agent that asked does not hold (`host_tool_missing`): it is booked like
-any gate's decline, `not_steered`, with no step marked failed.
+any gate's decline, `not_steered`, with no step marked failed. A plan with steps that run only when
+a test says so (§9.2) is declined for such a host before anything is spent
+(`host_tests_unsupported`): its adapter steps through a plan call by call and reads no tests yet.
 
 Gate 4 is retired. Up to 0.3.6 it declined a match under `BIR_MIN_STEER_SIMILARITY` (0.92),
 above the server's 0.9, on the argument that the server only decided *"do not record this again"*
@@ -879,6 +881,77 @@ time limit, §13.1; argument order and the plain-object guard still match the se
 In direct mode both live inside one `for` loop. In steer mode they are split across *separate HTTP
 requests* — which is what §7.3's ordering rule protects.
 
+### 9.2 Steps that run only when (contract 2)
+
+Built 2026-10-23 for the service's autocorrect.md AC5; not yet released. A task can have two
+halves: "if engaged users went over the threshold, book a meeting; otherwise send a note". A
+recording shows one half, so its plan knows one half. The service's correction adds the other half
+and a test on each step that belongs to only one of them. A served step, and a sub-task's call
+row, may carry:
+
+```ts
+when?: { logic: string; otherwise: "skip" | "hand_over"; text?: string | null } | null
+// logic: a function body, (parameters, intent, respParams) => true | false
+```
+
+The test runs in the same sandbox as the other logic (`evalWhenLogic`, `src/replay/logic.ts`). It is
+decided when its step comes due, with what is known then: the request's values and the results of
+the steps before it. A call row's test is decided once, in the caller's scope, before the sub-task
+starts — where its first step *or its callee's* is: a sub-task whose chain begins with a call
+begins with that call's steps, so nothing of it runs before its test says it is needed. A sub-task
+is entered there too, before its callee, whose mapping reads its parameters, and left after the
+last step of it or its callee (`frameEdges`, `src/replay/flatten.ts`).
+
+| The test says | What happens |
+|---|---|
+| `true` | The step runs. |
+| `false`, `otherwise: "skip"` | Nothing is sent. The step is reported `not_taken` and the plan goes on. A skipped call row leaves out its whole sub-task and is reported `not_taken` under its own index. |
+| `false`, `otherwise: "hand_over"` | The plan stops in front of the step and hands the rest of the task to the model, saying the steps from here are only for when `text` (`fallbackKind: other_branch`). |
+| throws, or not exactly `true` or `false` | The plan stops: the step is `failed` at stage `when_logic` (`fallbackKind: step_failed`). The model is told the plan could not tell whether this request needs the step, and decides itself. Nothing is guessed. |
+
+A plan whose tests left out every step it came to, and ran none, hands the whole task to the model
+(`other_branch`, step 0). Its report is `failed` with `fallbackKind: other_branch`, and it is sent
+although it cost nothing: it tells the service the request took the half the plan does not know.
+
+A step left out that is the last of a sub-task still hands the sub-task's results back to its
+caller. When the body that maps them throws, the plan stops there: the call row is `failed` at stage
+`tool_output_logic`, and the note says the sub-task could not hand back its results — never that
+the step left out ran.
+
+- **Direct mode** decides the tests in its loop. The bundle gives a left-out step its own heading,
+  `--- Step 5: tool (not needed) ---`, and says it is only for when `text`, so the model does not run
+  it itself.
+- **Steer mode** settles the tests after each call. The `PostToolUse` answer names the next step
+  this request does not need, and the step to call instead. A call to a left-out tool — every tool
+  of a sub-task left out whole — is answered in its place with the same words, at most twice, and
+  does not end the plan. When the left-out step and the next one share a tool and the note has not
+  reached the model yet, a call the pin guard (§7) finds is not the next step gets the note in its
+  place too, so the step left out never runs because the note was late. A note naming a step to call
+  next is dropped when the plan retires — a divergence, a hand-over — since the plan no longer has
+  that step; only "the sequence is complete" outlives a plan that finished.
+- **The divergence bundle** (§8) decides the tests the same way, going on from the sub-task the
+  cursor is inside, with what that sub-task made so far. A `hand_over` stop ends the bundle there,
+  and the turn is booked `fell_back` when a step did its work (`failed` when none did) — a hand-over,
+  as in the other modes, never `diverged`, so the service takes the agent's work after it as that
+  half's evidence.
+- **The directive** (§6.4) marks a tested step `(only when <text>)` and says the results, or the
+  notes after each call, name the steps this request does not need.
+- **A hand-over note** counts only the steps that ran, names the ones their tests left out ("Not
+  needed for this request, so not run: step 2 (Grep)"), and marks a remaining step that runs only
+  under a test `(only when …)`, so the list does not read as work this request needs.
+- **Another host** (a LangChain application) steps through a plan call by call, and its adapter
+  reads no tests yet: a plan with any test is declined for it before anything is spent
+  (`host_tests_unsupported`), and the model does the task.
+
+A step left out passes over its own recorded output (§8.1): it was in the recording and made its
+call there, so the next step of its tool takes its own output, not the one left out. A step a
+correction added from the agent's redo (`correctionKind: "added"`) made no call in the recording
+and passes over nothing (`SourceRunCache.leftOut`, `src/replay/source-run.ts`).
+
+The runner names `x-bir-contract: 2` on its calls to the service (`src/util/service-headers.ts`).
+The service hands a plan with any test only to a runner that names 2 or more; an older runner gets
+no plan (`runner_update_required`) and the agent does the task.
+
 ---
 
 ## 10. Timing: what may block, and for how long
@@ -971,7 +1044,8 @@ threaded before the divergence. A divergence that ran nothing books `failed`, an
 stopped at a step that broke (a logic failure, a tool error, a call sent and never answered). A
 recorded stand-in (`BIR_REPLAY_RECORDED_OUTPUTS=1`) is never work done: it counts toward neither
 `stepsPinned` nor the upgrade, and a direct run that used one is `diverged` at best. A call that ran
-beside a pinned one hands over as `fell_back` or `failed` (§7). A direct run cancelled by its caller
+beside a pinned one hands over as `fell_back` or `failed` (§7), and so does a divergence whose
+bundle stops in front of the other half of an "if … otherwise" (§9.2). A direct run cancelled by its caller
 (Esc, or `bir-scenario`'s own timeout) books `fell_back` or `failed` with `measured: false`, never
 `diverged`: that turn's cost says nothing about what the task costs.
 
@@ -1012,7 +1086,8 @@ bounded flush — runs in the background, so `Stop` never blocks on the network:
 POST /scenarios/:scenarioId/executions
   { ticket, outcome, deriveCostUsd, sessionCostUsd, fallbackCostUsd,
     durationMs, stepsPlanned, stepsPinned, measured, pricingVersion, prompt,
-    steps, error, errorStage, errorStepIndex, errorToolName }
+    steps, error, errorStage, errorStepIndex, errorToolName,
+    redoneBy }   // { runId, ownCalls }, only after a redo (below)
 ```
 
 An **unredeemed** ticket leaves no execution row at all. That asymmetry is intentional and worth
@@ -1023,6 +1098,14 @@ was handed out, and answers a later report `409 invalid_ticket`. The service as
 yet) redeems it for 24 hours. It also answers a report whose write failed `503 report_not_booked`,
 and the recorder sends that report once more.
 
+**After a redo** (the service's autocorrect.md AC1; built 2026-10-23, not yet released). When a
+plan ran to its end and the agent then did the task again itself, the rest of the turn is recorded
+as a repeat of the recording, with reason `redone` (§12). The report then says
+`redoneBy: { runId, ownCalls }`: the repeat's run id, and how many tool calls the agent made of its
+own in it. A call the plan pinned is not one of them, and neither is one a proxy reports after
+`Stop`. Only the plan the prompt armed sends it. The service judges from it whether the agent
+rejected the plan's result, and why.
+
 ### 11.2a What each step did (the service's errorshandling.md)
 
 The last five fields are the diagnosis, and none of the money depends on them. The service's
@@ -1035,7 +1118,7 @@ at a web page.
 steps: Array<{
   stepIndex: number;          // the scenario's own index, not a position in this array
   toolName: string;
-  status: "ok" | "recorded" | "skipped" | "failed";
+  status: "ok" | "recorded" | "skipped" | "failed" | "not_taken";
   stage?: ExecutionStage;     // where in the step, for `failed` / `skipped`
   error?: string;             // message only — this is rendered in a web page
   durationMs?: number;
@@ -1083,7 +1166,9 @@ only another open session's proxy), or it was sent and timed out or was refused.
 host stopped itself, in a host that is not Claude Code, is `skipped` as well: a person refused it,
 or changed its call (§7.4). The plan stops at a `skipped` step.
 **`failed` is the only one that means the scenario is broken** rather than the environment — it is
-the scenario's own logic throwing, and it is what `Recalculate` fixes.
+the scenario's own logic throwing, and it is what `Recalculate` fixes. A step's test that throws is
+`failed` too, at stage `when_logic`. `not_taken` is a step its test left out (§9.2): nothing was
+sent, so it has neither payload.
 
 Three rules this must keep:
 
@@ -1197,6 +1282,20 @@ Three consequences to keep straight:
    `request()` is *"Never used by the relay"* — it was built for `bir doctor` and tests, and this is
    its second, load-bearing user.
 
+**A plan the agent redid.** The service's newestRun.md N7 makes one exception. When the agent
+does the task again after a plan ran to its end, the rest of the turn is recorded as a repeat of the
+recording, with reason `redone`. Since autocorrect.md AC2 (built 2026-10-23, not yet released) the
+repeat starts with the plan's own calls, then the agent's. Each of the plan's calls is a pair of
+rows marked `metadata.byPlan: { scenarioId, stepIndex, chainRevision }`, and each is kept whole,
+like a recorded step (`serializeCapped(redact(…))`, up to 64 KiB), not cut to the report's 3,800
+bytes. So the service can set what the plan did beside what the agent did instead, call by call.
+
+- Only the plan the prompt armed keeps its calls, and only when the match offered a repeat.
+- Only calls that were sent and answered are kept, with a result or with a tool error. A step left
+  out, not sent, or standing on a recorded output is not among them.
+- The calls kept in one turn are held to about 8 MB. Past that, a call keeps only the report's cut.
+- `chainRevision` is the plan's revision as it was served, or `null` when the service did not send one.
+
 ### 12.1 `bir replay` — the Tier 2 and debugging path
 
 ```bash
@@ -1400,6 +1499,7 @@ fail because of BaseInstRunner.**
 | Plan mode | Nothing is announced, pinned or approved |
 | Another host (§7.4): the run's adapter asked for no plan with its prompt | Declined at gate 2 (`host_records_only`), `not_steered`; the model does the task |
 | Another host: the plan names a tool the agent that asked does not hold | Taken back before any step runs (`host_tool_missing`), `not_steered`; the model does the task |
+| Another host: the plan has steps that run only when a test says so (§9.2) | Declined before anything is spent (`host_tests_unsupported`), `not_steered`; the model does the task |
 | Another host: the model makes a call of its own while the plan is live | The plan is handed over. The call runs as the model wrote it, never with the plan's arguments, and the note comes with its `/tool/post` |
 | Another host: a person refuses a step, or changes its call | The step is `skipped`, never `failed`, and the plan hands over; `baselineEligible: false`, and after a refusal `measured: false` (§11.1) |
 | Another host: the run fails, goes silent for two hours, or is closed with its plan still live | A live plan is handed over first: `fell_back` or `failed`. The report says `measured: false` and `baselineEligible: false`. A run that ended early is finished with an `error` and no final answer |
@@ -1653,7 +1753,8 @@ bir scenario check <id> --step <n>    POST  /scenarios/:id/steps/:n/check
 bir scenario edit  <id> --step <n>    PATCH /scenarios/:id/steps/:n              the same check, then save
 bir scenario edits <id>               GET   /scenarios/:id/edits                 the history, newest first
 bir scenario undo  <id> [--edit <e> | --step <n>]
-                                      POST  /scenarios/:id/edits/:e/revert       take back the newest edit (of step n)
+                                      POST  /scenarios/:id/edits/:e/revert       take back the newest edit (of step n);
+                                                                                 <e> is a sedit_, pedit_ or scor_ id
 bir scenario editing on|off|status    (no route) ~/.baseinstrunner/installed.json  which `bir` MCP tools are offered
 
 bir replay --scenario <scnId> --prompt "…" [--dry]     alias; the Tier 2 / debugging path (§12.1)
@@ -1684,6 +1785,16 @@ are where `bir` changes a scenario by hand, so the rules are strict:
   steps and the final answer (so only when it changes output logic), and answers
   `422 undo_refused` when it would break them, unless `--force --note "<why>"` is given. Every
   save and every undo bumps the scenario's `chainRevision`.
+- **Corrections** (the service's autocorrect.md AC7; built 2026-10-23, not yet released). After the
+  agent redid a plan, the service may correct the plan itself, for example by adding the half of
+  the task it did not know (§9.2). `edits` lists each correction beside the hand edits, under its
+  `scor_` id, with its state (`proposed`, `used`, `failed`, `undone`, `replaced`), the revisions
+  before and after, and what it did. `undo --edit scor_…` puts back the plan from before it, all of
+  it, and the service then holds the plan: it is not handed out until its owner chooses "Use it
+  again" on the recording page. A plain `undo` takes back a correction in use when it is the newest
+  change; `--step` never picks one, because a correction changes the whole plan. A correction is
+  protected like a hand edit: `calc --force` answers `409 scenario_has_edits` with its
+  `correctionId`, and `bir` says the plan carries it.
 - A save lifts a mark made by hand (`--freeze`, `by_hand`) only with `--unfreeze`; undoing the
   freeze, or `calc --force --discard-edits`, also removes it. A forced save lifts only a mark the
   calculation set.

package/docs/calculatedReplayGuide.md

@@ -491,6 +491,7 @@ Everything replay decides is one line. `grep` for these:
 | `replay.concurrent_call` | A call ran beside a pinned step; the plan handed over |
 | `replay.thread_fallback` | A wrapped step's output was threaded from the hook's view because the proxy did not report in time |
 | `replay.step` | One direct step executed |
+| `replay.step_not_taken` | A step's test said this request does not need it, and nothing was sent for it ([calculatedReplay.md](calculatedReplay.md) §9.2). `plan.armed … tests=` lists the tested steps by their place in the plan: `4:hand_over,11:skip` |
 | `replay.diverge` / `replay.compose` | Off-script, and the recovery |
 | `replay.handover` | The plan stopped and handed the rest of the task to the model; `kind=` and `step=` say where |
 | `replay.vetoed` | A direct plan retired without running anything: `run_scenario` was not the first call, or never arrived |
@@ -501,7 +502,8 @@ Everything replay decides is one line. `grep` for these:
 | `replay.delivery_tool` | A `bir` server said it can, or cannot, deliver a direct plan |
 | `control.hook_deadline` | A hook route answered `{}` at its deadline |
 | `replay.done` | Final outcome, steps completed, elapsed |
-| `execution.reported` | The ticket was redeemed and the saving booked |
+| `execution.reported` | The ticket was redeemed and the saving booked. `redoneBy=` and `ownCalls=` when the agent did the task again after the plan |
+| `run.repeat … reason=redone` | The plan ran to its end, and the agent did the task again itself. The rest of the turn is recorded as the recording's newest run, `run=`; `planCalls=` says how many of the plan's calls open it |
 | `run.unmeasured` | The turn's cost is not measured (§7). `why=` says what was missing, and `models=` names a model the runner has no price for |
 | `run.start … host=` / `plan.armed … host=` | The turn ran in a host that is not Claude Code, named after `host=` (§6.5). A Claude Code turn has no such field |
 | `replay.own_call` / `replay.step_host_stopped` | Another host only. The model made a call of its own while the plan was live, and the plan handed over / the host stopped a step itself: `stop=rejected` or `stop=edited` |
@@ -732,6 +734,25 @@ LangChain recording it raises no `steer_only` finding, and it explains an
 unmeasured cost in its own words. That part is built on the service and not
 deployed yet.
 
+**A plan the agent redid** (built 2026-10-23, not yet released; the service's
+autocorrect.md). The plan ran to its end, and then the agent did the task again
+with calls of its own. The turn shows it three ways:
+
+- the `reported` line ends `redone by run_… (N calls of its own)`;
+- a `repeat` line names the run that holds the redo: the newest run of the
+  recording, never a recording of its own and never a plan;
+- a `redone` finding says the agent did not take the plan's result.
+
+From the service you also see:
+
+- the verdict on the execution, `verdict wrong_branch: …`, with the plan's
+  steps it rejected and what the plan left in place. Remove that by hand if it
+  should not be there;
+- `HELD since …` on the plan: it is not handed out until you choose "Use it
+  again" on the recording page;
+- a step's test, `only when …, otherwise skip`, with the correction that added it;
+- the newest correction, and whether it is used.
+
 You see your own data. An admin of the service sees everyone's and may pass
 `--user` to `executions`. `--json` on any form prints the raw merge.
 
@@ -760,7 +781,7 @@ bir scenario edit  <runId|scnId> --step <n> [--input-logic <file|->] [--output-l
                    [--freeze | --unfreeze] [--note "<why>"] [--force --note "<why>"] [--revision <n>]
 bir scenario edit  <runId|scnId> --param <name> --kind target|setting [--note "<why>"] [--revision <n>]
 bir scenario edits <runId|scnId>
-bir scenario undo  <runId|scnId> [--edit <sedit_id|pedit_id> | --step <n> | --param <name>] [--force --note "<why>"]
+bir scenario undo  <runId|scnId> [--edit <sedit_id|pedit_id|scor_id> | --step <n> | --param <name>] [--force --note "<why>"]
 bir scenario calc  <runId|scnId> [--force [--discard-edits]]
 bir scenario editing on|off|status
 ```
@@ -1093,6 +1114,21 @@ How undo works:
 - Once every hand edit of a plan is taken back, the service repairs and rebuilds it as usual again.
   An undo forced past a refusal is the exception: it leaves its step counted as edited and
   forced, so `bir investigate` keeps warning about it.
+- **A correction the service made** (built 2026-10-23, not yet released). After the agent redid a
+  plan, the service may correct the plan itself (its autocorrect.md), for example by adding the
+  half of the task the recording did not show. `bir scenario edits` lists the correction beside
+  your edits, under its `scor_` id:
+
+  ```
+  scor_5b2e…  2026-10-22 17:58:10Z  correction  used     revision 7 → 8
+      16 steps added for the otherwise half; …; 16 steps added (11–26), tests on steps 4–10, the answer changed; …
+  ```
+
+  `bir scenario undo <id> --edit scor_…` puts back the whole plan from before it. The plan is then
+  held: it is not handed out until you choose "Use it again" on the recording page. A plain
+  `bir scenario undo` takes back a correction in use when it is the newest change. `--step` never
+  picks one: a correction changes the whole plan. A recalculation is refused on a corrected plan
+  as on an edited one (`Not recalculated: the plan carries correction scor_…`).
 
 #### What a save changes
 
@@ -1185,6 +1221,7 @@ The tools, as the `bir` server defines them. **Bold** arguments are required.
 | `scenario_undo` | with scenario editing on | **`target`**, one of `edit`, `step` or `param`, `force`, `note` | `bir scenario undo` |
 
 - `target` is a `scn_` id, or the `run_` id of a whole-run scenario. `step` is the `stepIndex`.
+- `edit` is an id from `scenario_edits`: a `sedit_`, `pedit_` or `scor_` id.
 - `inputLogic` and `outputLogic` are the code itself, as text. The server writes them to temporary
   files for `bir`, and removes the files afterwards.
 - `revision` is the `chainRevision` at the top of `scenario_show` with `step`.
@@ -1300,7 +1337,7 @@ Parameter database: target → setting (revision 4). Undo: bir scenario undo scn
 | `revision_changed` | The plan changed since you read it: another edit, or a recalculation | `show` it again, check again, save again |
 | `not_ready` or `scenario_calculating` | The scenario is not `ready`, or a recalculation is running | Wait for it to finish |
 | `undo_refused` | The undo would stop a later step from giving its recorded call, or leave the final answer without its values | Fix that later step first. Or undo it on purpose: `--force --note "why"` |
-| `not_latest_edit` | The step has changed since the edit you named: a newer entry changed it | `bir` prints two commands: undo the newer one first, then yours |
+| `not_latest_edit` | The step has changed since the edit you named: a newer entry changed it. For a correction: the plan has changed since it | `bir` prints two commands: undo the newer one first, then yours |
 | `already_undone` | That edit was undone already | To redo it, undo the undo. `bir` prints the command |
 | `edit_replaced` | A recalculation replaced the plan after that edit | Nothing to undo; the edit is history now |
 | `logic_sandbox_unavailable` | The service could not run step code just now (HTTP 503). Nothing was checked, saved or undone | Try again in a minute |
@@ -1333,6 +1370,7 @@ part of it is not deployed yet.
 | **R6** | Divergence, source-run fallback, `bir replay` | `diverge()` in [controller.ts](../src/replay/controller.ts), [source-run.ts](../src/replay/source-run.ts) |
 | **R7** | Usage watermark, reporting, ticket, doctor | [control/transcript.ts](../src/control/transcript.ts), [remote-recorder.ts](../src/record/remote-recorder.ts) |
 | **§6.5** *(the package is not on PyPI; the service's part is not deployed)* | A plan stepped through by the adapter of a host that is not Claude Code: the declines `host_records_only` and `host_tool_missing`, the stops `host_rejected` and `host_edited`, the cost from the adapter's `usage` | [control/server.ts](../src/control/server.ts), [controller.ts](../src/replay/controller.ts), [handover.ts](../src/replay/handover.ts), [safety.ts](../src/replay/safety.ts), [bin/investigate.ts](../src/bin/investigate.ts); the proof: `examples/langchain-proof/` in the repository (not in the npm package) |
+| **Redo and corrections** *(not yet released; the service's autocorrect.md)* | The report's `redoneBy`; a redone repeat opens with the plan's own calls, whole and marked `byPlan`; steps that run only when (contract 2); `scor_` corrections in `bir scenario edits` and `undo`; `bir investigate`'s repeat, verdict, hold and correction lines | [control/server.ts](../src/control/server.ts), [controller.ts](../src/replay/controller.ts), [plan.ts](../src/replay/plan.ts), [scenario-edit.ts](../src/bin/scenario-edit.ts), [investigate.ts](../src/bin/investigate.ts); tests: [step-tests.test.ts](../test/step-tests.test.ts), [newest-run.test.ts](../test/newest-run.test.ts) |
 | **§9.2** *(not yet released)* | `bir scenario show/check/edit/edits/undo/calc/editing`, the `bir` server's scenario tools, `bir` calls never recorded (`editSteps.md` D13) | [bin/scenario-edit.ts](../src/bin/scenario-edit.ts), [bin/bir-scenario.ts](../src/bin/bir-scenario.ts), [record/housekeeping.ts](../src/record/housekeeping.ts); tests: [scenario-edit.test.ts](../test/scenario-edit.test.ts), [bir-scenario.test.ts](../test/bir-scenario.test.ts), [housekeeping.test.ts](../test/housekeeping.test.ts), [replay-server.test.ts](../test/replay-server.test.ts) |
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@basein/runner",
-  "version": "0.3.14",
+  "version": "0.3.16",
   "description": "A recording MCP proxy: sits between any MCP client and its MCP servers, executes each call on the client's behalf, and records the run as a reusable BaseIn scenario.",
   "type": "module",
   "license": "MIT",