@basein/runner 0.3.17 → 0.3.19

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

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

package/dist/bin/bir-hooks.js

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

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

@@ -68,7 +68,11 @@
  * WHICH TOOLS ARE OFFERED. `run_scenario`, always — unless the runner is
  * switched off (`bir off`), when nothing is: an inert runner adds nothing to
  * the model's context, and a call from a list taken before the switch starts
- * nothing and asks nobody. The rest come with scenario editing, which
+ * nothing and asks nobody. `report_wrong_result` comes with it: the agent that
+ * reads a replay's results is the one who can tell they do not answer the
+ * request, and says so in one call that holds the plan and undoes nothing
+ * (the service's review of calcscenarioautocorrect.md, item 19); the control
+ * server knows which session asks, and so which plan. The rest come with scenario editing, which
  * `bir setup` turns on (a person's `bir scenario editing off` is kept): the
  * reading tools — also with `BIR_SCENARIO_TOOLS=read` in this server's
  * environment — and the tools that CHANGE a scenario (D2). A project wired by

package/dist/bin/bir-scenario.js

@@ -68,7 +68,11 @@
  * WHICH TOOLS ARE OFFERED. `run_scenario`, always — unless the runner is
  * switched off (`bir off`), when nothing is: an inert runner adds nothing to
  * the model's context, and a call from a list taken before the switch starts
- * nothing and asks nobody. The rest come with scenario editing, which
+ * nothing and asks nobody. `report_wrong_result` comes with it: the agent that
+ * reads a replay's results is the one who can tell they do not answer the
+ * request, and says so in one call that holds the plan and undoes nothing
+ * (the service's review of calcscenarioautocorrect.md, item 19); the control
+ * server knows which session asks, and so which plan. The rest come with scenario editing, which
  * `bir setup` turns on (a person's `bir scenario editing off` is kept): the
  * reading tools — also with `BIR_SCENARIO_TOOLS=read` in this server's
  * environment — and the tools that CHANGE a scenario (D2). A project wired by
@@ -184,6 +188,39 @@ const TOOL = {
         "never otherwise.",
     inputSchema: { type: "object", properties: {}, additionalProperties: false },
 };
+/**
+ * The agent's way to say a replay was wrong (the service's review of
+ * calcscenarioautocorrect.md, item 19). A plan that took the wrong half of an
+ * "if … otherwise" was caught only when the agent said so in its answer, or
+ * did the task again — and the results it was handed told it not to check.
+ * Offered wherever `run_scenario` is: the agent that reads a replay's results
+ * is the one who can tell they are wrong. It holds the plan on the service and
+ * undoes nothing. Must match `REPORT_TOOL_NAME`'s suffix in the replay
+ * controller.
+ */
+const REPORT_TOOL_NAME = "report_wrong_result";
+/** What the agent may say, in characters; the control server and the service cut it there too. */
+const REPORT_REASON_MAX = 2_000;
+/** The whole report's request: the control server waits up to 10 s for the service. */
+const REPORT_TIMEOUT_MS = 15_000;
+const REPORT_TOOL = {
+    name: REPORT_TOOL_NAME,
+    description: "Call this when the results of a replayed scenario (run_scenario, or a plan bir ran for you) do not answer " +
+        "the user's request — for example, the wrong branch of an if/otherwise was taken, or the wrong item was acted " +
+        "on. Say why in one or two sentences. It does not undo anything.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            reason: {
+                type: "string",
+                maxLength: REPORT_REASON_MAX,
+                description: "Why the results do not answer the request, in one or two sentences.",
+            },
+        },
+        required: ["reason"],
+        additionalProperties: false,
+    },
+};
 /**
  * Ask the control server to run the armed plan. Never throws. The reasons it
  * returns are for the audit log; {@link toolResult} decides what the model reads.
@@ -213,8 +250,14 @@ async function runArmedPlan(cwd, flight, toolUseId) {
                 "content-type": "application/json",
                 authorization: `Bearer ${found.token}`,
             },
-            // `ppid`: the host that started this server and the session's proxies (WHOSE PROXIES above).
-            body: JSON.stringify(toolUseId ? { toolUseId, ppid: process.ppid } : { ppid: process.ppid }),
+            // `ppid`: the host that started this server and the session's proxies
+            // (WHOSE PROXIES above). `reports`: this server offers
+            // `report_wrong_result`, so the results may say the agent can use it.
+            body: JSON.stringify({
+                ...(toolUseId ? { toolUseId } : {}),
+                ppid: process.ppid,
+                reports: listTools(cwd).some((t) => t.name === REPORT_TOOL_NAME),
+            }),
             signal: controller.signal,
         });
         const raw = await res.text();
@@ -333,6 +376,60 @@ function toolResult(result) {
         return said(ALREADY_RUNNING_TEXT);
     return said(UNAVAILABLE_TEXT);
 }
+/**
+ * Tell the control server the agent said a replay was wrong (review item 19):
+ * it knows the session — by the host's id for this call, as for
+ * `run_scenario` — and so the plan, and it reports it to the service. Never
+ * throws; every failure is an answer.
+ */
+async function reportWrongResult(cwd, flight, reason, toolUseId) {
+    const found = await resolveControl(cwd, DISCOVERY_GRACE_MS, 50);
+    if (!found?.url || !found.token)
+        return { ok: false, why: "no_plan" };
+    if (flight.cancelled)
+        return { ok: false, why: "cancelled" };
+    const controller = new AbortController();
+    flight.abort = controller;
+    const timer = setTimeout(() => controller.abort(), REPORT_TIMEOUT_MS);
+    timer.unref?.();
+    try {
+        const res = await fetch(`${found.url.replace(/\/+$/, "")}/scenario/dispute`, {
+            method: "POST",
+            headers: { "content-type": "application/json", authorization: `Bearer ${found.token}` },
+            body: JSON.stringify({ reason, ...(toolUseId ? { toolUseId } : {}), ppid: process.ppid }),
+            signal: controller.signal,
+        });
+        const raw = await res.text();
+        // An older recorder has no such route (404): it cannot take the report.
+        if (!res.ok)
+            return { ok: false, why: res.status === 404 ? "unsupported" : `HTTP ${res.status}` };
+        const body = JSON.parse(raw);
+        return body && typeof body === "object" && !Array.isArray(body) ? body : { ok: false };
+    }
+    catch (err) {
+        return { ok: false, why: flight.cancelled ? "cancelled" : errText(err) };
+    }
+    finally {
+        clearTimeout(timer);
+        flight.abort = undefined;
+    }
+}
+/**
+ * The one sentence the agent reads back. Never an error: the report is a side
+ * note to its answer, and whatever happened to it, the agent's next move is to
+ * tell the user.
+ */
+function reportAnswer(result) {
+    if (result.ok === true) {
+        return said(result.held === true
+            ? "Reported. bir will not use this plan again until it is checked."
+            : "Reported. Now tell the user what is wrong with these results.");
+    }
+    if (result.why === "no_plan") {
+        return said("Nothing was reported: no scenario was replayed for this session's latest request.");
+    }
+    return said("The report could not be sent right now. Tell the user what is wrong with these results.");
+}
 // ── the scenario tools: `bir scenario …`, spawned ─────────────────────────────
 /** How long a `bir` that may change a scenario may take. A check replays the chain on the service. */
 const BIR_TIMEOUT_MS = 120_000;
@@ -720,7 +817,11 @@ function readToolsOptedIn() {
     const value = (process.env.BIR_SCENARIO_TOOLS ?? "").trim().toLowerCase();
     return value === "read" || value === "1" || value === "on" || value === "true";
 }
-/** The tools to list for `cwd`, read now: the switches may have moved since the last list. */
+/**
+ * The tools to list for `cwd`, read now: the switches may have moved since the
+ * last list. `report_wrong_result` comes with `run_scenario`, editing on or off:
+ * whoever reads a replay's results may need to say they are wrong.
+ */
 function listTools(cwd) {
     if (runnerOff(cwd))
         return [];
@@ -728,6 +829,7 @@ function listTools(cwd) {
     const reading = editing || readToolsOptedIn();
     return [
         TOOL,
+        REPORT_TOOL,
         ...SCENARIO_TOOLS.filter((t) => (t.changes ? editing : reading)).map(({ name, description, inputSchema }) => ({
             name,
             description,
@@ -968,7 +1070,8 @@ function main() {
         cwd,
         state: () => {
             const off = runnerOff(cwd);
-            return { tools: off ? 0 : listTools(cwd).length, off };
+            const tools = off ? [] : listTools(cwd);
+            return { tools: tools.length, off, report: tools.some((t) => t.name === REPORT_TOOL_NAME) };
         },
     });
     /**
@@ -1035,6 +1138,27 @@ function main() {
         }
         reply({ jsonrpc: "2.0", id, result: answer });
     };
+    /** `report_wrong_result`: tell the control server, and answer exactly once — unless cancelled. */
+    const answerReport = async (id, flight, reason, toolUseId) => {
+        let result;
+        try {
+            result = await reportWrongResult(cwd, flight, reason, toolUseId);
+        }
+        catch (err) {
+            result = { ok: false, why: errText(err) };
+        }
+        if (inFlight.get(id) === flight)
+            inFlight.delete(id);
+        if (flight.cancelled || closing)
+            return;
+        logLine("scenario.reported", {
+            ok: result.ok === true,
+            held: result.held === true || undefined,
+            why: typeof result.why === "string" ? result.why.slice(0, 200) : undefined,
+            bound: toolUseId !== undefined || undefined,
+        });
+        reply({ jsonrpc: "2.0", id, result: reportAnswer(result) });
+    };
     /** A scenario tool: run `bir`, and answer exactly once — unless cancelled. */
     const answerTool = async (id, tool, args, flight) => {
         let result;
@@ -1136,6 +1260,32 @@ function main() {
                     void answerTool(id, scenarioTool, paramsObject(params.arguments), flight);
                     return;
                 }
+                if (name === REPORT_TOOL_NAME) {
+                    // Off: nothing ran a plan, so there is nothing to report — said
+                    // plainly, as the reading tools say it.
+                    if (runnerOff(cwd)) {
+                        logLine("scenario.reported", { ok: false, why: "runner is off" });
+                        reply({
+                            jsonrpc: "2.0",
+                            id,
+                            result: said("BaseInstRunner is switched off here, so there is nothing to report."),
+                        });
+                        return;
+                    }
+                    const reason = paramsObject(params.arguments).reason;
+                    if (typeof reason !== "string" || reason.trim() === "") {
+                        reply({
+                            jsonrpc: "2.0",
+                            id,
+                            result: { content: [{ type: "text", text: "`reason` is required: say in a sentence or two why the results are wrong." }], isError: true },
+                        });
+                        return;
+                    }
+                    const flight = { tool: REPORT_TOOL_NAME, cancelled: false };
+                    inFlight.set(id, flight);
+                    void answerReport(id, flight, reason.trim().slice(0, REPORT_REASON_MAX), toolUseIdOf(params));
+                    return;
+                }
                 if (name !== TOOL_NAME) {
                     reply(errorResponse(id, JsonRpcErrorCode.MethodNotFound, `unknown tool: ${params.name}`));
                     return;

package/dist/bin/bir.js

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

package/dist/bin/investigate.d.ts

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

package/dist/bin/investigate.js

@@ -203,8 +203,8 @@ export function findTurn(turns, id) {
 /** The runner's own gate vocabulary, with the cause and the fix (guide §9). */
 export const DECLINES = {
     replay_disabled: {
-        cause: "calculated replay was off in this bir-hooks (BIR_REPLAY=0), or a sub-task was handed out with BIR_SEGMENT_ARM off.",
-        fix: "start bir-hooks with BIR_REPLAY=1 (the default); for sub-tasks set BIR_SEGMENT_ARM=1.",
+        cause: "calculated replay was off in this bir-hooks (BIR_REPLAY=0), or a sub-task was handed out to a recorder that only observes sub-tasks (BIR_SEGMENT_ARM=0, or a recorder older than 0.3.19).",
+        fix: "start bir-hooks with BIR_REPLAY=1 (the default); for sub-tasks leave BIR_SEGMENT_ARM unset (on from 0.3.19), then `bir up --restart`.",
     },
     not_ready: {
         cause: "the matched recording had no ready scenario at that moment.",
@@ -434,9 +434,11 @@ export function localFindings(turn) {
     }
     for (const i of turn.incidents) {
         const fields = Object.fromEntries(Object.entries(i).filter(([k]) => k !== "at" && k !== "event"));
+        // A stop at the plan's decision is the plan working as split: no fault.
+        const decisionStop = i.event === "replay.handover" && i.kind === "decision";
         out.push({
             code: i.event.replace(/\./g, "_"),
-            severity: i.event.endsWith("_failed") || i.event === "replay.failed" ? "problem" : "warn",
+            severity: i.event.endsWith("_failed") || i.event === "replay.failed" ? "problem" : decisionStop ? "info" : "warn",
             title: `${i.event}${i.error ? `: ${String(i.error)}` : ""}`,
             cause: Object.entries(fields)
                 .map(([k, v]) => `${k}=${String(v)}`)
@@ -447,13 +449,15 @@ export function localFindings(turn) {
                     : "the turn's cost could not be read from the transcript, or the runner has no price for the model: update it. Its report is unmeasured; run bir-hooks where the Claude Code transcript is readable."
                 : i.event === "replay.handover" && i.kind === "other_branch"
                     ? "this request was the other half of the task the plan holds (a step's test said so), and the agent did it; that run is how the service learns the other half."
-                    : i.event === "replay.diverge" || i.event === "replay.handover"
-                        ? "the model left the script or the runner handed the turn back; the service section shows what the fallback cost."
-                        : i.event === "run.incomplete"
-                            ? "the recording is not the whole run, so it is never calculated and no longer catches its prompt; run the task again to record it whole."
-                            : i.event === "run.host_failed"
-                                ? "the application's run failed; its recording is closed with that error and never becomes a plan."
-                                : "see the guide's troubleshooting table for this line.",
+                    : decisionStop
+                        ? "nothing to fix: the plan stopped at its decision, as planned. It ran the steps before it, and the agent chose the way. A segment of the half it chose may have run next (a `replay.intent_armed` line with kind segment); a `run.fragment` line with decision=true is the agent's own work, from which the service makes the other half."
+                        : i.event === "replay.diverge" || i.event === "replay.handover"
+                            ? "the model left the script or the runner handed the turn back; the service section shows what the fallback cost."
+                            : i.event === "run.incomplete"
+                                ? "the recording is not the whole run, so it is never calculated and no longer catches its prompt; run the task again to record it whole."
+                                : i.event === "run.host_failed"
+                                    ? "the application's run failed; its recording is closed with that error and never becomes a plan."
+                                    : "see the guide's troubleshooting table for this line.",
         });
     }
     const r = turn.reported;
@@ -536,6 +540,12 @@ export function savedPct(turn) {
     return baseline > 0 ? r.savedUsd / baseline : null;
 }
 const short = (id) => (id ? id.slice(0, 13) : "—");
+/**
+ * An execution's outcome, and where it handed the task over when the service
+ * says (`fell_back · decision`). The service sends `fallbackKind: null` for a
+ * run that did not hand over, and an older one sends nothing.
+ */
+const outcomeOf = (e) => typeof e.fallbackKind === "string" && e.fallbackKind !== "" ? `${e.outcome} · ${e.fallbackKind}` : e.outcome;
 /** 4624 → "4,624", whatever the machine's locale. */
 const count = (n) => String(n).replace(/\B(?=(\d{3})+(?!\d))/g, ",");
 const money = (v) => (v == null ? "—" : usd(v));
@@ -638,6 +648,10 @@ export function renderService(out, s, viewerIsOwner) {
         if (sc.held) {
             out(`            HELD since ${when(sc.held.at ?? undefined)}${sc.held.reason ? ` (${sc.held.reason})` : ""}: not handed out — the agent does the task until the plan is corrected or let go${sc.held.runId ? `; the redo is ${sc.held.runId}` : ""}`);
         }
+        if (typeof sc.decisionStep === "number") {
+            const text = typeof sc.decisionText === "string" ? sc.decisionText.replace(/\s+/g, " ").trim() : "";
+            out(`            decision at step ${sc.decisionStep}: the plan stops in front of it, and the agent decides${text ? ` (${text.length > 160 ? `${text.slice(0, 160)}…` : text})` : ""}`);
+        }
         for (const line of stepLines(sc.steps))
             out(`            ${line}`);
         const correction = newestCorrection(sc.corrections);
@@ -655,7 +669,7 @@ export function renderService(out, s, viewerIsOwner) {
     if (ex.length > 0) {
         out(`  executions (${ex.length}, newest first)`);
         for (const e of ex.slice(0, 10)) {
-            out(`    ${when(e.createdAt)}  ${short(e.id)}  ${e.outcome.padEnd(13)} cost ${usd(e.costUsd)}  saved ${money(e.savedUsd)}${e.savedPct != null ? ` (${pct(e.savedPct)})` : ""}${e.measured ? "" : "  unmeasured"}`);
+            out(`    ${when(e.createdAt)}  ${short(e.id)}  ${outcomeOf(e).padEnd(13)} cost ${usd(e.costUsd)}  saved ${money(e.savedUsd)}${e.savedPct != null ? ` (${pct(e.savedPct)})` : ""}${e.measured ? "" : "  unmeasured"}`);
             const failed = e.steps?.filter((st) => st.status === "failed") ?? [];
             for (const st of failed)
                 out(`        step ${st.stepIndex} ${st.toolName ?? ""} failed${st.error ? `: ${st.error.slice(0, 120)}` : ""}`);
@@ -790,7 +804,7 @@ export async function investigateCommand(args, deps) {
         if (rows.length === 0)
             out("  none yet");
         for (const e of rows) {
-            out(`  ${when(e.createdAt)}  ${e.id}  ${e.outcome.padEnd(13)} cost ${usd(e.costUsd)}  saved ${money(e.savedUsd)}${e.savedPct != null ? ` (${pct(e.savedPct)})` : ""}${e.measured ? "" : "  unmeasured"}`);
+            out(`  ${when(e.createdAt)}  ${e.id}  ${outcomeOf(e).padEnd(13)} cost ${usd(e.costUsd)}  saved ${money(e.savedUsd)}${e.savedPct != null ? ` (${pct(e.savedPct)})` : ""}${e.measured ? "" : "  unmeasured"}`);
             out(`      scenario ${e.scenarioId}${e.runId ? `  run ${e.runId}` : ""}${e.intent ? `  "${e.intent.slice(0, 60)}"` : ""}`);
         }
         out();

package/dist/bin/scenario-edit.d.ts

@@ -222,6 +222,13 @@ export declare const SCENARIO_EDIT_SUBCOMMANDS: ReadonlySet<string>;
 export declare const READ_TOOLS: readonly ["scenario_show", "scenario_edits", "investigate"];
 /** The ones that change a scenario: offered only after `bir scenario editing on` (D2). */
 export declare const EDIT_TOOLS: readonly ["scenario_check", "scenario_edit", "scenario_undo"];
+/**
+ * The ones every session with the `bir` server has, editing on or off: the
+ * delivery of a direct plan, and the agent's way to say a replay's results do
+ * not answer the request (the service's review of calcscenarioautocorrect.md,
+ * item 19). `bir setup`'s allow rule, `mcp__bir`, covers every one.
+ */
+export declare const BASE_TOOLS: readonly ["run_scenario", "report_wrong_result"];
 export declare function scenarioEditCommand(args: ScenarioEditArgs, deps: ScenarioEditDeps): Promise<number>;
 /**
  * A logic file's text. UTF-8, with a byte-order mark dropped — and UTF-16 with

package/dist/bin/scenario-edit.js

@@ -59,6 +59,13 @@ export const SCENARIO_EDIT_SUBCOMMANDS = new Set([
 export const READ_TOOLS = ["scenario_show", "scenario_edits", "investigate"];
 /** The ones that change a scenario: offered only after `bir scenario editing on` (D2). */
 export const EDIT_TOOLS = ["scenario_check", "scenario_edit", "scenario_undo"];
+/**
+ * The ones every session with the `bir` server has, editing on or off: the
+ * delivery of a direct plan, and the agent's way to say a replay's results do
+ * not answer the request (the service's review of calcscenarioautocorrect.md,
+ * item 19). `bir setup`'s allow rule, `mcp__bir`, covers every one.
+ */
+export const BASE_TOOLS = ["run_scenario", "report_wrong_result"];
 const USAGE = {
     show: "usage: bir scenario show <runId|scnId> [--step <n>]",
     check: "usage: bir scenario check <runId|scnId> --step <n> [--input-logic <file|->] [--output-logic <file|->] [--unfreeze] [--json]",
@@ -1067,11 +1074,11 @@ function describeEditing(out, sidecar, cwd) {
     // working on a scenario, and every other session would pay for their
     // definitions on every request without ever calling them.
     if (on) {
-        out(`  the bir MCP server offers  run_scenario, ${READ_TOOLS.join(", ")}  (they read)`);
+        out(`  the bir MCP server offers  ${[...BASE_TOOLS, ...READ_TOOLS].join(", ")}  (they read)`);
         out(`                        and  ${EDIT_TOOLS.join(", ")}  (they change a scenario)`);
     }
     else {
-        out("  the bir MCP server offers  run_scenario");
+        out(`  the bir MCP server offers  ${BASE_TOOLS.join(", ")}`);
         out(`  \`bir scenario editing on\` adds ${EDIT_TOOLS.join(", ")}  (they change a scenario)`);
         out(`                        and  ${READ_TOOLS.join(", ")}  (they read)`);
         out("  (BIR_SCENARIO_TOOLS=read in the server's environment offers the reading ones alone)");
@@ -1224,6 +1231,16 @@ function explain(reply, args, deps, e) {
             // newer entry puts the step back as this one left it, and then this one
             // can be undone. It used to loop, when undo only toggled (C23).
             const latest = typeof body.latestEditId === "string" ? body.latestEditId : "<the newer edit>";
+            if (latest.startsWith("ssplit_")) {
+                // The plan was split at its decision since (the service's
+                // segmentsbreakdown.md). No `--edit` takes a split back: its Undo is
+                // on the recording page's Split card, and only then can this go.
+                const what = aboutCorrection ? "correction" : "edit";
+                out(`${e.verb} (not_latest_edit): the plan was split at its decision after that ${what} (${latest}). ` +
+                    `It cannot be taken back while the split is in use: undo the split first (Undo on the Split card of the plan's recording page), then this ${what}:`);
+                out(`  bir scenario undo ${target} --edit ${e.editId ?? "<this edit>"}`);
+                return 1;
+            }
             out(aboutCorrection
                 ? `${e.verb} (not_latest_edit): the plan has changed since that correction — ${latest} changed it after. Undo the newer one first, then this one:`
                 : `${e.verb} (not_latest_edit): the ${aboutParam ? "parameter" : "step"} has changed since that edit — ${latest} changed it after. Undo the newer one first, then this one:`);

package/dist/bin/scenario-liveness.d.ts

@@ -75,6 +75,13 @@ export interface HelloBody {
     /** How many tools this server lists now (0 when off). */
     tools: number;
     off: boolean;
+    /**
+     * It lists `report_wrong_result` (runner 0.3.18 on; the service's review of
+     * calcscenarioautocorrect.md, item 19): a replay's results may then tell the
+     * agent it can say they are wrong. Sent only when true; an older recorder
+     * ignores it.
+     */
+    report?: boolean;
 }
 /** A discovery record as written, its pid not yet checked. */
 export interface RecorderRecord {
@@ -100,10 +107,14 @@ export declare function launchRevive(cwd: string): Promise<void>;
 export interface LivenessOptions {
     /** The project this server runs for. */
     cwd: string;
-    /** What this server lists now. Called for every hello. */
+    /**
+     * What this server lists now. Called for every hello. `report`: the list
+     * holds `report_wrong_result` (review item 19).
+     */
     state: () => {
         tools: number;
         off: boolean;
+        report?: boolean;
     };
     now?: () => number;
     random?: () => number;

package/dist/bin/scenario-liveness.js

@@ -314,10 +314,14 @@ export class ScenarioLiveness {
     state() {
         try {
             const s = this.opts.state();
-            return { tools: Number.isInteger(s.tools) && s.tools >= 0 ? s.tools : 0, off: s.off === true };
+            return {
+                tools: Number.isInteger(s.tools) && s.tools >= 0 ? s.tools : 0,
+                off: s.off === true,
+                report: s.report === true && s.off !== true,
+            };
         }
         catch {
-            return { tools: 0, off: false };
+            return { tools: 0, off: false, report: false };
         }
     }
     async sendHello(why) {
@@ -330,8 +334,8 @@ export class ScenarioLiveness {
             const target = this.target();
             if (!target)
                 return;
-            const { tools, off } = this.state();
-            const body = { pid: process.pid, version: packageVersion(), tools, off };
+            const { tools, off, report } = this.state();
+            const body = { pid: process.pid, version: packageVersion(), tools, off, ...(report ? { report } : {}) };
             this.tried = target.identity;
             this.lastHelloAt = this.now();
             let reach;

package/dist/bin/setup.js

@@ -43,7 +43,7 @@ import { normalizePath } from "../control/paths.js";
 import { allowRules, BIR_TOOLS_RULE, claudeCodePaths, claudeCodeSetUp } from "../config/adapters/claude-code.js";
 import { allocateReplacementPort, editingEnabled, isScenarioServer, isWrapped, LOOPBACK_NO_PROXY, probeFreePort, proxyConfigured, projectRecord, readSidecar, SCENARIO_SERVER_KEY, setProjectRecord, settleReplaySwitch, writeSidecar, allocateFreeProjectPort, } from "../config/generate.js";
 import { resolveServers } from "../config/resolve.js";
-import { EDIT_TOOLS, READ_TOOLS } from "./scenario-edit.js";
+import { BASE_TOOLS, EDIT_TOOLS, READ_TOOLS } from "./scenario-edit.js";
 import { errText } from "../util/log.js";
 import { offSource } from "../util/off-switch.js";
 import { packageVersion } from "../util/version.js";
@@ -508,8 +508,8 @@ export async function runSetup(args, deps) {
     if (resolveServers(project).some((s) => s.name === SCENARIO_SERVER_KEY && isScenarioServer(s.config))) {
         const asks = !allowRules(claudeCodePaths(project).settingsLocal).includes(BIR_TOOLS_RULE);
         out(editingEnabled(readSidecar(), project)
-            ? `  tools      ${["run_scenario", ...READ_TOOLS, ...EDIT_TOOLS].join(", ")} — ${asks ? "Claude Code asks before each" : "Claude Code runs them without asking, except a forced change"}`
-            : "  tools      run_scenario only — scenario editing is off here (`bir scenario editing on` adds investigate and the scenario tools)");
+            ? `  tools      ${[...BASE_TOOLS, ...READ_TOOLS, ...EDIT_TOOLS].join(", ")} — ${asks ? "Claude Code asks before each" : "Claude Code runs them without asking, except a forced change"}`
+            : `  tools      ${BASE_TOOLS.join(" and ")} only — scenario editing is off here (\`bir scenario editing on\` adds investigate and the scenario tools)`);
     }
     if (ensured) {
         const { info, health: h } = ensured.status;

package/dist/control/client.d.ts

@@ -68,6 +68,11 @@ export declare class ControlClient {
     }): Promise<RegisterResult | undefined>;
     /** Report one completed MCP call. Resolves false when the send was dropped. */
     report(step: ProxyStepReport): Promise<boolean>;
+    /**
+     * The tool list of the server this proxy wraps, as it answered `tools/list`
+     * (the service's autocorrect.md AC12). Resolves false when the send was dropped.
+     */
+    tools(serverName: string, tools: readonly unknown[]): Promise<boolean>;
     health(): Promise<Record<string, unknown> | undefined>;
     /**
      * Ask the control server to shut down. Resolves true when it agreed; the

package/dist/control/client.js

@@ -26,6 +26,13 @@ export class ControlClient {
         const body = this.identity ? { ...step, proxyId: this.identity.proxyId } : step;
         return (await this.post("/proxy/step", body)) !== undefined;
     }
+    /**
+     * The tool list of the server this proxy wraps, as it answered `tools/list`
+     * (the service's autocorrect.md AC12). Resolves false when the send was dropped.
+     */
+    async tools(serverName, tools) {
+        return (await this.post("/proxy/tools", { ...this.identity, serverName, tools })) !== undefined;
+    }
     async health() {
         return (await this.request("GET", "/health"));
     }