@basein/runner 0.3.23 → 0.3.24

package/dist/control/pin-guard.d.ts

@@ -85,20 +85,4 @@ export declare function commandShape(command: string, depth?: number, escape?: s
  * only the general rule is applied there.
  */
 export declare function pinCompatible(toolName: string, modelArgs: unknown, pinnedArgs: unknown, otherHost?: boolean): PinVerdict;
-/**
- * Whether the model's own call is a continuation's first step: the same call,
- * not only the same kind of call (the service's fallbk.md Part 3).
- *
- * Stricter than {@link pinCompatible}, on purpose. A pin takes a call the
- * model was told to make — the directive named the step — and one argument in
- * common is enough to know it is that call. A continuation starts on a call
- * nobody told the model to make: after a hand-over, the call is the model's
- * own choice of what to do next, and the plan may run only when that choice
- * is the one the recording made. Looking up another person, restarting
- * another worker, reading another file is another choice. So the call must
- * pass the pin guard, share at least one argument with the step, and hold
- * the same value in every argument they share — text compared without
- * surrounding space or letter case, anything else exactly.
- */
-export declare function sameFirstCall(toolName: string, modelArgs: unknown, stepArgs: unknown): PinVerdict;
 //# sourceMappingURL=pin-guard.d.ts.map

package/dist/control/pin-guard.js

@@ -545,40 +545,4 @@ export function pinCompatible(toolName, modelArgs, pinnedArgs, otherHost = false
         ? { ok: true }
         : { ok: false, why: "it shares no argument with the step" };
 }
-/**
- * Whether the model's own call is a continuation's first step: the same call,
- * not only the same kind of call (the service's fallbk.md Part 3).
- *
- * Stricter than {@link pinCompatible}, on purpose. A pin takes a call the
- * model was told to make — the directive named the step — and one argument in
- * common is enough to know it is that call. A continuation starts on a call
- * nobody told the model to make: after a hand-over, the call is the model's
- * own choice of what to do next, and the plan may run only when that choice
- * is the one the recording made. Looking up another person, restarting
- * another worker, reading another file is another choice. So the call must
- * pass the pin guard, share at least one argument with the step, and hold
- * the same value in every argument they share — text compared without
- * surrounding space or letter case, anything else exactly.
- */
-export function sameFirstCall(toolName, modelArgs, stepArgs) {
-    const verdict = pinCompatible(toolName, modelArgs, stepArgs);
-    if (!verdict.ok)
-        return verdict;
-    const model = record(modelArgs);
-    const step = record(stepArgs);
-    const shared = Object.keys(model).filter((key) => Object.prototype.hasOwnProperty.call(step, key));
-    if (shared.length === 0) {
-        return stableStringify(model) === stableStringify(step)
-            ? { ok: true }
-            : { ok: false, why: "it shares no argument with the step" };
-    }
-    const differs = shared.find((key) => !sameValue(model[key], step[key]));
-    return differs === undefined ? { ok: true } : { ok: false, why: `its ${differs} is not the step's` };
-}
-function sameValue(a, b) {
-    if (typeof a === "string" && typeof b === "string") {
-        return a.trim().toLowerCase() === b.trim().toLowerCase();
-    }
-    return stableStringify(a) === stableStringify(b);
-}
 //# sourceMappingURL=pin-guard.js.map

package/dist/control/server.d.ts

@@ -1178,12 +1178,17 @@ export declare class ControlServer {
      * hand-over itself is the question — the plan and the step — so the service
      * names one recording and matches no words.
      *
-     * It arms only when the call the model is making is that plan's first step —
-     * its tool, and arguments the pin guard would pin to the step's input — and
-     * is then answered in that call's place, as an intent plan whose first step
-     * the call is. The plan before it stopped because the next step needed a
-     * judgement. This call is the model's judgement; a plan that starts with
-     * another call is a way the model did not take, and must not run.
+     * It arms on the model's first call after the hand-over, whatever that call
+     * is (Eran, 2026-10-26). Runner 0.3.23 armed it only when the call was the
+     * plan's first step, and lost it whenever the model first re-checked what
+     * the plan before had already done. How the model is told depends on the
+     * call. A call to one of the plan's own tools is answered in its place: the
+     * plan makes that call itself, and letting it run would make it twice. Any
+     * other call runs as the model wrote it, and the plan is told on its
+     * PostToolUse, as an intent plan armed beside the model's own work is. The
+     * plan before it stopped because the next step needed a judgement; the
+     * continuation runs the half that was recorded, whatever the model would
+     * have judged.
      *
      * Its values are read from the turn's own request — the rest of the task is
      * the one the user asked for — with the model's words, the call it was about
@@ -1197,6 +1202,24 @@ export declare class ControlServer {
      * not armed is reported for its ticket, with the reason.
      */
     private tryContinuation;
+    /** The body of {@link tryContinuation}, once the continuation is asked for. */
+    private continuationAttempt;
+    /**
+     * A call meeting a continuation that armed beside another call of the same
+     * message and still waits to be told (`pendingDirective`). A call to one of
+     * the plan's own tools gets the plan's directive in its place: letting it
+     * run would have the plan make the same call again — a duplicated write.
+     * Any other call runs, and the plan is told on the first PostToolUse.
+     */
+    private announceContinuationInstead;
+    /**
+     * Put back the fragment a continuation took the place of, when that
+     * continuation retired having run no step and handed nothing over —
+     * `run_scenario` refused, the plan vetoed, or a steer pin left by the
+     * model. The model is doing the rest of the task itself, and that work is
+     * recorded from its next call, as it would have been with no continuation.
+     */
+    private restoreParkedFragment;
     /**
      * A continuation handed out and not armed: kept, retired, for its ticket's
      * report at the seal (`not_steered`, with the reason, unmeasured). `code`
@@ -1211,12 +1234,6 @@ export declare class ControlServer {
      * continuation request can never return it.
      */
     private armedScenarioIds;
-    /**
-     * Whether the model's call is a continuation's first step: its tool, and
-     * the step's own input in every argument the two share (pin-guard.ts
-     * `sameFirstCall`). Anything that cannot be computed is "no".
-     */
-    private isContinuationFirstCall;
     /** Whether continuations are asked for: on unless `BIR_CONTINUATIONS=0`. */
     private continuationsOn;
     /**

package/dist/control/server.js

@@ -30,7 +30,7 @@ import { join, resolve as resolvePath } from "node:path";
 import { BIR_CALL_ID, fingerprint, newCallId, parseQualifiedName, qualifyToolName, } from "./correlation.js";
 import { StepIndexAllocator } from "./ordering.js";
 import { pidAlive } from "./discovery.js";
-import { pinCompatible, sameFirstCall } from "./pin-guard.js";
+import { pinCompatible } from "./pin-guard.js";
 import { agentDayOf, 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";
@@ -492,17 +492,6 @@ function reportedArgs(args) {
 function score(value) {
     return typeof value === "number" && Number.isFinite(value) ? value.toFixed(3) : undefined;
 }
-/**
- * The tool a served scenario starts with, or undefined when the payload does
- * not say. Untyped JSON from the service, read without trusting its shape.
- */
-function firstStepTool(scenario) {
-    const steps = scenario?.steps;
-    if (!Array.isArray(steps) || steps.length === 0)
-        return undefined;
-    const name = steps[0]?.toolName;
-    return typeof name === "string" ? name : undefined;
-}
 function positiveEnv(name, fallback) {
     const n = Number(process.env[name]);
     return Number.isFinite(n) && n > 0 ? n : fallback;
@@ -3043,6 +3032,10 @@ export class ControlServer {
         // Billed apart, the part after the hand-over would be saved twice.
         const continuedBy = (state, from) => {
             const chain = [];
+            // A plan that ran no step reports `failed`, which books no saving: its
+            // continuations then book their own, and it bills only its own window.
+            if (state.outcome === "failed")
+                return { chain, deriveUsd: 0 };
             const ids = new Set(state.scenarioId ? [state.scenarioId] : []);
             for (const s of states.slice(from + 1)) {
                 if (s.continuation && ids.has(s.continuation.ofScenarioId)) {
@@ -3057,12 +3050,15 @@ export class ControlServer {
             const deriveUsd = [...chain, ...declined].reduce((usd, s) => usd + s.deriveCostUsd, 0);
             return { chain, deriveUsd };
         };
+        const chains = states.map((state, i) => continuedBy(state, i));
+        /** A continuation no plan of this turn books: its plan before it ran nothing. */
+        const booksOwn = (state) => state.continuation !== undefined && !chains.some((c, j) => states[j] !== state && c.chain.includes(state));
         // 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.
         // A turn with a single prompt-armed plan is exactly the report it always was.
         states.forEach((state, i) => {
-            const { chain, deriveUsd: chainDeriveUsd } = continuedBy(state, i);
+            const { chain, deriveUsd: chainDeriveUsd } = chains[i];
             // The plan whose arm ends this one's window: never one that continued it.
             const next = states.slice(i + 1).find((s) => !chain.includes(s));
             const nextMark = next?.armedBy === "intent" ? next.usageMark : undefined;
@@ -3098,6 +3094,7 @@ export class ControlServer {
                 cutShort: cutShort || undefined,
                 redoneBy: state === prompt && state.ranToEnd === true ? redoneBy : undefined,
                 chainDeriveUsd,
+                booksOwnSaving: booksOwn(state),
             });
             if (!report)
                 return;
@@ -3564,6 +3561,21 @@ export class ControlServer {
             if (stashed)
                 return this.preToolAnswer(this.replay.deliverInstead(stashed, toolName)) ?? {};
         }
+        // A continuation request of another call of this same message is still
+        // out (the service's fallbk.md Part 3): calls of one message reach their
+        // hooks at once. This one waits for it, so it meets whatever that request
+        // armed — a direct plan whose first call is not `run_scenario` is vetoed
+        // just below — and never opens the fragment beside it.
+        const attempt = run.fragment?.attempt;
+        if (attempt)
+            await this.withinBudget(attempt, CONTINUATION_PROBE_MS + CONTINUATION_ARM_MS);
+        // A continuation armed beside another call of this message is told on
+        // that call's PostToolUse. A call to one of its own tools must not run
+        // before then — the plan makes that call itself — so it is answered in
+        // its place, and that answer tells the model of the plan.
+        const told = planning ? undefined : this.announceContinuationInstead(run, toolName);
+        if (told)
+            return told;
         const live = this.livePlan(run);
         /** `run_scenario` for this session's own announced direct plan: allowed, see below. */
         let allowDirect = false;
@@ -3766,8 +3778,7 @@ export class ControlServer {
             // 2a. The model's first call after a plan handed over: the work recorded
             //     after an earlier hand-over at the same step may have a plan of its
             //     own (the service's fallbk.md Part 3). Asked with the hand-over, not
-            //     with words, and armed only when this call is its first step.
-            const dueFragment = run.fragment;
+            //     with words, and armed on this call, whatever the call is.
             const before = run.replay;
             const continued = planning
                 ? undefined
@@ -3792,10 +3803,18 @@ export class ControlServer {
                         run.replays.splice(at, 1);
                     run.replay = before;
                     this.keepDeclinedContinuation(session, run, late, "arm_unannounced");
-                    run.fragment = dueFragment;
+                    if (run.parkedFragment?.by === late) {
+                        run.fragment = run.parkedFragment.fragment;
+                        run.parkedFragment = undefined;
+                    }
                 }
             }
-            const armed = planning || continued
+            // A continuation that retired having run no step — refused, vetoed, or
+            // left by the model — gives the model's work back to the fragment.
+            this.restoreParkedFragment(run);
+            // A continuation armed beside this call is this turn's plan, waiting for
+            // the call's PostToolUse: no other plan is looked for in its place.
+            const armed = planning || continued || run.replay !== before
                 ? undefined
                 : await this.tryIntentMatch(session, run, toolName, intent, modelArgs);
             if (armed) {
@@ -3816,8 +3835,9 @@ export class ControlServer {
             }
             // 3. No scenario took over: the model's own work after a hand-over is
             //    recorded as a fragment, starting with this call.
-            // Not for the call an intent match just armed a plan beside: the plan
-            //    runs next, and the fragment opens on the model's own work after it.
+            // Not for the call a continuation or an intent match just armed a plan
+            //    beside: the plan runs next, and the fragment opens on the model's
+            //    own work after it.
             if (run.fragment?.state === "due" && !run.pendingDirective) {
                 await this.openFragment(session, run, reasoning, toolName, modelArgs);
             }
@@ -4572,12 +4592,17 @@ export class ControlServer {
      * hand-over itself is the question — the plan and the step — so the service
      * names one recording and matches no words.
      *
-     * It arms only when the call the model is making is that plan's first step —
-     * its tool, and arguments the pin guard would pin to the step's input — and
-     * is then answered in that call's place, as an intent plan whose first step
-     * the call is. The plan before it stopped because the next step needed a
-     * judgement. This call is the model's judgement; a plan that starts with
-     * another call is a way the model did not take, and must not run.
+     * It arms on the model's first call after the hand-over, whatever that call
+     * is (Eran, 2026-10-26). Runner 0.3.23 armed it only when the call was the
+     * plan's first step, and lost it whenever the model first re-checked what
+     * the plan before had already done. How the model is told depends on the
+     * call. A call to one of the plan's own tools is answered in its place: the
+     * plan makes that call itself, and letting it run would make it twice. Any
+     * other call runs as the model wrote it, and the plan is told on its
+     * PostToolUse, as an intent plan armed beside the model's own work is. The
+     * plan before it stopped because the next step needed a judgement; the
+     * continuation runs the half that was recorded, whatever the model would
+     * have judged.
      *
      * Its values are read from the turn's own request — the rest of the task is
      * the one the user asked for — with the model's words, the call it was about
@@ -4610,13 +4635,43 @@ export class ControlServer {
             return undefined;
         }
         f.asked = true;
-        const text = (intent?.text ?? "").trim().slice(0, 4_000);
+        // Calls of one message reach their hooks at once. The others wait for
+        // this attempt (`onToolPre`), so they meet whatever it armed, and none
+        // opens the fragment while it is still out.
+        let done;
+        f.attempt = new Promise((resolve) => {
+            done = resolve;
+        });
+        try {
+            return await this.continuationAttempt(session, run, f, toolName, intent, modelArgs);
+        }
+        finally {
+            f.attempt = undefined;
+            done();
+        }
+    }
+    /** The body of {@link tryContinuation}, once the continuation is asked for. */
+    async continuationAttempt(session, run, f, toolName, intent, modelArgs) {
+        const recorder = this.recorder;
+        if (!isIntentMatcher(recorder))
+            return undefined;
         const framework = frameworkOf(session);
-        const handover = { scenarioId: f.scenarioId, stepIndex: f.stepIndex };
+        const handover = {
+            scenarioId: f.scenarioId,
+            stepIndex: f.stepIndex,
+            ...(f.kind ? { kind: f.kind } : {}),
+            ...(f.handoverId ? { id: f.handoverId } : {}),
+        };
+        // Whether this hand-over is still the turn's: its fragment due, nothing
+        // recording, the turn open. Checked after every wait.
+        const stillDue = () => run.fragment === f && f.state === "due" && !run.recording && !run.finished;
         let landed = false;
-        const probe = this.recorder
+        const probe = recorder
             .matchIntent({
-            text,
+            // Answered by the hand-over alone, so no words go: a service from
+            // before continuations would match them against plan intents, and
+            // the agent's reasoning is not sent for nothing.
+            text: "",
             currentToolName: toolName,
             exclude: this.armedScenarioIds(run),
             handover,
@@ -4629,13 +4684,11 @@ export class ControlServer {
         });
         const answer = await this.withinBudget(probe, CONTINUATION_PROBE_MS);
         if (!answer) {
-            if (!landed) {
-                // Too slow, not failed: the service most likely counted the hand-over
-                // already, so the fragment says so. A plan its late answer hands out
-                // is reported as late, for its ticket.
-                f.counted = true;
-                void probe.then((late) => this.noteLateContinuation(run, handover, late));
-            }
+            // A plan a late answer hands out is reported as late, for its ticket.
+            // Whether the hand-over was counted is the service's to know: the
+            // fragment's create call carries the same id.
+            if (!landed)
+                void probe.then((late) => this.noteLateContinuation(run, f, late));
             logDetail("replay.continuation_miss", {
                 run: run.runId,
                 tool: toolName,
@@ -4655,7 +4708,7 @@ export class ControlServer {
                 continues: `${f.scenarioId}@${f.stepIndex}`,
                 recording: answer.continuation?.runId,
                 why: answer.continuation
-                    ? "the work recorded after an earlier hand-over here has no plan ready"
+                    ? "the work recorded after an earlier hand-over here has no plan to hand out"
                     : "no hand-over at this step was recorded before",
             });
             return undefined;
@@ -4665,11 +4718,8 @@ export class ControlServer {
             stepIndex: f.stepIndex,
             runId: answer.continuation.runId,
         };
-        // Before anything is read: the plan starts with another tool than the
-        // model's call, so the model chose another way.
-        const first = firstStepTool(match.scenario);
-        if (match.scenario && first !== undefined && first !== toolName) {
-            this.keepDeclinedContinuation(session, run, this.replay.declinedContinuation(match, "not_first_step", continuation));
+        if (!stillDue()) {
+            this.keepDeclinedContinuation(session, run, this.replay.declinedContinuation(match, "match_late", continuation));
             return undefined;
         }
         const startedAt = Date.now();
@@ -4681,7 +4731,8 @@ export class ControlServer {
         });
         // The rest of the task the user asked for: its values are in the turn's
         // request, and the model's words say what it is doing next.
-        const prompt = [run.input, text].filter((s) => s.trim().length > 0).join("\n\n");
+        const words = (intent?.text ?? "").trim().slice(0, 4_000);
+        const prompt = [run.input, words].filter((s) => s.trim().length > 0).join("\n\n");
         const arming = this.armOrLog(run, this.replay.arm(match, prompt, this.wrapped, "intent", {
             liveCall: { toolName, toolInput },
             recentResults: this.recentResultsFor(session, "call"),
@@ -4714,21 +4765,40 @@ export class ControlServer {
             this.keepDeclinedContinuation(session, run, state);
             return undefined;
         }
-        // Its values are in: the model's call must be its first step, arguments
-        // and all — the same call, not merely one the pin guard would take over
-        // (pin-guard.ts `sameFirstCall`).
-        await this.withinBudget(state.plan.ready().catch(() => undefined), Math.max(0, CONTINUATION_ARM_MS - (Date.now() - startedAt)));
-        if (!this.isContinuationFirstCall(state, toolName, modelArgs)) {
-            this.keepDeclinedContinuation(session, run, state, "not_first_step");
+        // Its values, worked out before the model is told of it: a reading that
+        // did not settle in time, or the plan's own code for its values failing,
+        // is said as what it is, and the plan is never handed out.
+        let paramsFailed = false;
+        const settled = await this.withinBudget(state.plan.ready().then(() => true, () => {
+            paramsFailed = true;
+            return false;
+        }), Math.max(0, CONTINUATION_ARM_MS - (Date.now() - startedAt)));
+        if (!stillDue()) {
+            this.keepDeclinedContinuation(session, run, state, "arm_unannounced");
+            return undefined;
+        }
+        if (settled === null) {
+            this.keepDeclinedContinuation(session, run, state, "arm_timeout");
+            return undefined;
+        }
+        if (paramsFailed) {
+            this.keepDeclinedContinuation(session, run, state, "params_failed");
             return undefined;
         }
+        // Whatever the model's call is, the plan takes the rest of the task. A
+        // call to one of its own tools is answered in its place: the plan makes
+        // that call itself, and letting it run first would make it twice — a
+        // duplicated write. Any other call (a re-check of what the plan before
+        // did, say) runs as the model wrote it, and the plan is told after it.
+        const inPlace = state.plan.usesTool(toolName);
         state.usageMark = markTranscriptUsage(session.transcriptPath);
         state.markUsage = () => markTranscriptUsage(session.transcriptPath);
         run.replays.push(state);
         run.replay = state;
         // From here the continuation is this turn's plan. A hand-over of its own,
-        // if it makes one, schedules its own fragment: the one the plan before it
-        // left due is not opened.
+        // if it makes one, schedules its own fragment. The one the plan before it
+        // left due is parked, and put back should this plan run no step.
+        run.parkedFragment = { by: state, fragment: f };
         run.fragment = undefined;
         const directive = this.replay.directiveFor(state) ?? "";
         logLine("replay.continuation_armed", {
@@ -4737,11 +4807,67 @@ export class ControlServer {
             continues: `${continuation.ofScenarioId}@${continuation.stepIndex}`,
             recording: continuation.runId,
             mode: state.mode,
-            instead: toolName,
+            instead: inPlace ? toolName : undefined,
+            after: inPlace ? undefined : toolName,
             ms: Date.now() - startedAt,
-            why: "the model's call after the hand-over is the first step of the plan calculated from the work recorded after an earlier hand-over at this step",
+            why: inPlace
+                ? "the plan calculated from the work recorded after an earlier hand-over at this step takes the rest of the task, in place of the model's call to one of its own tools"
+                : "the plan calculated from the work recorded after an earlier hand-over at this step takes the rest of the task after the model's call, which runs as written",
+        });
+        if (inPlace)
+            return this.preToolAnswer(this.replay.deliverInstead(directive, toolName));
+        run.pendingDirective = { state, text: directive };
+        return undefined;
+    }
+    /**
+     * A call meeting a continuation that armed beside another call of the same
+     * message and still waits to be told (`pendingDirective`). A call to one of
+     * the plan's own tools gets the plan's directive in its place: letting it
+     * run would have the plan make the same call again — a duplicated write.
+     * Any other call runs, and the plan is told on the first PostToolUse.
+     */
+    announceContinuationInstead(run, toolName) {
+        const pending = run.pendingDirective;
+        const state = pending?.state;
+        if (!pending || !state || state !== run.replay || !state.continuation)
+            return undefined;
+        if (!state.plan || state.retired || !pending.text || !state.plan.usesTool(toolName))
+            return undefined;
+        run.pendingDirective = undefined;
+        logLine("replay.continuation_told", {
+            run: run.runId,
+            scenario: state.scenarioId ?? undefined,
+            instead: toolName,
+            why: "a call to one of the continuation's own tools, made beside the call it armed on — answered in its place, so the plan does not make it twice",
+        });
+        return this.preToolAnswer(this.replay.deliverInstead(pending.text, toolName));
+    }
+    /**
+     * Put back the fragment a continuation took the place of, when that
+     * continuation retired having run no step and handed nothing over —
+     * `run_scenario` refused, the plan vetoed, or a steer pin left by the
+     * model. The model is doing the rest of the task itself, and that work is
+     * recorded from its next call, as it would have been with no continuation.
+     */
+    restoreParkedFragment(run) {
+        const parked = run.parkedFragment;
+        if (!parked || run.fragment || run.recording || run.finished)
+            return;
+        const s = parked.by;
+        if (!s.retired || s.stepsPinned > 0 || s.handover || s.ranToEnd || s.running || this.runningPlans.has(s))
+            return;
+        run.parkedFragment = undefined;
+        run.fragment = parked.fragment;
+        // Its report says why, for its ticket: told of the plan, the model never
+        // asked for it — another call of the same message came first, or it chose
+        // its own way after the directive.
+        if (!s.declined && !s.directRequested)
+            s.declined = "not_taken";
+        logLine("replay.continuation_unused", {
+            run: run.runId,
+            scenario: s.scenarioId ?? undefined,
+            why: "the continuation retired without running a step — the model's own work is recorded from this call, as before",
         });
-        return this.preToolAnswer(this.replay.deliverInstead(directive, toolName));
     }
     /**
      * A continuation handed out and not armed: kept, retired, for its ticket's
@@ -4759,9 +4885,9 @@ export class ControlServer {
                 continues: state.continuation
                     ? `${state.continuation.ofScenarioId}@${state.continuation.stepIndex}`
                     : undefined,
-                why: code === "not_first_step"
-                    ? "the model's call after the hand-over is not this continuation's first step — the model chose another way"
-                    : "the continuation was not armed in time",
+                why: code === "params_failed"
+                    ? "the continuation's own code for its values failed — never handed out, so never run"
+                    : "the continuation was not armed in time — never handed out, so never run",
             });
         }
         state.sessionId = session.sessionId;
@@ -4797,27 +4923,6 @@ export class ControlServer {
             .map((s) => s.scenarioId)
             .filter((id) => typeof id === "string");
     }
-    /**
-     * Whether the model's call is a continuation's first step: its tool, and
-     * the step's own input in every argument the two share (pin-guard.ts
-     * `sameFirstCall`). Anything that cannot be computed is "no".
-     */
-    isContinuationFirstCall(state, toolName, modelArgs) {
-        const plan = state.plan;
-        if (!plan || plan.expectedTool() !== toolName)
-            return false;
-        try {
-            const verdict = sameFirstCall(toolName, modelArgs, plan.toolInputForCurrentStep());
-            if (!verdict.ok) {
-                logDetail("replay.continuation_other_call", { tool: toolName, why: verdict.why });
-            }
-            return verdict.ok;
-        }
-        catch (err) {
-            logDetail("replay.first_step_unknown", { tool: toolName, error: errText(err) });
-            return false;
-        }
-    }
     /** Whether continuations are asked for: on unless `BIR_CONTINUATIONS=0`. */
     continuationsOn() {
         if (this.opts.continuations !== undefined)
@@ -4884,7 +4989,15 @@ export class ControlServer {
         const h = state?.handover;
         if (!h || !state?.scenarioId)
             return;
-        run.fragment = { scenarioId: state.scenarioId, stepIndex: h.stepIndex, state: "due" };
+        run.fragment = {
+            scenarioId: state.scenarioId,
+            stepIndex: h.stepIndex,
+            state: "due",
+            // Which half the model's work after it is (the service's fallbk.md
+            // Part 3), and the id that makes the hand-over one hit.
+            kind: h.kind,
+            handoverId: `ho_${randomUUID()}`,
+        };
     }
     /**
      * Open the fragment run and record from this call on (fallbk.md D7).
@@ -4904,9 +5017,15 @@ export class ControlServer {
             return;
         const input = reasoning.trim() || `${toolName} ${serializeCapped(redact(args))}`.slice(0, 2_000);
         const fallbackOf = { scenarioId: f.scenarioId, stepIndex: f.stepIndex };
-        // The service counted this hand-over already, when it was asked for its
-        // continuation (Part 3): the create says so, and is not counted again.
-        const sent = f.counted ? { ...fallbackOf, counted: true } : fallbackOf;
+        // Which half of a step's test this work is, and the hand-over's id, which
+        // its continuation request carried too: the service counts the hand-over
+        // once (Part 3). `counted` says the same to a service from before ids.
+        const sent = {
+            ...fallbackOf,
+            ...(f.kind ? { kind: f.kind } : {}),
+            ...(f.handoverId ? { handoverId: f.handoverId } : {}),
+            ...(f.counted ? { counted: true } : {}),
+        };
         // The fragment is a run of the same host as the turn it continues.
         const framework = frameworkOf(session);
         const id = this.recorder.startRun(input, { ...this.runMetadata(session), fallbackOf }, framework ? { fallbackOf: sent, framework } : { fallbackOf: sent });

package/dist/record/recorder.d.ts

@@ -8,13 +8,18 @@
 import type { ExecutionStage, ExecutionStepResult, FallbackKind } from "../replay/types.js";
 export interface StartRunOptions {
     /**
-     * Marks a *fragment* (fallbk.md D7). `counted`: the runner asked for this
-     * hand-over's continuation first, and the service counted the hand-over as
-     * a hit then, so this request must not count it again (Part 3).
+     * Marks a *fragment* (fallbk.md D7). `kind`: the kind of hand-over, so the
+     * other half of a step's test gets a fragment of its own (Part 3).
+     * `handoverId`: the hand-over's id, which its continuation request carried
+     * too, so the service counts the hand-over once. `counted`: the same for a
+     * service from before ids — it counted the hand-over when asked for its
+     * continuation.
      */
     fallbackOf?: {
         scenarioId: string;
         stepIndex: number;
+        kind?: string;
+        handoverId?: string;
         counted?: boolean;
     };
     /**
@@ -313,11 +318,16 @@ export interface IntentMatchRequest {
      * A continuation request (the service's fallbk.md Part 3): the plan that
      * just handed the task to the model, and the step it stopped in front of.
      * The service answers with the plan of the work recorded after an earlier
-     * hand-over at that step, if there is one, and matches no words.
+     * hand-over at that step, if there is one, and matches no words. `kind`:
+     * the kind of hand-over (the other half of a step's test is continued only
+     * by the other half's recording); `id`: the hand-over's id, which its
+     * fragment's create call carries too, so the hand-over counts once.
      */
     handover?: {
         scenarioId: string;
         stepIndex: number;
+        kind?: string;
+        id?: string;
     };
 }
 /** The answer to a probe. */

package/dist/replay/controller.d.ts

@@ -608,13 +608,21 @@ export type DeclineCode = "replay_disabled" | "not_ready" | "known_bad_first_ste
  */
  | "match_late"
 /**
- * A continuation (the service's fallbk.md Part 3) whose first step is not
- * the call the model is making after the hand-over: another tool, or the
- * same tool on something else. The model chose what to do next — the
- * judgement the plan before it stopped for — and chose otherwise. Set by
+ * A continuation (the service's fallbk.md Part 3) armed after the hand-over
+ * and told to the model, which never ran it: `run_scenario` was never asked
+ * for — another call of the same message came first, the model did the
+ * rest its own way, or the call was refused. Set by the control server.
+ * (Runner 0.3.23 armed a continuation only when the model's call was its
+ * first step and declined it otherwise as `not_first_step`. From 0.3.24 it
+ * arms on the model's first call after the hand-over, whatever that is.)
+ */
+ | "not_taken"
+/**
+ * A continuation whose own code for working out its values (`paramsLogic`)
+ * failed on this request, so none of its steps could be computed. Set by
  * the control server.
  */
- | "not_first_step";
+ | "params_failed";
 /**
  * What a continuation continues (the service's fallbk.md Part 3): the plan
  * that handed over, the step it stopped in front of, and the recording of the
@@ -712,10 +720,9 @@ export declare class ReplayController {
     lateMatch(match: RunMatchLike, host?: HostContext): ReplayState;
     /**
      * The state of a continuation handed out and not armed (the service's
-     * fallbk.md Part 3): declined before any gate ran — its first step is not
-     * the model's call (`not_first_step`), or the service's answer came too
-     * late (`match_late`). Like {@link lateMatch}, it exists only for its
-     * ticket's report, with the reason.
+     * fallbk.md Part 3): declined before any gate ran — the service's answer
+     * came too late (`match_late`). Like {@link lateMatch}, it exists only for
+     * its ticket's report, with the reason.
      */
     declinedContinuation(match: RunMatchLike, code: DeclineCode, continuation: ContinuationOf): ReplayState;
     /**
@@ -1015,6 +1022,12 @@ export declare class ReplayController {
          * them would be left out of the turn's saving.
          */
         chainDeriveUsd?: number;
+        /**
+         * A continuation whose plan before it ran no step (its report is
+         * `failed`, which books no saving): this one books its own, against its
+         * own baseline, so the turn's saving is booked somewhere.
+         */
+        booksOwnSaving?: boolean;
     }): ExecutionReport | undefined;
     /**
      * The step a failed replay is fairly blamed on: the first whose own logic

package/dist/replay/controller.js

@@ -376,10 +376,9 @@ export class ReplayController {
     }
     /**
      * The state of a continuation handed out and not armed (the service's
-     * fallbk.md Part 3): declined before any gate ran — its first step is not
-     * the model's call (`not_first_step`), or the service's answer came too
-     * late (`match_late`). Like {@link lateMatch}, it exists only for its
-     * ticket's report, with the reason.
+     * fallbk.md Part 3): declined before any gate ran — the service's answer
+     * came too late (`match_late`). Like {@link lateMatch}, it exists only for
+     * its ticket's report, with the reason.
      */
     declinedContinuation(match, code, continuation) {
         const state = this.blankState(match, new Set(), "intent");
@@ -392,9 +391,7 @@ export class ReplayController {
             run: match.runId,
             scenario: match.scenarioId ?? undefined,
             continues: `${continuation.ofScenarioId}@${continuation.stepIndex}`,
-            why: code === "not_first_step"
-                ? "a continuation starts only on its first step, and the model's call after the hand-over is another one"
-                : "the continuation came after the call it could have replaced had gone ahead",
+            why: "the continuation came after the call it could have replaced had gone ahead",
         });
         return state;
     }
@@ -1998,8 +1995,11 @@ export class ReplayController {
             // The agent did not take the plan's result and redid the task (AC1).
             ...(d.redoneBy ? { redoneBy: d.redoneBy } : {}),
             // A continuation (the service's fallbk.md Part 3): the plan it continued
-            // books the whole turn, so this report books no saving of its own.
-            ...(state.continuation ? { continues: { scenarioId: state.continuation.ofScenarioId } } : {}),
+            // books the whole turn, so this report books no saving of its own —
+            // unless that plan ran nothing and books none.
+            ...(state.continuation && !d.booksOwnSaving
+                ? { continues: { scenarioId: state.continuation.ofScenarioId } }
+                : {}),
             // A turn in which another plan ran is not a measurement of what this task
             // costs unaided, so it is no baseline sample (segmented.md R-MONEY-5).
             // This covers two plans that both armed, and — the case that was silently

package/docs/calculatedReplayGuide.md

@@ -373,7 +373,7 @@ so there is exactly one switch and it cannot get out of step with itself.
 | `BIR_BASH_ALLOW` | *(unset: any command)* | Command prefixes a runner-side `Bash` step may run (`*` for all). Unset means any command; `none` means no command, and `Bash` steps are steered in the session. A plan's Bash steps share a working directory, exactly as the host's own Bash tool does — variables and functions do not persist, also as the host's. A call with `run_in_background`, or with its own `timeout` longer than the step's clock (`BIR_STEP_TIMEOUT_MS`), is never started on the runner: the plan hands over in front of it |
 | `BIR_PATH_ALLOW` | *(unset: any folder, from 0.3.21)* | Folders a runner-side `Read`, `Glob`, `Grep`, `Edit` or `Write` may touch (`*` for all). Unset means any path, as the agent's own tools reach it — a plan that reads the agent's memory file under `~/.claude` runs. `project` is the session's project folder alone (the rule up to 0.3.20); add folders after a comma, `~` for the home folder: `project,~/.claude`. Under a list, a path outside it, symlinks included, is refused and the plan hands over in front of it. `none` means no folder, and the file steps are steered in the session. `Bash` is `BIR_BASH_ALLOW`'s |
 | `BIR_INTENT_ARM` | *(unset: off)* | `1` lets a whole plan whose intent matches the agent's reasoning mid-turn arm in the calling tool's place, which means waiting for it (`BIR_INTENT_ARM_BUDGET_MS`, 500). Unset or `0`: off — no probe is sent and nothing arms mid-turn, as up to 0.3.18 |
-| `BIR_CONTINUATIONS` | *(unset: on, from 0.3.23)* | After a plan hands the task to the agent at a step, the agent's first call asks the service for the plan of the work recorded after an earlier hand-over at that step — once per hand-over, waiting 1.5 s at most for the answer and up to 7 s for its values — and runs it in that call's place only when the call is its first step (the same tool, on the same thing). Its saving is counted on the plan that handed over. `0`: off, and the agent's work is recorded as before. `BIR_INTENT_MATCH=0` turns it off too |
+| `BIR_CONTINUATIONS` | *(unset: on, from 0.3.23)* | After a plan hands the task to the agent at a step, the agent's first call asks the service for the plan of the work recorded after an earlier hand-over at that step — once per hand-over, waiting 1.5 s at most for the answer and up to 7 s for its values — and that plan does the rest of the task, whatever the agent's call was (from 0.3.24; 0.3.23 ran it only when the call was its first step). A call to one of the plan's own tools is answered in its place, so the plan never makes it twice; any other call runs as the agent wrote it, and the agent is told of the plan on its result. Its saving is counted on the plan that handed over. `0`: off, and the agent's work is recorded as before. `BIR_INTENT_MATCH=0` turns it off too |
 | `BIR_VERBOSE` | *(unset)* | `1` adds per-step `replay.*` detail lines |
 
 The `bir` server reads its own, from the environment Claude Code starts it with:

package/package.json

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