@basein/runner 0.3.13 → 0.3.14

package/dist/control/server.d.ts

@@ -1073,6 +1073,31 @@ export declare class ControlServer {
     private openFragment;
     /** What the fragment's create call said: `created: false` is a hit, not a recording. */
     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).
+     */
+    private repeatDue;
+    /**
+     * Open the repeat run and record from this call on (newestRun.md N1).
+     *
+     * 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.
+     */
+    private openRepeat;
+    /**
+     * 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
+     * here, a plan that was late included.
+     */
+    private repeatReason;
     /** Resolve with `p`, or null once `ms` passes or it rejects. */
     private withinBudget;
     /**

package/dist/control/server.js

@@ -697,6 +697,9 @@ export class ControlServer {
                 }
                 : null,
             fragment: s.run?.fragment ? { state: s.run.fragment.state } : null,
+            // The service's offer to record the turn as a recording's newest run,
+            // and what became of it (newestRun.md).
+            repeat: s.run?.repeat ? { state: s.run.repeat.state, of: s.run.repeat.runId } : null,
         }));
         const sending = this.recorderBacklog();
         return {
@@ -1673,6 +1676,12 @@ export class ControlServer {
             if (!match || run.runId !== runId)
                 return;
             run.recording = false;
+            // The service's offer to record the turn after all, should the model end
+            // up doing the task itself (newestRun.md N5). Taken up at the model's
+            // first call of its own, once no plan of this match runs (`repeatDue`).
+            if (match.repeat?.runId && !run.repeat) {
+                run.repeat = { runId: match.repeat.runId, withheld: match.withheld ?? undefined, state: "offered" };
+            }
             logLine("run.matched", {
                 run: runId,
                 matchedRun: match.runId,
@@ -2934,6 +2943,12 @@ export class ControlServer {
                 this.noteHandover(run);
                 return this.preToolAnswer(this.replay.deliverInstead(note, toolName));
             }
+            // The model is doing the matched task itself, and the service asked for
+            // that run to be recorded as the recording's newest (newestRun.md N1).
+            // Opened before the probe below, so the turn is recorded from this call
+            // on like any recording turn — a plan an intent match arms in it too.
+            if (this.repeatDue(run))
+                this.openRepeat(session, run);
             // 2. The model is driving: look for a scenario by this iteration's intent.
             //    Never in plan mode, where nothing may run on the user's behalf.
             //    If the deadline answers first, it answers `{}`: the call runs as
@@ -3266,6 +3281,9 @@ export class ControlServer {
             });
         }
         this.noteHandover(run);
+        // The model doing the matched task itself, as in Claude Code (newestRun.md N1).
+        if (this.repeatDue(run))
+            this.openRepeat(session, run);
         const words = this.hostWords(payload);
         // Counted, never waited on, and never arming: see `tryIntentMatch`.
         await this.tryIntentMatch(session, run, toolName, words.intent, modelArgs);
@@ -3546,6 +3564,10 @@ export class ControlServer {
             out.add(prompt);
         if (run.fragment?.hitRunId)
             out.add(run.fragment.hitRunId);
+        // The recording the match offered a repeat of: the same recording, and
+        // known even when the match landed too late to be armed (newestRun.md).
+        if (run.repeat)
+            out.add(run.repeat.runId);
         return [...out];
     }
     /**
@@ -3985,8 +4007,16 @@ export class ControlServer {
     /** What the fragment's create call said: `created: false` is a hit, not a recording. */
     applyFragmentCreation(run, id, created) {
         const f = run.fragment;
-        if (created.created || !f || run.runId !== id)
+        if (!f || run.runId !== id)
+            return;
+        if (created.created) {
+            // Recorded as the newest run of the fragment it is a hit on (the
+            // service's newestRun.md N2): still that fragment's repeat, so no step
+            // hit may be counted against it (R-HIT-7).
+            if (created.fragmentOf)
+                f.hitRunId = created.fragmentOf.runId;
             return;
+        }
         run.recording = false;
         f.state = "hit";
         // Which run it hit matters from here on: this turn must not count step
@@ -4000,6 +4030,83 @@ export class ControlServer {
             why: "a hand-over at this step was recorded before — counted as a hit, not recorded",
         });
     }
