@basein/runner 0.3.15 → 0.3.17

package/dist/bin/scenario-edit.js

@@ -66,7 +66,7 @@ const USAGE = {
         '                          [--freeze | --unfreeze] [--note "why"] [--force --note "why"] [--revision <n>] [--json]\n' +
         '       bir scenario edit <runId|scnId> --param <name> --kind target|setting [--note "why"] [--revision <n>] [--json]',
     edits: "usage: bir scenario edits <runId|scnId> [--json]",
-    undo: 'usage: bir scenario undo <runId|scnId> [--edit <sedit_id|pedit_id> | --step <n> | --param <name>] [--force --note "why"] [--json]',
+    undo: 'usage: bir scenario undo <runId|scnId> [--edit <sedit_id|pedit_id|scor_id> | --step <n> | --param <name>] [--force --note "why"] [--json]',
     calc: "usage: bir scenario calc <runId|scnId> [--force [--discard-edits]]",
     editing: "usage: bir scenario editing on|off|status",
 };
@@ -594,13 +594,19 @@ function refusal(out, report, opening, hint) {
     }
     out(hint);
 }
-// ── edits / undo ──────────────────────────────────────────────────────────────
-/** The service's history: step edits, and — from a service that has them — kind changes. */
+/**
+ * The service's history: step edits, and — from a service that has them —
+ * kind changes and corrections (autocorrect.md AC7). An older service sends
+ * neither list, and there is nothing of them to print.
+ */
 function historyOf(body) {
     const b = body;
     return {
         edits: Array.isArray(b?.edits) ? b.edits : [],
         paramEdits: Array.isArray(b?.paramEdits) ? b.paramEdits : [],
+        corrections: Array.isArray(b?.corrections)
+            ? b.corrections.filter((c) => typeof c?.id === "string" && typeof c?.createdAt === "string")
+            : [],
     };
 }
 async function fetchEdits(scenarioId, deps) {
@@ -628,15 +634,16 @@ async function listEdits(args, deps) {
         out(jsonText(reply.body));
         return 0;
     }
-    const { edits, paramEdits } = historyOf(reply.body);
-    if (edits.length === 0 && paramEdits.length === 0) {
+    const { edits, paramEdits, corrections } = historyOf(reply.body);
+    if (edits.length === 0 && paramEdits.length === 0 && corrections.length === 0) {
         out(`No hand edits of ${target}.`);
         return 0;
     }
     // Ids are printed whole: they are what `undo --edit` takes. The detail line
     // is indented rather than aligned under the date, which a 42-character id
     // would push past most terminals' width. One list, newest first: a step's
-    // edits and a parameter's kind changes are walked back by the same `undo`.
+    // edits, a parameter's kind changes and the service's corrections of the
+    // plan are walked back by the same `undo`.
     const noteOf = (note) => (note ? `  "${note.replace(/\s+/g, " ")}"` : "");
     const rows = [
         ...edits.map((e) => ({
@@ -649,6 +656,11 @@ async function listEdits(args, deps) {
             line: `${p.id}  ${when(p.createdAt)}  param ${p.param}  ${String(p.kind).padEnd(7)} revision ${p.chainRevisionBefore} → ${p.chainRevisionAfter}${noteOf(p.note)}`,
             detail: paramSummary(p),
         })),
+        ...corrections.map((c) => ({
+            at: c.createdAt,
+            line: `${c.id}  ${when(c.createdAt)}  correction  ${String(c.state).padEnd(8)} revision ${c.chainRevisionBefore ?? "?"} → ${c.chainRevisionAfter ?? "—"}`,
+            detail: correctionSummary(c),
+        })),
     ].sort((x, y) => (x.at < y.at ? 1 : x.at > y.at ? -1 : 0));
     for (const r of rows) {
         out(r.line);
@@ -656,6 +668,62 @@ async function listEdits(args, deps) {
     }
     return 0;
 }
+/** `[11,12,13,15]` → "11–13, 15": the step lists of a correction. */
+export function stepRanges(steps) {
+    const sorted = [...new Set((steps ?? []).filter((n) => Number.isInteger(n)))].sort((a, b) => a - b);
+    const parts = [];
+    for (let i = 0; i < sorted.length;) {
+        let j = i;
+        while (j + 1 < sorted.length && sorted[j + 1] === sorted[j] + 1)
+            j += 1;
+        parts.push(j === i ? String(sorted[i]) : `${sorted[i]}–${sorted[j]}`);
+        i = j + 1;
+    }
+    return parts.join(", ");
+}
+/** The second line of a correction in `edits`: what it changed, from which run, and what became of it. */
+export function correctionSummary(c) {
+    const parts = [];
+    if (c.summary)
+        parts.push(c.summary.replace(/\s+/g, " ").trim());
+    const changes = [];
+    const count = (steps) => steps?.length ?? 0;
+    if (count(c.added))
+        changes.push(`${count(c.added)} step${count(c.added) === 1 ? "" : "s"} added (${stepRanges(c.added)})`);
+    if (count(c.tested))
+        changes.push(`tests on step${count(c.tested) === 1 ? "" : "s"} ${stepRanges(c.tested)}`);
+    if (count(c.changed))
+        changes.push(`step${count(c.changed) === 1 ? "" : "s"} ${stepRanges(c.changed)} changed`);
+    if (c.answerChanged)
+        changes.push("the answer changed");
+    if (changes.length > 0)
+        parts.push(changes.join(", "));
+    if (c.redoneRunId)
+        parts.push(`from the redo ${c.redoneRunId}${c.verdictKind ? ` (${c.verdictKind})` : ""}`);
+    switch (c.state) {
+        case "proposed":
+            parts.push('shown, not used yet — "Use the correction" on the recording page uses it');
+            break;
+        case "used":
+            parts.push(`used${c.usedAt ? ` ${when(c.usedAt)}` : ""}`);
+            break;
+        case "failed": {
+            const first = c.problems?.[0];
+            parts.push(`not used: its check failed${first ? ` — ${first}` : ""}`);
+            break;
+        }
+        case "undone":
+            parts.push(`undone${c.undoneAt ? ` ${when(c.undoneAt)}` : ""}`);
+            break;
+        case "replaced":
+            parts.push("replaced by a recalculation");
+            break;
+        default:
+            if (c.state)
+                parts.push(String(c.state));
+    }
+    return parts.join("; ");
+}
 /** The second line of a kind change in `edits`: the kinds, and what became of it. */
 function paramSummary(p) {
     const parts = [];
@@ -722,14 +790,29 @@ export function newestUndoableParam(paramEdits, param) {
         .sort((x, y) => (x.createdAt < y.createdAt ? 1 : x.createdAt > y.createdAt ? -1 : 0))
         .find((e) => e.kind !== "revert" && !e.revertedAt && !e.replacedAt && (param === undefined || e.param === param));
 }
+/**
+ * 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 function newestUndoableCorrection(corrections) {
+    return [...corrections]
+        .filter((c) => c.state === "used" && !c.undoneAt)
+        .sort((x, y) => {
+        const a = x.usedAt ?? x.createdAt;
+        const b = y.usedAt ?? y.createdAt;
+        return a < b ? 1 : a > b ? -1 : 0;
+    })[0];
+}
 const isParamEditId = (id) => id.startsWith("pedit_");
+const isCorrectionId = (id) => id.startsWith("scor_");
 async function undo(args, deps) {
     const { out } = deps;
     const target = args.positionals[1];
     if (!target)
         return usageError(deps, "undo");
-    if (args.edit !== undefined && !/^(sedit|pedit)_[\w-]+$/.test(args.edit)) {
-        return usageError(deps, "undo", `--edit takes a sedit_… or pedit_… id, as \`bir scenario edits\` prints it; got ${args.edit}.`);
+    if (args.edit !== undefined && !/^(sedit|pedit|scor)_[\w-]+$/.test(args.edit)) {
+        return usageError(deps, "undo", `--edit takes a sedit_…, pedit_… or scor_… id, as \`bir scenario edits\` prints it; got ${args.edit}.`);
     }
     const picks = [args.edit, args.step, args.param].filter((v) => v !== undefined).length;
     if (picks > 1) {
@@ -754,11 +837,18 @@ async function undo(args, deps) {
         const listed = await fetchEdits(resolved.id, deps);
         if ("reply" in listed)
             return explain(listed.reply, args, deps, { verb: "Could not read the history", target });
-        // Undo walks back across both lists (D9): the newest change of either
-        // kind goes first, unless --step or --param narrows it to one.
+        // Undo walks back across every list (D9): the newest change of any kind
+        // goes first — a correction in use too, which is a change of the whole
+        // plan (autocorrect.md AC7) — unless --step or --param narrows it to one.
         const stepPick = args.param === undefined ? newestUndoable(listed.edits, args.step) : undefined;
         const paramPick = args.step === undefined ? newestUndoableParam(listed.paramEdits, args.param) : undefined;
-        const pick = !stepPick ? paramPick : !paramPick ? stepPick : paramPick.createdAt > stepPick.createdAt ? paramPick : stepPick;
+        const correctionPick = args.step === undefined && args.param === undefined ? newestUndoableCorrection(listed.corrections) : undefined;
+        const candidates = [
+            ...(stepPick ? [{ id: stepPick.id, at: stepPick.createdAt }] : []),
+            ...(paramPick ? [{ id: paramPick.id, at: paramPick.createdAt }] : []),
+            ...(correctionPick ? [{ id: correctionPick.id, at: correctionPick.usedAt ?? correctionPick.createdAt }] : []),
+        ];
+        const pick = candidates.sort((x, y) => (x.at < y.at ? 1 : x.at > y.at ? -1 : 0))[0];
         if (!pick) {
             return localFailure(args, deps, "nothing_to_undo", args.step !== undefined
                 ? `Nothing to undo: step ${args.step} of ${target} has no hand edit that can be undone.`
@@ -793,6 +883,8 @@ async function undo(args, deps) {
     }
     if (isParamEditId(editId))
         return paramUndone(reply.body, editId, target, args, deps);
+    if (isCorrectionId(editId))
+        return correctionUndone(reply.body, editId, target, deps);
     if (answer?.report)
         renderReport(out, answer.report, { brief: true, undo: true });
     if (refused && answer?.report) {
@@ -820,6 +912,20 @@ async function undo(args, deps) {
     }
     return 0;
 }
+/**
+ * A correction taken back: the plan is as it was before it, exactly — and
+ * held, because that plan was the one the agent rejected. Said so, with the
+ * way to let it go.
+ */
+function correctionUndone(answer, editId, target, deps) {
+    const revision = answer?.chainRevision ?? answer?.correction?.chainRevisionAfter;
+    deps.out(`The plan is back as it was before correction ${answer?.correction?.id ?? editId} (revision ${revision ?? "?"}).`);
+    if (answer?.held) {
+        deps.out(`  It is held${answer.held.reason ? ` (${answer.held.reason})` : ""}: the plan from before is the one the agent rejected, so it is not used — the agent does the task — until it is corrected again or someone presses "Use it again" on the recording page.`);
+    }
+    deps.out(`  One further back: bir scenario undo ${target}`);
+    return 0;
+}
 /**
  * A kind change undone. Nothing ran, so there is no report: the parameter's
  * kind as it is now, what that means for the next prompt, and the way on —
@@ -884,8 +990,14 @@ async function calc(args, deps) {
     if (status === 409 && code === "scenario_has_edits") {
         const steps = body.editedSteps;
         const list = Array.isArray(steps) ? steps.map(String) : [];
+        // A correction the service made from a redo is protected the same way
+        // (autocorrect.md AC6): a recalculation from the recording would bring
+        // back the one-half plan it fixed.
+        const correction = body.correctionId;
         const which = list.length === 0 ? "some steps were" : list.length === 1 ? `step ${list[0]} was` : `steps ${list.join(", ")} were`;
-        out(`Not recalculated: ${which} edited by hand, and a recalculation rebuilds every step.`);
+        out(typeof correction === "string"
+            ? `Not recalculated: the plan carries correction ${correction}, and a recalculation from the recording would throw it away.`
+            : `Not recalculated: ${which} edited by hand, and a recalculation rebuilds every step.`);
         out(`  To recalculate anyway and discard the edits: bir scenario calc ${target} --force --discard-edits`);
         out("  (the edits stay in `bir scenario edits`, marked replaced)");
         return 1;
@@ -1057,6 +1169,8 @@ function explain(reply, args, deps, e) {
     const stepFlag = e.step !== undefined ? ` --step ${e.step}` : "";
     // A kind change (findoffer.md) is about a parameter, and nothing in it is checked.
     const aboutParam = e.param !== undefined || (e.editId?.startsWith("pedit_") ?? false);
+    // A correction (autocorrect.md AC7) is about the whole plan.
+    const aboutCorrection = e.editId?.startsWith("scor_") ?? false;
     if (reply.status === 404) {
         out(e.notFound ??
             `${e.verb} (not_found): no such scenario, step or edit — or it is not yours. Only a scenario's owner can see or change it.`);
@@ -1110,13 +1224,19 @@ 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>";
-            out(`${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:`);
+            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:`);
             out(`  bir scenario undo ${target} --edit ${latest}`);
             out(`  bir scenario undo ${target} --edit ${e.editId ?? "<this edit>"}`);
             return 1;
         }
         case "already_undone": {
             const by = typeof body.revertedById === "string" ? body.revertedById : undefined;
+            if (aboutCorrection) {
+                out(`${e.verb} (already_undone): ${e.editId ?? "that correction"} was taken back already; \`bir scenario edits ${target}\` lists what the plan has now.`);
+                return 1;
+            }
             out(`${e.verb} (already_undone): ${e.editId ?? "that edit"} was undone already${by ? `, by ${by}` : ""}. To redo it, undo that undo:`);
             out(`  bir scenario undo ${target} --edit ${by ?? "<the undo's sedit_ id, from bir scenario edits>"}`);
             return 1;
@@ -1124,7 +1244,7 @@ function explain(reply, args, deps, e) {
         case "edit_replaced":
             out(aboutParam
                 ? `${e.verb} (edit_replaced): a recalculation dropped that parameter after the change. It stays in \`bir scenario edits\`, but there is nothing left to undo.`
-                : `${e.verb} (edit_replaced): a recalculation replaced the plan after that edit. It stays in \`bir scenario edits\`, but there is nothing left to undo.`);
+                : `${e.verb} (edit_replaced): a recalculation replaced the plan after that ${aboutCorrection ? "correction" : "edit"}. It stays in \`bir scenario edits\`, but there is nothing left to undo.`);
             return 1;
         case "rate_limited": {
             const ms = typeof body.retryAfterMs === "number" ? body.retryAfterMs : undefined;

package/dist/control/server.d.ts

@@ -1107,6 +1107,22 @@ export declare class ControlServer {
      * answered `id: null` — the service records no repeat of it — drops them.
      */
     private openRepeat;
+    /**
+     * Record the prompt plan's own calls of this turn into the `redone` repeat
+     * `id`, in the order they went out, before the agent's first call of its
+     * own (the service's autocorrect.md AC2). Each is a pair, both rows marked
+     * `byPlan` with the plan, its step and its chain revision, so the service
+     * stores them without a vector and counts none of them as the agent's.
+     * Payloads are whole — redacted and capped as any recorded call's — where
+     * the report has only 3,800 bytes of each. Returns how many it recorded.
+     */
+    private recordPlanCalls;
+    /**
+     * One tool call of the model's own was recorded into `run`: counted for
+     * the plan's report when it is the `redone` repeat (AC1). A step a plan
+     * pinned is the plan's doing, not the model's, and is not counted.
+     */
+    private noteOwnCall;
     /**
      * Why the matched turn's plan did not run, as the service shows it: what
      * the service withheld it for, else the code of the gate that declined it

package/dist/control/server.js

@@ -31,7 +31,7 @@ import { BIR_CALL_ID, fingerprint, newCallId, parseQualifiedName, qualifyToolNam
 import { StepIndexAllocator } from "./ordering.js";
 import { pidAlive } from "./discovery.js";
 import { pinCompatible } from "./pin-guard.js";
-import { contextForToolUse, intentForToolUse, markTranscriptUsage, recentToolResults, settledLastAssistantText, thinkingForToolUse, usageSince, } from "./transcript.js";
+import { contextForToolUse, intentForToolUse, markTranscriptUsage, recentToolResults, settledLastAssistantText, settledTextAfterToolUse, thinkingForToolUse, usageSince, } from "./transcript.js";
 import { isHousekeepingCall } from "../record/housekeeping.js";
 import { asSent, userText } from "../record/prompt-text.js";
 import { redact, redactText } from "../record/redact.js";
@@ -1811,6 +1811,11 @@ export class ControlServer {
         // the jail it may not leave (replay/builtins.ts). The session's own cwd
         // from the hook payloads, never the daemon's.
         state.sessionCwd = session.cwd ?? this.opts.cwd;
+        // The service offered to record this turn as the recording's newest run:
+        // should the agent redo the task after the plan, the plan's own calls go
+        // into that run first, so they are kept whole as they run (AC2).
+        if (match.repeat?.runId)
+            state.keepCalls = true;
         this.declineWithoutDeliveryTool(state);
         // A steer plan with a shell or file-write step can only be followed if the
         // directive shows its computed arguments (the pin guard holds those steps
@@ -2289,7 +2294,14 @@ export class ControlServer {
         // A matched turn records nothing, but it still owes the ledger a number —
         // including when it declined to steer, which is a *baseline* sample and is
         // what every saving is measured against (docs/calculatedReplay.md §11).
-        this.reportExecution(session, run, durationMs, cost, cutShort);
+        this.reportExecution(session, run, durationMs, cost, cutShort, reason);
+        // The plan's calls kept for a redo went into the repeat when it opened
+        // (AC2); nothing reads them after the turn, and they can run to megabytes
+        // on a sealed run the session keeps as its previous one.
+        for (const s of run.replays.length > 0 ? run.replays : run.replay ? [run.replay] : []) {
+            s.turnCalls = undefined;
+            s.turnCallChars = 0;
+        }
         // A fragment is recorded from the hand-over on (fallbk.md D7), so its cost
         // and duration are the model's own work, not the steps the scenario did.
         // So is a repeat opened after the plan ran to its end (newestRun.md N7). Another host
@@ -2323,8 +2335,10 @@ export class ControlServer {
             // Resolve the answer *outside* the queue: the wait below is up to two
             // seconds, and the queue is serial — blocking it here would delay the
             // first step of the user's next turn by that much. Kept on the run, so a
-            // drain of this run waits for this seal and for nobody else's.
-            run.sealing = answerText
+            // drain of this run waits for this seal and for nobody else's — beside a
+            // plan's report that waits for the answer too (AC11), never in its place.
+            const before = run.sealing;
+            const finishing = answerText
                 .then((answer) => {
                 run.finishQueued = true;
                 this.queue.push(() => {
@@ -2347,6 +2361,7 @@ export class ControlServer {
                     });
                 });
             });
+            run.sealing = before ? Promise.all([before, finishing]).then(() => undefined) : finishing;
         }
         logLine("run.finish", {
             run: run.runId,
@@ -2439,7 +2454,9 @@ export class ControlServer {
     }
     reportExecution(session, run, durationMs, cost, 
     /** The run was closed before its task ended for the caller (another host only). */
-    cutShort = false) {
+    cutShort = false, 
+    /** Why the turn was sealed: only an ordinary `stop` ends with an answer (AC11). */
+    sealedBy = "stop") {
         if (!isScenarioReporter(this.recorder))
             return;
         const states = run.replays.length > 0 ? run.replays : run.replay ? [run.replay] : [];
@@ -2447,6 +2464,14 @@ export class ControlServer {
         // Another host hands over one number for the whole run. It cannot be
         // split between two plans, so with more than one neither is measured.
         const unsplit = otherHost(session) && states.length > 1;
+        // The plan ran to its end and the agent redid the task in a repeat the
+        // service took (newestRun.md N7): the prompt plan's report says so, with
+        // the repeat's id and the agent's own calls in it (autocorrect.md AC1).
+        const r = run.repeat;
+        const redoneBy = r?.state === "open" && r.reason === "redone" && r.openedRunId
+            ? { runId: r.openedRunId, ownCalls: r.ownCalls ?? 0 }
+            : undefined;
+        const prompt = states.find((s) => s.armedBy === "prompt");
         // One report per plan armed this turn (fallbk.md §Runner 4). Each is billed
         // for its own window of the transcript — from when it armed to when the next
         // one did — so the turn's tokens are split between them, never counted twice.
@@ -2484,6 +2509,7 @@ export class ControlServer {
                 siblings: states,
                 runId: run.runId,
                 cutShort: cutShort || undefined,
+                redoneBy: state === prompt && state.ranToEnd === true ? redoneBy : undefined,
             });
             if (!report)
                 return;
@@ -2494,6 +2520,30 @@ export class ControlServer {
                     billedTo: state.retiredMark !== undefined ? "its own retire" : "the next arm or the turn",
                 });
             }
+            // The plan ran to its end, and no redo of the model's own was recorded:
+            // the model only answered. Its answer goes with the report, so that the
+            // service can tell whether it took the plan's result (the service's
+            // autocorrect.md AC11). Read off the queue, as a recording's answer is —
+            // the wait is up to two seconds, and the queue is serial — and kept on
+            // the run, so a drain of this run waits for it. Only after an ordinary
+            // stop, and only the text written after the turn's last call: a turn cut
+            // short has no answer, and an older text is none. Claude Code only: the
+            // service corrects no other host's plan.
+            if (state === prompt &&
+                state.ranToEnd === true &&
+                !redoneBy &&
+                report.outcome === "steered_full" &&
+                sealedBy === "stop" &&
+                run.lastToolUseId !== undefined &&
+                !otherHost(session)) {
+                const sent = settledTextAfterToolUse(session.transcriptPath, run.lastToolUseId)
+                    .catch(() => "")
+                    .then((answer) => {
+                    this.queue.push(() => recorder.reportExecution(answer ? { ...report, answer } : report));
+                });
+                run.sealing = run.sealing ? Promise.all([run.sealing, sent]).then(() => undefined) : sent;
+                return;
+            }
             this.queue.push(() => recorder.reportExecution(report));
         });
         // The prompt match that landed too late (see `noteLateMatch`). Not when a
