@basein/runner 0.3.14 → 0.3.16

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

@@ -1075,23 +1075,54 @@ export declare class ControlServer {
     private applyFragmentCreation;
     /**
      * Whether this matched turn's task is now the model's own, so its work is
-     * the repeat the service offered to record (the service's newestRun.md N1):
-     * offered, nothing recording, no fragment, and no plan of the prompt match
-     * that ran a step or still may. A plan that handed over is the fragment's to
-     * record (fallbk.md D7).
+     * the repeat the service offered to record: offered, nothing recording, no
+     * fragment, and the prompt match's plan done with — retired, not running,
+     * not diverging — and either:
+     *
+     *  - it ran no step: the model does the whole task (newestRun.md N1); or
+     *  - it ran to its end, and the model, told to answer from its results,
+     *    called tools of its own instead (N7). Before 0.3.15 that work was
+     *    lost: a model that did not take the plan's result as the answer and
+     *    did the task again left nothing to fix the plan from.
+     *
+     * A plan that handed over is the fragment's to record (fallbk.md D7). One
+     * that ran part of the task and stopped without a hand-over records
+     * nothing, as before: the call where it stopped ran while it was still
+     * live, so a run of what came after would lack the step that matters.
      */
     private repeatDue;
     /**
-     * Open the repeat run and record from this call on (newestRun.md N1).
+     * Whether the prompt match's plan ran to its end before the model went on
+     * by itself (newestRun.md N7). False when it ran no step, which is N1.
+     */
+    private redoneAfterPlan;
+    /**
+     * Open the repeat run and record from this call on (newestRun.md N1, N7).
      *
      * The same swap as {@link openFragment}: nothing allocated before it belongs
-     * to it. Unlike a fragment it carries the turn's prompt, and its cost and
-     * duration are the whole turn's, because no plan did any of the task. Nothing
-     * waits for the service's answer: the steps queue behind the create, and a
-     * create answered `id: null` — the service records no repeat of it — drops
-     * them.
+     * to it. Unlike a fragment it carries the turn's prompt. When no plan did
+     * any of the task, its cost and duration are the whole turn's; after a plan
+     * that ran to its end, they start here, as a fragment's do. Nothing waits
+     * for the service's answer: the steps queue behind the create, and a create
+     * 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