+    /**
+     * 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).
+     */
+    repeatDue(run) {
+        const r = run.repeat;
+        if (!r || r.state !== "offered" || run.recording || run.finished || run.fragment)
+            return false;
+        const prompt = run.replays.find((s) => s.armedBy === "prompt");
+        if (!prompt?.plan)
+            return true;
+        return prompt.retired && prompt.stepsPinned === 0 && !prompt.handover;
+    }
+    /**
+     * Open the repeat run and record from this call on (newestRun.md N1).
+     *
+     * 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.
+     */
+    openRepeat(session, run) {
+        const r = run.repeat;
+        if (!r || r.state !== "offered")
+            return;
+        const reason = 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);
+        const id = this.recorder.startRun(run.input, { ...this.runMetadata(session), repeatOf }, framework ? { repeatOf, framework } : { repeatOf });
+        for (const c of run.correlations.values()) {
+            c.settled = true;
+            if (c.fallback)
+                clearTimeout(c.fallback);
+        }
+        run.builtIns.clear();
+        run.runId = id;
+        run.ordering = new StepIndexAllocator();
+        run.recording = true;
+        r.state = "open";
+        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",
+        });
+        if (!isRunCreationAware(this.recorder))
+            return;
+        void this.recorder
+            .runCreated(id)
+            .catch(() => ({ created: true }))
+            .then((created) => {
+            if (created.created || run.runId !== id)
+                return;
+            run.recording = false;
+            r.state = "refused";
+            logLine("run.repeat_refused", {
+                run: id,
+                of: r.runId,
+                why: "the service records no repeat of this recording — nothing recorded",
+            });
+        });
+    }
+    /**
+     * 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
+     * here, a plan that was late included.
+     */
+    repeatReason(run) {
+        const prompt = run.replays.find((s) => s.armedBy === "prompt") ?? run.lateMatch;
+        return run.repeat?.withheld ?? prompt?.declined ?? undefined;
+    }
     /** Resolve with `p`, or null once `ms` passes or it rejects. */
     async withinBudget(p, ms) {
         let timer;

package/dist/record/recorder.d.ts

@@ -11,6 +11,16 @@ export interface StartRunOptions {
         scenarioId: string;
         stepIndex: number;
     };
+    /**
+     * 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.
+     */
+    repeatOf?: {
+        runId: string;
+        reason?: string;
+    };
     /**
      * The run's `framework`, when the session named a host that is not Claude
      * Code: its `app`, or `app:scope` (`langchain`, `langchain:billing`). The
@@ -176,6 +186,15 @@ export interface RunMatch {
      * ordinary hand-out, and from an older service.
      */
     withheld?: string | null;
+    /**
+     * The service's offer (its newestRun.md N5): should the model end up doing
+     * this task itself — the plan declined, withheld, late or off — record the
+     * turn as a repeat of `runId`, the recording's newest run. Absent or null
+     * from a service that does not record repeats: then nothing is recorded.
+     */
+    repeat?: {
+        runId: string;
+    } | null;
 }
 /** Optional capability: `null` means "fresh run, keep recording". */
 export interface MatchAware {
@@ -202,10 +221,18 @@ export declare function isMatchAware(r: Recorder): r is Recorder & MatchAware;
 /** What the create call said about a run: fresh, or a hit on a fragment. */
 export interface RunCreation {
     created: boolean;
-    /** Set when this was a hit on an existing fragment (R-FALL-7, R-HIT-7). */
+    /**
+     * Set when this was a hit on an existing fragment (R-FALL-7, R-HIT-7) —
+     * with `created` too when the service recorded it all the same, as that
+     * fragment's newest run (its newestRun.md N2).
+     */
     fragmentOf?: {
         runId: string;
     };
+    /** Set when the service recorded the run as a repeat: the run it repeats. */
+    repeatOf?: {
+        runId: string;
+    };
 }
 export interface RunCreationAware {
     runCreated(runId: string): Promise<RunCreation>;

package/dist/record/remote-recorder.js

@@ -475,6 +475,9 @@ export class RemoteRecorder {
                         // A fragment (fallbk.md D7). Omitted, not null, so an older service
                         // that does not know the field sees the body it always saw.
                         ...(options?.fallbackOf ? { fallbackOf: options.fallbackOf } : {}),
+                        // A repeat (the service's newestRun.md). Sent only after a match
+                        // that offered it, so a service that would not know it never sees it.
+                        ...(options?.repeatOf ? { repeatOf: options.repeatOf } : {}),
                         // A chain with calls is inlined for this runner rather than stopped in
                         // front of its first call (segmented.md R-CALL-28).
                         supportsCalls: true,
@@ -496,7 +499,11 @@ export class RemoteRecorder {
                             why: "the create's first attempt failed, so the turn went ahead as a fresh one; the service kept its own run, and this one's steps are not sent",
                         });
                     }
-                    entry.settle(b.matched ?? null, { created: b.id !== null, fragmentOf: b.fragmentOf });
+                    entry.settle(b.matched ?? null, {
+                        created: b.id !== null,
+                        fragmentOf: b.fragmentOf,
+                        ...(b.repeatOf ? { repeatOf: b.repeatOf } : {}),
+                    });
                 }
                 catch (err) {
                     entry.settle(null, { created: true }); // fail-safe: on a create error, record normally

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@basein/runner",
-  "version": "0.3.13",
+  "version": "0.3.14",
   "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",