@@ -2894,6 +2944,7 @@ export class ControlServer {
                 if (!steering.retired) {
                     steering.pinned.clear();
                     steering.retired = true;
+                    steering.skipNote = undefined;
                     logLine("replay.pin_overran", {
                         scenario: steering.scenarioId ?? undefined,
                         tool: toolName,
@@ -2915,9 +2966,25 @@ export class ControlServer {
                     if (verdict.ok) {
                         pinned = action.input;
                         this.declinedPins.delete(steering);
+                        this.replay.pinTaken(steering);
                     }
                     else {
                         steering.pinned.delete(toolUseId);
+                        // Not the next step — and perhaps the step a test just left out,
+                        // which shares its tool, made because the note saying so had not
+                        // reached the model yet (AC5). The note goes in its place: a step
+                        // left out never runs because the note was late. The plan stays
+                        // armed for the step that is next.
+                        const skipped = this.replay.skipNoteFor(steering, toolName);
+                        if (skipped) {
+                            logLine("replay.pin_declined", {
+                                scenario: steering.scenarioId ?? undefined,
+                                tool: toolName,
+                                step: action.stepIndex,
+                                why: "a call to the step a test left out — the note saying so is given in its place",
+                            });
+                            return this.preToolAnswer(this.replay.deliverInstead(skipped, toolName));
+                        }
                         this.declinedPins.add(steering);
                         logLine("replay.pin_declined", {
                             scenario: steering.scenarioId ?? undefined,
@@ -2938,6 +3005,13 @@ export class ControlServer {
         // a plan nobody would ever hear of.
         if (!overran && !pinned && (!run.replay?.plan || run.replay.retired)) {
             // ── falling back to the model (fallbk.md) ──────────────────────────────
+            // 0. A call to a step a test left out (AC5), when the note saying so has
+            //    not reached the model yet — the plan may have finished on it. The
+            //    note goes in its place: a step left out must never run because the
+            //    note was late.
+            const skipped = planning ? undefined : this.replay.skipNoteFor(run.replay, toolName);
+            if (skipped)
+                return this.preToolAnswer(this.replay.deliverInstead(skipped, toolName));
             // 1. A hand-over noticed where no hook answer could carry it — a proxy
             //    report threaded after its PostToolUse had already answered — reaches
             //    the model in place of this call. Never silence (D4).
@@ -3071,6 +3145,7 @@ export class ControlServer {
             ? (run.replay?.scenarioId ?? undefined)
             : undefined;
         if (run.recording) {
+            this.noteOwnCall(run, pinnedBy);
             this.queue.push(() => {
                 this.recorder.recordToolSelected(run.runId, pair.selected, {
                     toolName,
@@ -3302,6 +3377,7 @@ export class ControlServer {
             toolName,
         });
         if (run.recording) {
+            this.noteOwnCall(run);
             const toolInput = serializeCapped(redact(modelArgs));
             this.queue.push(() => {
                 this.recorder.recordToolSelected(run.runId, pair.selected, {
@@ -3360,6 +3436,7 @@ export class ControlServer {
         state.retired = true;
         state.retiredAt = Date.now();
         state.pinned.clear();
+        state.skipNote = undefined;
         this.directCalls = this.directCalls.filter((c) => c.state !== state);
         logLine("replay.vetoed", {
             run: run.runId,
@@ -3390,6 +3467,8 @@ export class ControlServer {
         state.retired = true;
         state.retiredAt = Date.now();
         state.pinned.clear();
+        // A note naming a step to call next is void with the plan (AC5 review).
+        state.skipNote = undefined;
         run.handback = HANDBACK_NOTE;
         logLine("replay.pin_abandoned", {
             run: run.runId,
@@ -4099,6 +4178,13 @@ export class ControlServer {
         run.ordering = new StepIndexAllocator();
         run.recording = true;
         r.state = "open";
+        r.openedRunId = id;
+        r.reason = reason;
+        r.ownCalls = 0;
+        // The plan's own calls of this turn go in first, whole and marked, so the
+        // newest run holds the whole turn: the agent's work is built on what the
+        // plan's calls returned (the service's autocorrect.md AC2).
+        const planCalls = redone ? this.recordPlanCalls(run, id) : 0;
         if (redone) {
             // The plan's steps are not the model's work: this run is billed and
             // timed from its own first call on, as a fragment is.
@@ -4109,6 +4195,7 @@ export class ControlServer {
             run: id,
             of: r.runId,
             reason,
+            planCalls: planCalls || undefined,
             why: redone
                 ? "the plan ran to its end, and the agent went on with calls of its own instead of answering from its results — recorded as that recording's newest run"
                 : "the agent is doing a recorded task itself — recorded as that recording's newest run",
@@ -4119,10 +4206,15 @@ export class ControlServer {
             .runCreated(id)
             .catch(() => ({ created: true }))
             .then((created) => {
-            if (created.created || run.runId !== id)
+            if (created.created)
                 return;
-            run.recording = false;
+            // Refused: never named as the turn's redo (the service's
+            // autocorrect.md AC1) — also when the turn has moved on to another
+            // run since, which used to leave the repeat `open` and named.
             r.state = "refused";
+            if (run.runId !== id)
+                return;
+            run.recording = false;
             logLine("run.repeat_refused", {
                 run: id,
                 of: r.runId,
@@ -4130,6 +4222,54 @@ export class ControlServer {
             });
         });
     }
+    /**
+     * Record the prompt plan's own calls of this turn into the `redone` repeat
+     * `id`, in the order they went out, before the agent's first call of its
+     * own (the service's autocorrect.md AC2). Each is a pair, both rows marked
+     * `byPlan` with the plan, its step and its chain revision, so the service
+     * stores them without a vector and counts none of them as the agent's.
+     * Payloads are whole — redacted and capped as any recorded call's — where
+     * the report has only 3,800 bytes of each. Returns how many it recorded.
+     */
+    recordPlanCalls(run, id) {
+        const prompt = run.replays.find((s) => s.armedBy === "prompt");
+        const calls = this.replay.turnCallsOf(prompt);
+        for (const call of calls) {
+            const pair = run.ordering.allocatePair();
+            const byPlan = {
+                scenarioId: call.scenarioId,
+                stepIndex: call.stepIndex,
+                // Left out, never null, when the plan was served without one: the
+                // service's row schema takes a number or nothing.
+                ...(call.chainRevision !== null ? { chainRevision: call.chainRevision } : {}),
+            };
+            this.queue.push(() => {
+                this.recorder.recordToolSelected(id, pair.selected, {
+                    toolName: call.toolName,
+                    toolInput: call.input,
+                    metadata: { byPlan },
+                });
+                this.recorder.recordToolResponse(id, pair.response, {
+                    toolName: call.toolName,
+                    toolOutput: call.error === undefined ? call.output : undefined,
+                    toolError: call.error,
+                    metadata: { byPlan },
+                });
+            });
+        }
+        return calls.length;
+    }
+    /**
+     * One tool call of the model's own was recorded into `run`: counted for
+     * the plan's report when it is the `redone` repeat (AC1). A step a plan
+     * pinned is the plan's doing, not the model's, and is not counted.
+     */
+    noteOwnCall(run, pinnedBy) {
+        const r = run.repeat;
+        if (pinnedBy || !r || r.state !== "open" || run.runId !== r.openedRunId)
+            return;
+        r.ownCalls = (r.ownCalls ?? 0) + 1;
+    }
     /**
      * Why the matched turn's plan did not run, as the service shows it: what
      * the service withheld it for, else the code of the gate that declined it
@@ -4171,10 +4311,18 @@ export class ControlServer {
             context.push(stashed);
         const run = this.sessions.get(payload.session_id ?? "unknown-session")?.run;
         if (run && !run.finished) {
+            // The answer, if one comes, is written after this call (AC11).
+            if (typeof payload.tool_use_id === "string" && payload.tool_use_id)
+                run.lastToolUseId = payload.tool_use_id;
             this.noteHandover(run);
             const note = this.replay.takeNote(run.replay);
             if (note)
                 context.push(note);
+            // The steps a test just left out (AC5): said before the model makes its
+            // next call, which must not be one of them.
+            const skipped = this.replay.takeSkipNote(run.replay);
+            if (skipped)
+                context.push(skipped);
             if (run.handback) {
                 context.push(run.handback);
                 run.handback = undefined;
@@ -5150,6 +5298,7 @@ export class ControlServer {
     record(run, pair, d) {
         if (!run.recording)
             return;
+        this.noteOwnCall(run, d.pinnedBy);
         const toolInput = serializeCapped(redact(d.args));
         const toolOutput = d.isError ? undefined : serializeCapped(redact(d.result));
         const toolError = d.isError

package/dist/control/transcript.d.ts

@@ -34,6 +34,24 @@
  * birth time, mtime, and the bytes at its head and at the offset) and read
  * again from the start, which is exactly what the old code did every time.
  */
+/**
+ * The model's text after the message that made the tool call `toolUseId`: its
+ * answer, once that call's result came back (the service's autocorrect.md
+ * AC11). Empty while none has been written, and when the call is not in the
+ * transcript — never an older text, which `lastAssistantText` can be: the
+ * sentence before a call, or the turn before's answer.
+ */
+export declare function textAfterToolUse(transcriptPath: string | undefined, toolUseId: string | undefined): string;
+/**
+ * {@link textAfterToolUse}, waited for: up to `timeoutMs` for a text to appear,
+ * then until it stops changing for `confirmMs`. Empty when none came in time —
+ * a plan's report then goes without an answer, rather than with a wrong one.
+ */
+export declare function settledTextAfterToolUse(transcriptPath: string | undefined, toolUseId: string | undefined, opts?: {
+    timeoutMs?: number;
+    confirmMs?: number;
+    pollMs?: number;
+}): Promise<string>;
 /** Forget every cached index (tests; a caller that knows files were replaced). */
 export declare function forgetTranscripts(): void;
 /**