@basein/runner 0.3.23 → 0.3.25

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. */