@basein/runner 0.3.14 → 0.3.15

package/dist/control/server.d.ts

@@ -1075,21 +1075,36 @@ 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;
     /**

package/dist/control/server.js

@@ -2292,12 +2292,15 @@ export class ControlServer {
         this.reportExecution(session, run, durationMs, cost, cutShort);
         // 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.
-        // Another host hands over one number for the whole run, and it is the
-        // fragment's: the plan's own steps made no model call, so all of it was
-        // spent after the hand-over.
+        // So is a repeat opened after the plan ran to its end (newestRun.md N7). Another host
+        // hands over one number for the whole run, and it is the fragment's: the
+        // plan's own steps made no model call, so all of it was spent after the
+        // hand-over.
         const fragment = run.fragment?.state === "open" ? run.fragment : undefined;
-        const recordedCost = fragment && !other ? this.costSince(session, fragment.usageMark) : cost;
-        const recordedMs = fragment?.startedAtMs ? Date.now() - fragment.startedAtMs : durationMs;
+        const repeatAfterPlan = !fragment && run.repeat?.state === "open" && run.repeat.startedAtMs !== undefined ? run.repeat : undefined;
+        const ownWork = fragment ?? repeatAfterPlan;
+        const recordedCost = ownWork && !other ? this.costSince(session, ownWork.usageMark) : cost;
+        const recordedMs = ownWork?.startedAtMs ? Date.now() - ownWork.startedAtMs : durationMs;
         if (run.recording) {
             const transcriptPath = session.transcriptPath;
             // The answer is the host's when it handed one over, and the
@@ -4032,10 +4035,20 @@ export class ControlServer {
     }
     /**
      * 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.
      */
     repeatDue(run) {
         const r = run.repeat;
@@ -4044,23 +4057,34 @@ export class ControlServer {
         const prompt = run.replays.find((s) => s.armedBy === "prompt");
         if (!prompt?.plan)
             return true;
-        return prompt.retired && prompt.stepsPinned === 0 && !prompt.handover;
+        if (!prompt.retired || prompt.diverging || this.runningPlans.has(prompt) || prompt.handover)
+            return false;
+        return prompt.stepsPinned === 0 || prompt.ranToEnd === true;
+    }
+    /**
+     * 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.
+     */
+    redoneAfterPlan(run) {
+        const prompt = run.replays.find((s) => s.armedBy === "prompt");
+        return prompt?.plan !== undefined && prompt.ranToEnd === true;
     }
     /**
-     * Open the repeat run and record from this call on (newestRun.md N1).
+     * 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.
      */
     openRepeat(session, run) {
         const r = run.repeat;
         if (!r || r.state !== "offered")
             return;
-        const reason = this.repeatReason(run);
+        const redone = this.redoneAfterPlan(run);
+        const reason = redone ? "redone" : this.repeatReason(run);
         const repeatOf = reason ? { runId: r.runId, reason } : { runId: r.runId };
         // The repeat is a run of the same host as the turn it records.
         const framework = frameworkOf(session);
@@ -4075,11 +4099,19 @@ export class ControlServer {
         run.ordering = new StepIndexAllocator();
         run.recording = true;
         r.state = "open";
+        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.
+            r.usageMark = markTranscriptUsage(session.transcriptPath);
+            r.startedAtMs = Date.now();
+        }
         logLine("run.repeat", {
             run: id,
             of: r.runId,
             reason,
-            why: "the agent is doing a recorded task itself — recorded as that recording's newest run",
+            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",
         });
         if (!isRunCreationAware(this.recorder))
             return;

package/dist/record/recorder.d.ts

@@ -13,9 +13,12 @@ export interface StartRunOptions {
     };
     /**
      * Marks a *repeat* (the service's newestRun.md): a matched turn whose plan
-     * did not run, so the model is doing the recording's task itself. Sent only
-     * when the match offered it ({@link RunMatch.repeat}). `reason` is why the
-     * plan did not run. The service never prompt-matches a repeat.
+     * did not run, so the model is doing the recording's task itself — or whose
+     * plan ran to its end, after which the model went on with calls of its own
+     * instead of answering from its results (N7). Sent only when the match
+     * offered it ({@link RunMatch.repeat}). `reason` is why the plan did not
+     * run, or `redone` after a plan that ran to its end. The service never
+     * prompt-matches a repeat.
      */
     repeatOf?: {
         runId: string;

package/dist/replay/controller.d.ts

@@ -435,6 +435,24 @@ export interface ReplayState {
     sharedWith: string[];
     /** Set when the plan handed the task to the model part-way (fallbk.md). */
     handover?: Handover;
+    /**
+     * Every planned step ran and the model was handed the results to answer
+     * from: a steered plan whose last step threaded, a direct run that ran to
+     * its end, or a divergence whose bundle carried the rest of the chain. A
+     * call the model makes of its own after this is the task done again — it
+     * did not take the plan's result as the answer (the service's newestRun.md
+     * N7). Never set on a plan that handed over: the hand-over says the rest
+     * is the model's.
+     */
+    ranToEnd?: boolean;
+    /**
+     * A divergence is running the plan's remaining steps for real (§8). The
+     * plan is already retired by then, so this is what tells a call made beside
+     * that work from one made after it: a repeat never opens while steps are
+     * still landing, and whether the plan ran to its end or handed over is not
+     * known yet (the service's newestRun.md N7).
+     */
+    diverging?: boolean;
     /**
      * Which gate declined, as a fixed code (segmented.md R-HIT-14). The prose
      * `why` that `decline()` logs stays free text; this is what code reads — the

package/dist/replay/controller.js

@@ -1375,6 +1375,7 @@ export class ReplayController {
         }
         if (done) {
             this.upgrade(state, "steered_full");
+            state.ranToEnd = true;
             // A completing retire: the last step threaded and the plan's work is over
             // (segmented.md R-MONEY-3). Everything the agent spends after this is the
             // agent's own, not this plan's.
@@ -1687,6 +1688,7 @@ export class ReplayController {
         // `runToCompletion` returned without a stop: the plan ran to its end, so
         // this is a completing retire (R-MONEY-3). The stopped path handed over
         // above and took no mark.
+        state.ranToEnd = true;
         this.retire(state, undefined, true);
         logLine("replay.done", {
             scenario: state.scenarioId ?? undefined,
@@ -2075,6 +2077,9 @@ export class ReplayController {
             step: `${plan.currentStepIndex}/${plan.stepCount}`,
             why,
         });
+        // Retired, and still working: until the bundle is composed, a call the
+        // model makes beside this one is beside the plan, not after it.
+        state.diverging = true;
         this.retire(state, undefined);
         // The bundle, and the note in front of it, must fit the channel it goes
         // out on whole: the host cuts a long Bash output in the middle.
@@ -2099,6 +2104,11 @@ export class ReplayController {
             });
             return { kind: "abort" };
         }
+        finally {
+            // Nothing below waits: what this divergence ends in — a hand-over, or
+            // a bundle that ran to the end — is settled before any other hook runs.
+            state.diverging = false;
+        }
         const stop = composed.stopped;
         // Same rule as `runArmed`: a recovered chain whose tools errored is
         // `failed`, and so is one that stopped at a step that broke — its logic
@@ -2175,6 +2185,11 @@ export class ReplayController {
             };
             text = `${state.handover.note}\n\n${composed.text}`;
         }
+        else if (!stop) {
+            // The bundle carries the rest of the chain, and its header tells the
+            // model the work is done: from here the model answers from it.
+            state.ranToEnd = true;
+        }
         // Bash-clean delivery: the model reaches for `Bash` when it cannot call a
         // scripted tool, and a genuine command output is trusted where a `deny`
         // reason is read as adversarial interception.

package/package.json

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