@basein/runner 0.3.15 → 0.3.17

package/README.md

@@ -393,6 +393,12 @@ which `bir setup` turns on (`bir scenario editing on` in a project wired by
 `bir install`). Step by step, with real output:
 [the guide's §9.2](docs/calculatedReplayGuide.md).
 
+The service can correct a plan itself too, after the agent did a planned task
+again its own way (built 2026-10-23, not yet released). `bir scenario edits`
+lists such a correction beside the hand edits, under its `scor_` id. Undoing it
+puts back the whole plan from before, and the plan is then held until you
+choose "Use it again" on the recording page.
+
 ```bash
 bir scenario show  scn_… --step 3                          # read one step (scenarioId and chainRevision first)
 bir scenario check scn_… --step 3 --input-logic step3.js   # try a change; nothing is saved
@@ -400,6 +406,7 @@ bir scenario edit  scn_… --step 3 --input-logic step3.js --note "why"   # the
 bir scenario edits scn_…                                   # the history, newest first
 bir scenario undo  scn_…                                   # take back the newest edit; again to go further back
 bir scenario undo  scn_… --step 3                          # take back step 3's newest edit only
+bir scenario undo  scn_… --edit scor_…                     # take back a correction the service made
 bir scenario calc  scn_… --force --discard-edits           # recalculate this plan, dropping its hand edits
 bir scenario editing on                                    # let Claude's `bir` tools change scenarios here (setup did)
 ```

package/dist/bin/bir-scenario.js

@@ -497,7 +497,9 @@ const SCENARIO_TOOLS = [
         changes: false,
         service: true,
         description: "List a calculated scenario's hand edits, newest first — step edits and parameter kind changes: step or " +
-            "parameter, note, revision, and whether each was forced, undone or replaced by a recalculation.",
+            "parameter, note, revision, and whether each was forced, undone or replaced by a recalculation — and the " +
+            "corrections the service made from a run the agent redid (scor_ ids): what each added, tested or changed, " +
+            "and whether it is used.",
         inputSchema: {
             type: "object",
             properties: { target: TARGET },
@@ -646,14 +648,15 @@ const SCENARIO_TOOLS = [
             "edit. Without `edit`, the newest edit that can be undone (of `step` or `param`, when given); calling it again goes " +
             "one further back. The service checks a step's undo like a save and refuses it when a later step or the final " +
             "answer would break — `force` with a `note` undoes it anyway. To redo, undo the undo: pass its id as `edit` (the " +
-            "answer names it).",
+            "answer names it). A scor_ id takes back a correction the service made: the plan goes back exactly as it was " +
+            "before it, and is held — not used — until it is corrected again or let go on the recording page.",
         inputSchema: {
             type: "object",
             properties: {
                 target: TARGET,
                 edit: {
                     type: "string",
-                    description: "The sedit_ or pedit_ id to undo, as scenario_edits lists it. Not with `step` or `param`.",
+                    description: "The sedit_, pedit_ or scor_ id to undo, as scenario_edits lists it. Not with `step` or `param`.",
                 },
                 step: {
                     ...STEP,
@@ -679,8 +682,8 @@ const SCENARIO_TOOLS = [
                 throw new BadArguments("`edit`, `step` and `param` each pick what to undo; give one of them");
             }
             if (a.edit !== undefined && a.edit !== null) {
-                if (typeof a.edit !== "string" || !/^(sedit|pedit)_[\w-]+$/.test(a.edit)) {
-                    throw new BadArguments("`edit` must be a sedit_… or pedit_… id");
+                if (typeof a.edit !== "string" || !/^(sedit|pedit|scor)_[\w-]+$/.test(a.edit)) {
+                    throw new BadArguments("`edit` must be a sedit_…, pedit_… or scor_… id");
                 }
                 if (a.step !== undefined && a.step !== null) {
                     throw new BadArguments("`edit` names one entry and `step` picks one; give one of them");

package/dist/bin/bir.js

@@ -172,7 +172,8 @@ Options:
   --unfreeze        scenario check|edit: ask to remove that mark; the check decides
   --note <text>     scenario edit|undo: why, kept in the history (required with --force)
   --revision <n>    scenario edit|undo: only if the plan is still at this chainRevision
-  --edit <id>       scenario undo: the sedit_ or pedit_ id to undo (default: the newest that can be)
+  --edit <id>       scenario undo: the sedit_, pedit_ or scor_ id to undo (default: the newest
+                    that can be); a scor_ id puts back the plan from before that correction
   --param <name>    scenario edit: the parameter whose kind changes · scenario undo: its newest change
   --kind <kind>     scenario edit --param: target (a prompt must name it) or setting (its
                     recorded value is used when a prompt names none; needs --note)

package/dist/bin/investigate.d.ts

@@ -78,6 +78,12 @@ export interface Turn {
         ticket?: string;
         scenarioId?: string;
         declined?: string;
+        /**
+         * The plan ran to its end and the agent redid the task: the repeat run it
+         * was recorded as, and the agent's own calls in it (autocorrect.md AC1).
+         */
+        redoneBy?: string;
+        ownCalls?: number;
     };
     finish?: {
         steps?: number;
@@ -86,6 +92,16 @@ export interface Turn {
         measured?: boolean;
         recorded?: boolean;
     };
+    /**
+     * The model's own work in a matched turn, recorded as the recording's newest
+     * run (`run.repeat`): its run id, the recording it repeats, and why — the
+     * plan did not run, or `redone` after it ran to its end.
+     */
+    repeat?: {
+        runId?: string;
+        of?: string;
+        reason?: string;
+    };
     /** `replay.*_failed`, `replay.arm_failed`, `replay.diverge`, `replay.handover` … */
     incidents: JournalEntry[];
     events: JournalEntry[];
@@ -138,6 +154,31 @@ export interface InvestigateArgs {
     user?: string;
     limit?: number;
 }
+/**
+ * The service's verdict on a turn whose plan the agent redid (its
+ * autocorrect.md AC3): did the agent reject the result, why, and what it left.
+ */
+interface ServiceVerdict {
+    accepted?: boolean;
+    kind?: string;
+    why?: string;
+    rejectedSteps?: number[];
+    leftInPlace?: string[];
+    condition?: string | null;
+}
+/** A correction of the plan, in brief (AC6, AC7). */
+interface ServiceCorrection {
+    id: string;
+    state?: string;
+    createdAt?: string;
+    usedAt?: string | null;
+    summary?: string | null;
+    added?: number[];
+    tested?: number[];
+    changed?: number[];
+    answerChanged?: boolean;
+    problems?: string[];
+}
 interface ServiceInvestigation {
     subject?: {
         kind: string;
@@ -159,6 +200,14 @@ interface ServiceInvestigation {
         isRecording: boolean;
         embedded: boolean;
         duplicateOf: string | null;
+        /** A repeat: the agent doing that run's task again itself (newestRun.md). */
+        repeatOfRunId?: string | null;
+        /** Why: the plan did not run, or `redone` after it ran to its end. */
+        repeatReason?: string | null;
+        /** On a redo: the plan's execution it redid (autocorrect.md AC1). */
+        executionId?: string | null;
+        /** On a recording: the agent's newest run of its task. */
+        newestRunId?: string | null;
     } | null;
     scenario?: {
         id: string;
@@ -167,6 +216,14 @@ interface ServiceInvestigation {
             stepIndex: number;
             toolName: string | null;
             failureCount: number;
+            /** Runs only when its test says so (AC5). */
+            when?: {
+                otherwise?: string;
+                text?: string | null;
+            } | null;
+            /** Added, tested or changed by a correction (AC6). */
+            correctionId?: string | null;
+            correctionKind?: string | null;
         }>;
         baseline: {
             costUsd: number | null;
@@ -180,6 +237,14 @@ interface ServiceInvestigation {
         hitCount: number | null;
         disabledAt: string | null;
         error: string | null;
+        /** Not handed out until it is corrected or let go (AC4). */
+        held?: {
+            at?: string | null;
+            reason?: string | null;
+            executionId?: string | null;
+            runId?: string | null;
+        } | null;
+        corrections?: ServiceCorrection[];
     } | null;
     executions?: Array<{
         id: string;
@@ -200,6 +265,12 @@ interface ServiceInvestigation {
             status: string;
             error?: string;
         }> | null;
+        /** The repeat the agent redid the task in, and its own calls there (AC1). */
+        redoneByRunId?: string | null;
+        redoneOwnCalls?: number | null;
+        /** The service's verdict on that redo, and where it stands (AC3). */
+        verdict?: ServiceVerdict | null;
+        verdictState?: string | null;
     }>;
     findings?: Finding[];
 }

package/dist/bin/investigate.js

@@ -65,8 +65,23 @@ export function turnsFromJournal(entries) {
         // matching turn, not about the recording's own (long finished) turn.
         if (run) {
             for (let i = turns.length - 1; i >= 0; i -= 1) {
-                if (turns[i].runId === run || turns[i].matched?.runId === run)
+                // A turn recorded as a repeat goes on under the repeat's own run id.
+                if (turns[i].runId === run || turns[i].matched?.runId === run || turns[i].repeat?.runId === run) {
                     return turns[i];
+                }
+            }
+        }
+        // The repeat's own line names a run no turn has yet: it belongs to the
+        // newest turn that matched the recording it repeats (`of`) and opened no
+        // repeat so far — never simply the newest turn, which with two sessions in
+        // one project may be the other session's.
+        if (e.event === "run.repeat") {
+            const of = str(e.of);
+            if (of) {
+                for (let i = turns.length - 1; i >= 0; i -= 1) {
+                    if (turns[i].matched?.runId === of && !turns[i].repeat)
+                        return turns[i];
+                }
             }
         }
         if (e.event === "execution.reported") {
@@ -143,8 +158,13 @@ export function turnsFromJournal(entries) {
                     ticket: str(e.ticket),
                     scenarioId: str(e.scenario),
                     declined: str(e.declined),
+                    redoneBy: str(e.redoneBy),
+                    ownCalls: num(e.ownCalls),
                 };
                 break;
+            case "run.repeat":
+                turn.repeat = { runId: str(e.run), of: str(e.of), reason: str(e.reason) };
+                break;
             case "run.finish":
                 turn.finishedAt = e.at;
                 turn.finish = {
@@ -171,7 +191,10 @@ export function findTurn(turns, id) {
             t.matched?.scenarioId === id ||
             t.plan?.scenarioId === id ||
             t.reported?.scenarioId === id ||
-            t.reported?.ticket === id) {
+            t.reported?.ticket === id ||
+            // The repeat the turn was recorded as (newestRun.md), a redo included.
+            t.repeat?.runId === id ||
+            t.reported?.redoneBy === id) {
             return t;
         }
     }
@@ -228,6 +251,10 @@ export const DECLINES = {
         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.",
         fix: "nothing in the prompt has to change: run it again a few minutes later. A `service.recovered` line just after this turn's `run.start` means an old failure was still on record, and the next prompt waits again. If it keeps happening without one, the service answers matches slowly: `bir doctor` shows its state, and `/health.matchGate` when prompts wait again.",
     },
+    held: {
+        cause: "the service matched the prompt and handed over no plan: it holds the plan, because after the plan's last run the agent did the task again its own way. The service judges that redo first, and then keeps the plan back until its owner decides.",
+        fix: "open the recording page: read the verdict, then use the correction if there is one, or choose \"Use it again\". `bir investigate <scnId>` shows the hold, the verdict and the newest correction. Until then the agent does the task.",
+    },
     runner_update_required: {
         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.",
@@ -236,7 +263,7 @@ export const DECLINES = {
         cause: "the chain could not be flattened — a sub-task it calls no longer resolves.",
         fix: "recalculate the scenario.",
     },
-    // The two gates of a host that is not Claude Code (a LangChain application).
+    // 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.",
         fix: "nothing to do while replay for LangChain is not released. After that: update the runner. Until then the model does the task, and the run counts as a sample of the usual cost.",
@@ -245,6 +272,10 @@ export const DECLINES = {
         cause: "the plan names a tool that the agent which asked does not have.",
         fix: "give the agent that tool, or delete the recording so the task is recorded again; `bir scenario show <scnId>` lists the plan's tools.",
     },
+    host_tests_unsupported: {
+        cause: "the plan has steps that run only when a test says so (an \"if … otherwise\"), and the LangChain package steps through a plan call by call without reading those tests yet, so the runner did not hand it the plan.",
+        fix: "nothing to change in the prompt: the model does the task, and the run counts as a sample of the usual cost. A plan without tests still runs there.",
+    },
 };
 /** Whether a turn ran in a host that is not Claude Code (see {@link Turn.host}). */
 function otherHost(turn) {
@@ -337,7 +368,8 @@ export function localFindings(turn) {
         const reading = readingDecline(code, turn.decision.why ?? "");
         out.push({
             code: `declined_${code || "unknown"}`,
-            severity: code === "not_ready" && !turn.matched.scenarioId ? "info" : "problem",
+            // A held plan is not broken: it waits for its owner's decision.
+            severity: code === "not_ready" && !turn.matched.scenarioId ? "info" : code === "held" ? "warn" : "problem",
             title: `Matched ${turn.matched.runId} but declined to steer: ${turn.decision.why ?? code}.`,
             cause: reading?.cause ?? known?.cause ?? "the runner's log line carries the reason text.",
             fix: reading?.fix ??
@@ -413,16 +445,27 @@ export function localFindings(turn) {
                 ? otherHost(turn)
                     ? HOST_UNMEASURED
                     : "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.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.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.",
         });
     }
     const r = turn.reported;
+    if (r?.redoneBy) {
+        out.push({
+            code: "redone",
+            severity: "warn",
+            title: `The plan ran to its end, and the agent did not take its result: it did the task again (${r.redoneBy}${r.ownCalls != null ? `, ${r.ownCalls} calls of its own` : ""}).`,
+            cause: "The service keeps that run as the recording's newest run, with the plan's own calls first. It judges the turn — did the agent reject the result, and why — and holds the plan while it does, so a wrong half is not done again; a correction of the plan may follow.",
+            fix: `\`bir investigate ${r.redoneBy}\` shows the redo; the service section below shows the verdict, the hold and any correction (\`bir scenario edits <scnId>\` lists corrections, \`bir scenario undo <scnId> --edit scor_…\` takes one back).`,
+        });
+    }
     if (r) {
         if (r.measured === false) {
             out.push(otherHost(turn)
@@ -542,6 +585,9 @@ export function renderTurn(out, turn) {
     if (turn.done) {
         out(`  replay    ${turn.done.outcome}${turn.done.steps ? ` ${turn.done.steps} steps` : ""}${turn.done.ms != null ? ` in ${(turn.done.ms / 1000).toFixed(1)} s` : ""}`);
     }
+    if (turn.repeat?.runId) {
+        out(`  repeat    ${turn.repeat.runId}${turn.repeat.of ? ` — the newest run of ${turn.repeat.of}` : ""}${turn.repeat.reason ? ` (${turn.repeat.reason})` : ""}`);
+    }
     if (turn.reported) {
         const r = turn.reported;
         const p = savedPct(turn);
@@ -550,7 +596,9 @@ export function renderTurn(out, turn) {
             (r.savedUsd != null
                 ? `  → saved ${usd(r.savedUsd)}${p != null ? ` (${pct(p)} of ${usd(r.savedUsd + cost)})` : ""}`
                 : "") +
-            (r.measured === false ? "  UNMEASURED" : ""));
+            (r.measured === false ? "  UNMEASURED" : "") +
+            // The agent did not take the plan's result (autocorrect.md AC1).
+            (r.redoneBy ? `  redone by ${r.redoneBy}${r.ownCalls != null ? ` (${r.ownCalls} calls of its own)` : ""}` : ""));
     }
     if (turn.finish) {
         const f = turn.finish;
@@ -563,11 +611,23 @@ export function renderTurn(out, turn) {
 export function renderService(out, s, viewerIsOwner) {
     out();
     out(`From the service${s.subject ? ` (${s.subject.kind} ${s.subject.id})` : ""}${s.owner ? `, owner ${viewerIsOwner ? "you" : (s.owner.email ?? s.owner.id)}` : ""}:`);
-    if (s.run) {
+    if (s.run?.repeatOfRunId) {
+        // A repeat is evidence, never a recording (newestRun.md N4): it is not
+        // listed, not embedded and never calculated, so none of those words — and
+        // no "calculate it" — belongs to it.
+        const r = s.run;
+        out(`  repeat    ${r.id}  the newest run of ${r.repeatOfRunId}${r.repeatReason ? ` (${r.repeatReason})` : ""}  ${r.actionCount} tool calls of the agent's own (${r.tools.join(", ") || "none"})  cost ${money(r.originalCostUsd)}`);
+        if (r.executionId)
+            out(`            redid the plan's run ${r.executionId}`);
+        out("            a repeat is evidence about its recording's task, not a recording of its own: no plan is ever made from it");
+    }
+    else if (s.run) {
         const r = s.run;
         out(`  recording ${r.id}  ${r.isRecording ? "listed" : "below threshold"}${r.embedded ? ", embedded" : ", NOT embedded"}  ${r.actionCount} tool calls (${r.tools.join(", ") || "none"})  cost ${money(r.originalCostUsd)}  hits ${r.iterations}${r.duplicateOf ? `  duplicate of ${r.duplicateOf}` : ""}`);
         if (r.title || r.input)
             out(`            "${(r.title ?? r.input).replace(/\s+/g, " ").slice(0, 100)}"`);
+        if (r.newestRunId)
+            out(`            newest run of its task ${r.newestRunId}`);
     }
     else {
         out("  recording none");
@@ -575,6 +635,14 @@ export function renderService(out, s, viewerIsOwner) {
     if (s.scenario) {
         const sc = s.scenario;
         out(`  scenario  ${sc.id}  ${sc.state}${sc.disabledAt ? " (switched off)" : ""}  ${sc.steps.length} steps (${[...new Set(sc.steps.map((x) => x.toolName ?? "?"))].join(", ")})  baseline ${money(sc.baseline.costUsd)} from ${sc.baseline.samples} sample(s)${sc.hitCount != null ? `  hits ${sc.hitCount}` : ""}`);
+        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}` : ""}`);
+        }
+        for (const line of stepLines(sc.steps))
+            out(`            ${line}`);
+        const correction = newestCorrection(sc.corrections);
+        if (correction)
+            out(`            ${correctionLine(correction)}`);
         if (sc.lastDecline)
             out(`            last decline ${sc.lastDecline.reason} at ${when(sc.lastDecline.at ?? undefined)}`);
         if (sc.error)
@@ -591,10 +659,74 @@ export function renderService(out, s, viewerIsOwner) {
             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)}` : ""}`);
+            const notTaken = e.steps?.filter((st) => st.status === "not_taken") ?? [];
+            if (notTaken.length > 0)
+                out(`        not needed: step${notTaken.length === 1 ? "" : "s"} ${notTaken.map((st) => st.stepIndex).join(", ")}`);
+            if (e.redoneByRunId) {
+                out(`        redone by ${e.redoneByRunId}${e.redoneOwnCalls != null ? ` (${e.redoneOwnCalls} calls of the agent's own)` : ""}`);
+            }
+            for (const line of verdictLines(e.verdict, e.verdictState))
+                out(`        ${line}`);
         }
     }
     renderFindings(out, s.findings ?? [], "Service findings");
 }
+/** The steps that run only under a test, or that a correction made, one line each (AC5, AC6). */
+function stepLines(steps) {
+    const lines = [];
+    for (const st of steps) {
+        const parts = [];
+        if (st.when) {
+            const otherwise = st.when.otherwise === "skip" ? "otherwise skip" : st.when.otherwise === "hand_over" ? "otherwise hand over" : "";
+            parts.push(`only when ${st.when.text ?? "its test says so"}${otherwise ? `, ${otherwise}` : ""}`);
+        }
+        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("; ")}`);
+    }
+    return lines;
+}
+/** The newest correction of a plan, by when it was made. */
+function newestCorrection(corrections) {
+    return [...(corrections ?? [])]
+        .filter((c) => typeof c?.id === "string")
+        .sort((x, y) => ((x.createdAt ?? "") < (y.createdAt ?? "") ? 1 : (x.createdAt ?? "") > (y.createdAt ?? "") ? -1 : 0))[0];
+}
+function correctionLine(c) {
+    const what = [];
+    if (c.added?.length)
+        what.push(`${c.added.length} step${c.added.length === 1 ? "" : "s"} added`);
+    if (c.tested?.length)
+        what.push(`tests on ${c.tested.length} step${c.tested.length === 1 ? "" : "s"}`);
+    if (c.changed?.length)
+        what.push(`${c.changed.length} step${c.changed.length === 1 ? "" : "s"} changed`);
+    if (c.answerChanged)
+        what.push("the answer changed");
+    const state = c.state === "proposed"
+        ? 'shown, not used yet ("Use the correction" on the recording page)'
+        : c.state === "used"
+            ? `used${c.usedAt ? ` ${when(c.usedAt)}` : ""}`
+            : c.state === "failed"
+                ? `not used: its check failed${c.problems?.[0] ? ` — ${c.problems[0].slice(0, 120)}` : ""}`
+                : (c.state ?? "");
+    return `correction ${c.id}  ${state}${what.length ? `  (${what.join(", ")})` : ""}${c.summary ? `  ${c.summary.replace(/\s+/g, " ").slice(0, 120)}` : ""}`;
+}
+/** The service's verdict on a redone turn, in words (AC3). */
+function verdictLines(verdict, state) {
+    if (!verdict) {
+        return state && state !== "done" ? [`verdict ${state === "waiting" ? "waiting (the service judges the turn when the redo has finished)" : state}`] : [];
+    }
+    const lines = [`verdict ${verdict.kind ?? (verdict.accepted ? "accepted" : "?")}${verdict.why ? `: ${verdict.why}` : ""}`];
+    if (verdict.rejectedSteps?.length)
+        lines.push(`rejected step${verdict.rejectedSteps.length === 1 ? "" : "s"} ${verdict.rejectedSteps.join(", ")}`);
+    if (verdict.condition)
+        lines.push(`the test it needs: ${verdict.condition}`);
+    if (verdict.leftInPlace?.length) {
+        lines.push(`left in place (remove by hand if it should not be there): ${verdict.leftInPlace.join("; ")}`);
+    }
+    return lines;
+}
 // ── the command ───────────────────────────────────────────────────────────────
 async function fetchInvestigation(deps, id, limit, clock) {
     const reply = await clock.within(deps.service(`/investigate/${id}${limit ? `?limit=${limit}` : ""}`));

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

@@ -138,6 +138,37 @@ export interface ParamEditEntry {
     /** A recalculation dropped the parameter; the entry is history now. */
     replacedAt: string | null;
 }
+/**
+ * A correction the service made from a run the agent redid (its
+ * autocorrect.md AC6): the plan changed as a whole — steps added, tests put
+ * on steps, a step's code or the answer's changed — and checked by code over
+ * the recording and the redone turn before it was kept. `bir scenario undo
+ * --edit scor_…` puts the plan back as it was before it, and holds it.
+ */
+export interface CorrectionEntry {
+    id: string;
+    scenarioId: string;
+    /**
+     * `proposed`: made and checked, shown, not used yet (SCENARIO_AUTOCORRECT=observe);
+     * `used`: the plan runs it; `failed`: its check failed, nothing was kept;
+     * `undone`: taken back; `replaced`: a recalculation replaced the plan since.
+     */
+    state: "proposed" | "used" | "failed" | "undone" | "replaced" | string;
+    createdAt: string;
+    usedAt?: string | null;
+    undoneAt?: string | null;
+    executionId?: string | null;
+    redoneRunId?: string | null;
+    verdictKind?: string | null;
+    summary?: string | null;
+    added?: number[];
+    tested?: number[];
+    changed?: number[];
+    answerChanged?: boolean;
+    problems?: string[];
+    chainRevisionBefore?: number | null;
+    chainRevisionAfter?: number | null;
+}
 export type ServiceReply = {
     status: number;
     body: unknown;
@@ -166,7 +197,10 @@ export interface ScenarioEditArgs {
     freeze: boolean;
     unfreeze: boolean;
     note?: string;
-    /** `undo --edit`: the `sedit_` (or `pedit_`) id to put back. `undo --step` is {@link step}. */
+    /**
+     * `undo --edit`: the `sedit_` (or `pedit_`) id to put back, or a `scor_`
+     * correction to take back whole. `undo --step` is {@link step}.
+     */
     edit?: string;
     /** `--revision`: save only if the plan is still at this `chainRevision`. */
     revision?: number;
@@ -222,6 +256,10 @@ export declare function renderReport(out: (line?: string) => void, r: EditReport
  * short — a window the service cut itself, or a small call — is printed whole.
  */
 export declare function around(text: string, at: number): string;
+/** `[11,12,13,15]` → "11–13, 15": the step lists of a correction. */
+export declare function stepRanges(steps: readonly number[] | undefined): string;
+/** The second line of a correction in `edits`: what it changed, from which run, and what became of it. */
+export declare function correctionSummary(c: CorrectionEntry): string;
 /**
  * What `undo` without `--edit` takes back (D9): the newest **edit** — never an
  * undo entry — that nothing has put back and no recalculation replaced; of
@@ -239,5 +277,11 @@ export declare function around(text: string, at: number): string;
 export declare function newestUndoable(edits: EditEntry[], step?: number): EditEntry | undefined;
 /** {@link newestUndoable} for kind changes: the newest that stands, of `param` when it is given. */
 export declare function newestUndoableParam(paramEdits: ParamEditEntry[], param?: string): ParamEditEntry | undefined;
+/**
+ * The correction `undo` without `--edit` takes back, when it is the newest
+ * change of all: one in use, not undone. A plan-wide change, so never one
+ * when `--step` or `--param` narrows the undo to a step or a parameter.
+ */
+export declare function newestUndoableCorrection(corrections: CorrectionEntry[]): CorrectionEntry | undefined;
 export {};
 //# sourceMappingURL=scenario-edit.d.ts.map