@basein/runner 0.3.17 → 0.3.19

package/dist/replay/controller.js

@@ -21,20 +21,27 @@ import { bashCommandFor } from "./bash-channel.js";
 import { BuiltinNotRunnable, BuiltinTimeout, parseBashAllow, parseBuiltinTools, runBuiltin, } from "./builtins.js";
 import { BASH_CHANNEL_MAX, MAX_REPLAY_REASON, testWords, truncate } from "./bundle.js";
 import { coverageOf, modeFor, reachOf } from "./coverage.js";
-import { deriveParameters, } from "./derive.js";
+import { deriveParameters, localDay, } from "./derive.js";
 import { buildHandoverNote, MAX_HANDOVER_NOTE, } from "./handover.js";
 import { NO_PROXY, NoSessionProxyError, ProxyWorkQueue, QUEUE_CLOSED } from "./executor.js";
 import { logicTimeoutMs, MAX_LOGIC_TIMEOUT_MS } from "./logic.js";
-import { PREVIEW_BUDGET_MS, ScenarioReplayPlan, StepRunError, } from "./plan.js";
+import { PREVIEW_BUDGET_MS, RecordedValueError, ScenarioReplayPlan, StepRunError, } from "./plan.js";
 import { PRICING_VERSION } from "./pricing.js";
 import { hasShellStep, sinkOf, sinkOfPlan, unsafeParameter } from "./safety.js";
 import { SourceRunOutputs } from "./source-run.js";
 import { clampToFrameStart, flattenChain, frameEdges, } from "./flatten.js";
-import { blockingTargets } from "./targets.js";
+import { blockingTargets, testedOnlyTargets } from "./targets.js";
 import { isNoResult, toolResultError } from "./tool-error.js";
 import { OUTCOME_RANK, hasTargets, isReadyScenario, } from "./types.js";
 /** The first-party tool a `direct` plan is delivered through (§6.3). */
 export const DIRECT_TOOL_NAME = "mcp__bir__run_scenario";
+/**
+ * `bir`'s own tool for saying a replay's results do not answer the request
+ * (bin/bir-scenario.ts; the service's review of calcscenarioautocorrect.md,
+ * item 19): the one call a finished bundle lets the agent make, where the
+ * session has it ({@link ReplayState.reportTool}).
+ */
+export const REPORT_TOOL_NAME = "mcp__bir__report_wrong_result";
 /** How long a `/proxy/poll` is held open before it answers empty. */
 export const POLL_HOLD_MS = 25_000;
 /**
@@ -113,6 +120,19 @@ const DIRECT_RUN_MARGIN_MS = 5_000;
  * Each is bounded by `logicTimeoutMs()` (logic.ts).
  */
 const LOGIC_BODIES_OUTSIDE_PLAN = 6;
+/**
+ * The agent's day as a system prompt said it, and only then (issue 1212): a
+ * line that says a day, written out or in words. Claude Code's own date
+ * reminder is this machine's day, which the runner knows better itself.
+ */
+function systemDay(day) {
+    if (!day || day.source !== "system")
+        return undefined;
+    if (day.day)
+        return day;
+    const words = /\b(jan(uary)?|feb(ruary)?|mar(ch)?|apr(il)?|may|june?|july?|aug(ust)?|sep(t(ember)?)?|oct(ober)?|nov(ember)?|dec(ember)?)\b/i;
+    return words.test(day.line) && /\b\d{4}\b/.test(day.line) ? day : undefined;
+}
 /** A derivation wait longer than this is not a budget a direct run can keep. */
 const MAX_DIRECT_DERIVE_MS = 60_000;
 /** However a direct run is squeezed, its plan keeps at least this. */
@@ -268,9 +288,11 @@ export class ReplayController {
     /**
      * Whether a handed-out segment may actually arm (segmented.md R-OUT-10).
      *
-     * Off by default: until an operator has read the observe-only logs and turned
-     * `BIR_SEGMENT_ARM=1` on, the runner asks for no segment and arms none. The
-     * server enforces the same thing from its side (R-OUT-9).
+     * Only when the option says so. The recorder passes it on unless
+     * `BIR_SEGMENT_ARM=0` (from 0.3.19; the service's segmentsbreakdown.md
+     * SB-21); a controller built without it stays observe-only, asks for no
+     * segment and arms none. The server enforces the same thing from its side
+     * (R-OUT-9).
      */
     get segmentArm() {
         return this.opts.segmentArm === true;
@@ -369,6 +391,10 @@ export class ReplayController {
      */
     async arm(match, prompt, wrapped, armedBy = "prompt", ctx = {}, host) {
         const state = this.blankState(match, wrapped, armedBy, host);
+        // A decision note quotes the request (SB-18); a plan armed by intent was
+        // given the step's intent here, and its control server sets the request.
+        if (armedBy === "prompt")
+            state.request = prompt;
         const isSegment = state.kind === "segment";
         const decline = (why, code) => {
             state.declined = code;
@@ -460,12 +486,18 @@ export class ReplayController {
             const unusable = flat.stopAt === 0 && flat.stopReason ? flat.stopReason : undefined;
             // The step that stops the plan, before the clamp: the reason is its own.
             const stopping = entries[Math.min(...rawStop)]?.step ?? entries[0].step;
-            const judgement = stopping.stop?.kind === "nondeterministic";
+            // The service never serves a decision at step 0 (segmentsbreakdown.md
+            // SB-5): should one come, the agent decides from the start, as it makes
+            // a judgement there. No new code reaches a service that may not know it.
+            const decisionFirst = stopping.stop?.kind === "decision";
+            const judgement = stopping.stop?.kind === "nondeterministic" || decisionFirst;
             const why = unusable
                 ? `its first step is a call that cannot run: ${unusable.reason}`
-                : judgement
-                    ? "its first step needs a judgement the plan cannot compute — the agent does this task"
-                    : `its first step has failed ${stopping.failureCount ?? 0} times — the agent does this task`;
+                : decisionFirst
+                    ? "its first step is a decision the agent makes — the agent does this task"
+                    : judgement
+                        ? "its first step needs a judgement the plan cannot compute — the agent does this task"
+                        : `its first step has failed ${stopping.failureCount ?? 0} times — the agent does this task`;
             return decline(why, unusable
                 ? "unusable_first_step"
                 : judgement
@@ -506,7 +538,7 @@ export class ReplayController {
         // command nobody asked for.
         let deriveCtx = ctx;
         if (ctx.recentResults?.length && sinkOfPlan(planned, host?.sinks) === "command") {
-            deriveCtx = { liveCall: ctx.liveCall };
+            deriveCtx = { liveCall: ctx.liveCall, agentDay: ctx.agentDay };
             logLine("replay.derive_context", {
                 scenario: scenario.id,
                 shell: hasShellStep(planned, host?.sinks) || undefined,
@@ -515,11 +547,27 @@ export class ReplayController {
             });
         }
         const derivation = this.startDerivation(scenario, prompt, state, deriveCtx);
+        // The agent's own day shows in the session only after the prompt hook
+        // (issue 1212): the plan's start looks again, and reads the values once
+        // more when the day is another one.
+        state.agentDayNow = deriveCtx.agentDay;
+        state.rederive = (day) => this.startDerivation(scenario, prompt, state, { ...deriveCtx, agentDay: () => day });
         // Whether the derivation has answered yet — read, never waited on, when the
         // directive is written (below).
         let deriveAnswered = false;
         derivation.then(() => (deriveAnswered = true), () => (deriveAnswered = true));
-        const params = derivation.then((r) => r.params);
+        // The targets only one half of this plan reads (the service's review of
+        // calcscenarioautocorrect.md, item 11; targets.ts, `testedOnlyTargets`):
+        // the plan holds each as a mark when the request does not give it. A
+        // reading that did not answer carries every target at its recorded
+        // sample (derive.ts), and one of these must be the mark there too — never
+        // last week's task name under a step that would create the task.
+        const oneHalf = hasTargets(scenario.paramsObject)
+            ? testedOnlyTargets(targetKeys(scenario.paramsObject), scenario.paramsObject, planned, scenario.paramsLogic)
+            : [];
+        const params = derivation.then((r) => r.derived || oneHalf.length === 0
+            ? r.params
+            : { ...r.params, ...Object.fromEntries(oneHalf.map((key) => [key, null])) });
         // `params` is awaited by the plan, and by gate 7 below when there is a
         // target. Without this, the losing race in gate 7 leaves `derivation`
         // rejected and unhandled, which takes the process down on an unhandled
@@ -578,11 +626,22 @@ export class ReplayController {
                 // Worth a line of its own: this is the difference between a scenario
                 // that never runs and one that does, and it is the first thing to look
                 // at when a replay acts on the wrong thing.
-                logLine("replay.targets_found_by_chain", {
-                    scenario: scenario.id,
-                    unnamed: result.missing.join(","),
-                    why: "the chain computes these from its own steps; none is read from the caller",
-                });
+                const forOneHalf = result.missing.filter((key) => oneHalf.includes(key));
+                const byChain = result.missing.filter((key) => !oneHalf.includes(key));
+                if (byChain.length > 0) {
+                    logLine("replay.targets_found_by_chain", {
+                        scenario: scenario.id,
+                        unnamed: byChain.join(","),
+                        why: "the chain computes these from its own steps; none is read from the caller",
+                    });
+                }
+                if (forOneHalf.length > 0) {
+                    logLine("replay.targets_for_one_half", {
+                        scenario: scenario.id,
+                        unnamed: forOneHalf.join(","),
+                        why: "only steps that run under a test read these: the plan runs, and a step that needs one stops in front of its call for the agent",
+                    });
+                }
             }
             // The values are in hand: one this plan must not template into its
             // command (safety.ts) declines here, before any directive is injected,
@@ -700,6 +759,15 @@ export class ReplayController {
             ...(plan.stopsEarly() ? { stopAt: plan.stepCount } : {}),
         };
     }
+    /**
+     * Whether the plan's steps end in front of a decision (the service's
+     * segmentsbreakdown.md SB-6): it runs the steps before it, then hands the
+     * task back there. The control server gives such a plan a usage mark, so
+     * that it is billed only up to the stop (SB-26).
+     */
+    stopsAtDecision(state) {
+        return state.plan?.stopEntry()?.step.stop?.kind === "decision";
+    }
     /**
      * Take back a plan that armed and has run nothing, as a decline.
      *
@@ -1058,10 +1126,12 @@ export class ReplayController {
                 // a note, delivered in place of this call.
                 const step = plan.currentStep();
                 if (step) {
+                    // A value only the recording holds (issue 1212) is no fault of the step.
+                    const recorded = err instanceof RecordedValueError;
                     this.recordStep(state, {
                         step,
                         entry: plan.currentEntry(),
-                        outcome: "failed",
+                        outcome: recorded ? "skipped" : "failed",
                         stage: "tool_input_logic",
                         error: errText(err),
                     });
@@ -1071,6 +1141,7 @@ export class ReplayController {
                         position: plan.currentStepIndex,
                         error: errText(err),
                         delivery: "above",
+                        ...(recorded ? { stopReason: "not_run" } : {}),
                     });
                     const note = this.takeNote(state);
                     if (note)
@@ -1772,7 +1843,7 @@ export class ReplayController {
         const deadline = Date.now() + this.budgets.planMs;
         let result;
         try {
-            result = await plan.runToCompletion(this.executeStep(state, { deadline }), this.recordedSource(state), this.observeStep(state), deadline, MAX_REPLAY_REASON, { stopOnFailure: true, recordedFallback: this.recordedFallback, signal });
+            result = await plan.runToCompletion(this.executeStep(state, { deadline }), this.recordedSource(state), this.observeStep(state), deadline, MAX_REPLAY_REASON, { stopOnFailure: true, recordedFallback: this.recordedFallback, signal, reportTool: this.reportToolFor(state) });
         }
         catch (err) {
             // The scenario's own logic failed. Retire and let the model do the work.
@@ -1952,16 +2023,20 @@ export class ReplayController {
         const total = state.deriveCostUsd + d.sessionCostUsd + state.fallbackCostUsd;
         const steps = this.stepResultsOf(state);
         const isBaseline = state.outcome === "not_steered" || state.outcome === "failed";
+        // The plan handed the task back by design, not by a fault: in front of the
+        // other half of an "if … otherwise" (AC5), or at its decision (the
+        // service's segmentsbreakdown.md SB-19). Such a stop is named whatever the
+        // outcome, and the agent's work after it is the service's evidence.
+        const handedBack = state.handover?.kind === "other_branch" || state.handover?.kind === "decision";
         // A costless decline is noise on both sides — *unless* it says something the
         // recording page cannot learn any other way: a step that actually broke, the
-        // gate that declined, or a plan that stood in front of the other half of
-        // its task (AC5), which the service takes the agent's work after as its
-        // evidence of that half. The service accepts a costless report that carries
-        // any of them (its errorshandling.md).
+        // gate that declined, or a plan that handed the task back by design. The
+        // service accepts a costless report that carries any of them (its
+        // errorshandling.md).
         if (isBaseline &&
             total <= 0 &&
             !state.declined &&
-            state.handover?.kind !== "other_branch" &&
+            !handedBack &&
             !steps?.some((s) => s.status === "failed")) {
             return undefined;
         }
@@ -2002,14 +2077,15 @@ export class ReplayController {
             declined: state.declined,
             // Where the plan handed the task to the model (fallbk.md). Only on
             // `fell_back`: a hand-over before any step ran is `failed`, and a parked
-            // step found after a divergence is still a divergence. Except the other
-            // half of an "if … otherwise" (AC5), named whatever the outcome: the
-            // agent's work after it is the service's evidence of that half, whether
+            // step found after a divergence is still a divergence. Except a plan
+            // that handed the task back by design — the other half of an "if …
+            // otherwise" (AC5), or its decision (SB-19) — named whatever the
+            // outcome: the agent's work after it is the service's evidence, whether
             // or not a step ran first.
-            fallbackStepIndex: state.outcome === "fell_back" || state.handover?.kind === "other_branch"
+            fallbackStepIndex: state.outcome === "fell_back" || handedBack
                 ? state.handover?.stepIndex
                 : undefined,
-            fallbackKind: state.outcome === "fell_back" || state.handover?.kind === "other_branch"
+            fallbackKind: state.outcome === "fell_back" || handedBack
                 ? state.handover?.kind
                 : undefined,
             // The agent did not take the plan's result and redid the task (AC1).
@@ -2060,6 +2136,10 @@ export class ReplayController {
      * there is nothing to be similar *to* and nothing to decline. It books no
      * execution either — there is no ticket, and inventing a saving for a manual
      * invocation is exactly the kind of number a ledger must never contain.
+     *
+     * One served stop is kept: a plan's decision (the service's
+     * segmentsbreakdown.md SB-6). The run stops in front of it, and `stopped`
+     * says so with the reason `decision`.
      */
     async runAdHoc(scenario, prompt, wrapped) {
         if (!isReadyScenario(scenario))
@@ -2124,16 +2204,25 @@ export class ReplayController {
             }
             return out;
         });
+        // The one served stop an operator's run keeps: a decision (the service's
+        // segmentsbreakdown.md SB-6). The steps after it are one half of an "if …
+        // otherwise", the half the recording took, and running them by id would
+        // do that half's writes whatever the request. Every other served stop is
+        // the plan's health, which an operator's run is there to try.
+        const decisionAt = flat.entries.findIndex((e) => e.step.stop?.kind === "decision");
+        const stopAt = decisionAt >= 0 && (flat.stopAt === undefined || decisionAt < flat.stopAt)
+            ? clampToFrameStart(flat.entries, decisionAt)
+            : flat.stopAt;
         const plan = new ScenarioReplayPlan({
             scenario,
             params,
             mode,
             entries: flat.entries,
-            stopAt: flat.stopAt,
+            stopAt,
             fallbackTargets: "samples",
         });
         state.plan = plan;
-        state.flatStop = flat.stopReason;
+        state.flatStop = stopAt === flat.stopAt ? flat.stopReason : undefined;
         if (this.opts.authUrl && this.opts.authToken) {
             state.sourceRun = new SourceRunOutputs({
                 baseUrl: this.opts.authUrl,
@@ -2180,6 +2269,15 @@ export class ReplayController {
             }
             const stop = result.stopped;
             const stoppedStep = stop ? plan.allSteps()[stop.flatIndex ?? plan.stepCount] : undefined;
+            // The plan's end in front of its decision: said so, by its own word.
+            const atDecision = stop?.kind === "known_bad_step" && stoppedStep?.stop?.kind === "decision";
+            if (atDecision) {
+                logLine("replay.adhoc_decision", {
+                    scenario: scenario.id,
+                    step: stop.stepIndex,
+                    why: "bir replay stops in front of the plan's decision: the steps after it are the half the recording took",
+                });
+            }
             return {
                 ok: true,
                 text: result.text,
@@ -2191,7 +2289,7 @@ export class ReplayController {
                     ? {
                         step: stop.stepIndex,
                         tool: stoppedStep?.toolName ?? "",
-                        reason: stop.reason ?? stop.stage ?? stop.kind,
+                        reason: atDecision ? "decision" : (stop.reason ?? stop.stage ?? stop.kind),
                         error: stop.error,
                     }
                     : undefined,
@@ -2233,8 +2331,18 @@ export class ReplayController {
         const service = this.deriveService(scenario.id);
         const hasSchema = Object.keys(scenario.paramsObject ?? {}).length > 0;
         state.deriveOnService = !apiKey && service !== undefined && hasSchema;
+        // The day a system prompt told the agent it is — a benchmark's keeps its
+        // agent on 2023-11-30 for ever — and else this machine's (issue 1212).
+        // Never Claude Code's own date reminder: that is this machine's day, and
+        // on a new day's first prompt still yesterday's.
+        const agent = systemDay(ctx.agentDay?.());
+        const today = agent?.day ?? localDay();
+        state.deriveDay = today;
+        state.deriveLine = agent?.line;
         return derive({
             prompt,
+            today,
+            ...(agent?.line ? { todaySaid: agent.line } : {}),
             intent: scenario.intent ?? "",
             paramsObject: scenario.paramsObject,
             apiKey,
@@ -2252,6 +2360,9 @@ export class ReplayController {
         })
             .then((r) => {
             state.deriveCostUsd += r.costUsd;
+            // The day the service read from: a plan on a fixed date reads its own.
+            if (r.dayUsed)
+                state.deriveDay = r.dayUsed;
             logLine("replay.derived", {
                 scenario: scenario.id,
                 params: Object.keys(r.params).length,
@@ -2333,6 +2444,7 @@ export class ReplayController {
                 recordedFallback: this.recordedFallback,
                 deadline,
                 signal,
+                reportTool: this.reportToolFor(state),
             });
         }
         catch (err) {
@@ -2372,7 +2484,16 @@ export class ReplayController {
         // when a step did its work — so the service takes the agent's work after
         // it as that half's evidence. Booked `diverged`, it never did.
         const otherHalf = stop?.kind === "other_branch";
-        this.upgrade(state, broke || !didWork ? "failed" : otherHalf ? "fell_back" : "diverged");
+        // A bundle that ran up to the plan's decision and stopped there (the
+        // service's segmentsbreakdown.md SB-17) is a hand-over too: the plan did
+        // all it was for, and the agent decides. Not one of recorded outputs
+        // only, which is no step done here — that stays a plain divergence.
+        const atDecision = !stop &&
+            plan.stopsEarly() &&
+            composed.endedAt === plan.stepCount &&
+            (composed.executed > 0 || composed.recorded === 0) &&
+            this.stopKindOf(state, plan.stopEntry()) === "decision";
+        this.upgrade(state, broke || !didWork ? "failed" : otherHalf || atDecision ? "fell_back" : "diverged");
         state.stepsPinned += composed.executed;
         // The headline number of this whole design: recovering from a divergence
         // costs nothing, because the proxies were already connected.
@@ -2409,6 +2530,30 @@ export class ReplayController {
                 const note = this.stopNote(state, plan, stop, "none", composed.left);
                 return this.deliverInstead(note, toolName, state.host !== undefined);
             }
+            // Every step left before the decision was one this request does not
+            // need: the plan has done its part, and the agent decides. Told in
+            // place of its call, like the other half. The steps that ran are the
+            // model's own calls above; the ones left out are named.
+            if (atDecision) {
+                const parked = plan.stopStep();
+                state.handover = {
+                    kind: "decision",
+                    stepIndex: callerStepIndexOf(plan.stopEntry()) ?? parked.stepIndex,
+                    toolName: parked.toolName ?? undefined,
+                    note: this.noteFor(state, {
+                        kind: "decision",
+                        step: parked,
+                        entry: plan.stopEntry(),
+                        position: plan.stepCount,
+                        delivery: "above",
+                        executedAbove: plan.currentStepIndex,
+                        leftOut: composed.left,
+                    }),
+                    delivered: true,
+                };
+                this.decidedInDivergence(state, plan);
+                return this.deliverInstead(state.handover.note, toolName, state.host !== undefined);
+            }
             // Every remaining step was left out by its test: the steps the session
             // ran were the whole of the plan this request needs, and it ran to its
             // end (newestRun.md N7 reads that).
@@ -2447,6 +2592,8 @@ export class ReplayController {
                 delivered: true,
             };
             text = `${state.handover.note}\n\n${composed.text}`;
+            if (atDecision)
+                this.decidedInDivergence(state, plan);
         }
         else if (!stop) {
             // The bundle carries the rest of the chain, and its header tells the
@@ -2514,6 +2661,12 @@ export class ReplayController {
             return;
         const ran = state.stepsPinned;
         this.retire(state, ran > 0 ? "fell_back" : "failed");
+        // A plan stopped at its decision did all it was for: its bill ends here,
+        // and the agent's decision and the half it takes are the agent's own
+        // (the service's segmentsbreakdown.md SB-26). Only once a step ran: a
+        // plan that did nothing is a baseline sample of the whole turn.
+        if (h.kind === "decision" && ran > 0)
+            this.markRetired(state);
         state.handover = {
             kind: h.kind,
             // The *caller's* index: a fragment opens at the call row, not at a step
@@ -2540,21 +2693,23 @@ export class ReplayController {
                 ? h.noneNeeded
                     ? "no step of the plan was needed for this request — the agent does the task"
                     : `this request is the other half: the steps from here are only for when ${h.whenText ?? "their test says so"} — the agent continues`
-                : h.kind === "unusable_call"
-                    ? "a sub-task of this chain cannot run — the agent does that part itself"
-                    : h.kind === "known_bad_step"
-                        ? "the next step has failed too often — the agent continues from here"
-                        : h.kind === "nondeterministic_step"
-                            ? "the next step needs a judgement the plan cannot compute — the agent makes it"
-                            : h.stopReason === "concurrent"
-                                ? "a second call arrived while the pinned step was still running — the agent continues from here"
-                                : h.stopReason === "budget" || h.stopReason === "cancelled"
-                                    ? "the run was cut short before this step — the agent continues from here"
-                                    : h.stopReason === "host_rejected" || h.stopReason === "host_edited"
-                                        ? "the host stopped this step itself — no fault of the plan; the agent continues from here"
-                                        : h.stopReason === "not_run" || h.stopReason === "uncertain"
-                                            ? "a step produced no result here — the agent continues from here"
-                                            : "a step broke — the agent continues from here",
+                : h.kind === "decision"
+                    ? "the plan ran the steps before its decision — the agent decides which way applies and continues"
+                    : h.kind === "unusable_call"
+                        ? "a sub-task of this chain cannot run — the agent does that part itself"
+                        : h.kind === "known_bad_step"
+                            ? "the next step has failed too often — the agent continues from here"
+                            : h.kind === "nondeterministic_step"
+                                ? "the next step needs a judgement the plan cannot compute — the agent makes it"
+                                : h.stopReason === "concurrent"
+                                    ? "a second call arrived while the pinned step was still running — the agent continues from here"
+                                    : h.stopReason === "budget" || h.stopReason === "cancelled"
+                                        ? "the run was cut short before this step — the agent continues from here"
+                                        : h.stopReason === "host_rejected" || h.stopReason === "host_edited"
+                                            ? "the host stopped this step itself — no fault of the plan; the agent continues from here"
+                                            : h.stopReason === "not_run" || h.stopReason === "uncertain"
+                                                ? "a step produced no result here — the agent continues from here"
+                                                : "a step broke — the agent continues from here",
         });
     }
     /**
@@ -2564,10 +2719,32 @@ export class ReplayController {
      * step.
      */
     stopKindOf(state, entry) {
+        // The service serves a decision ahead of any other stop of its step
+        // (the service's segmentsbreakdown.md SB-6), and so it is read first.
+        if (entry?.step.stop?.kind === "decision")
+            return "decision";
         if (entry?.step.stop?.kind === "nondeterministic")
             return "nondeterministic_step";
         return state.flatStop ? "unusable_call" : "known_bad_step";
     }
+    /**
+     * A divergence's bundle that ended at the plan's decision (SB-17): logged
+     * as `handOver` logs every other hand-over, and its usage mark taken there
+     * when a step of the plan ran (SB-26).
+     */
+    decidedInDivergence(state, plan) {
+        if (state.stepsPinned > 0)
+            this.markRetired(state);
+        logLine("replay.handover", {
+            scenario: state.scenarioId ?? undefined,
+            kind: "decision",
+            step: `${plan.stepCount}/${plan.totalSteps}`,
+            via: "divergence",
+            ran: state.stepsPinned,
+            outcome: state.outcome,
+            why: "the plan ran the steps before its decision — the agent decides which way applies and continues",
+        });
+    }
     /**
      * The steps before flat position `bound` that ran, 1-based, and the ones
      * their tests left out (AC5) — the plan cursor's own, and a divergence
@@ -2608,15 +2785,21 @@ export class ReplayController {
             h.stopReason === "host_rejected" ||
             h.stopReason === "host_edited" ||
             h.stopReason === "result_map";
+        // A chain that holds a decision (the service's segmentsbreakdown.md SB-18)
+        // keeps the decision note's protections in every note, even when the plan
+        // stops earlier for another reason: no intent, no parameters, and no step
+        // from the decision on. Each points at the half the recording took, and an
+        // agent that follows it there runs that half's segment: the plan decided.
+        const decisionAt = plan ? plan.decisionIndex() : -1;
         let params;
         try {
-            params = plan?.parameters;
+            params = decisionAt >= 0 ? undefined : plan?.parameters;
         }
         catch {
             params = undefined;
         }
         return buildHandoverNote({
-            intent: plan?.intent ?? "",
+            intent: decisionAt >= 0 ? "" : (plan?.intent ?? ""),
             kind: h.kind,
             stepIndex: h.position,
             stepToolName: h.step?.toolName ?? undefined,
@@ -2651,13 +2834,17 @@ export class ReplayController {
             totalSteps: plan?.totalSteps ?? state.stepsPlanned,
             // A step that runs only under a test is marked so: the list must not
             // read as steps this request needs (AC5).
-            remainingTools: plan ? plan.remainingFrom(handled ? h.position + 1 : h.position) : [],
+            remainingTools: plan
+                ? plan.remainingFrom(handled ? h.position + 1 : h.position, decisionAt >= 0 ? decisionAt : undefined)
+                : [],
             params,
             delivery: h.delivery,
             whenText: h.whenText ?? null,
             subTask: h.subTask ?? null,
             // "None was needed" is the note's own wording for the end of the plan.
             ...(h.noneNeeded ? { stepIndex: plan?.totalSteps ?? state.stepsPlanned } : {}),
+            // The request's own words for the choice (SB-18); never the service's.
+            ...(h.kind === "decision" ? { request: state.request ?? null } : {}),
         });
     }
     /**
@@ -2768,6 +2955,21 @@ export class ReplayController {
         }
         return serializeCapped(redact(result));
     }
+    /**
+     * The report tool a bundle may name, when this plan's session has it
+     * ({@link ReplayState.reportTool}); undefined leaves the bundle's words as
+     * they always were. Never for another host: its adapter reads no bundle.
+     */
+    reportToolFor(state) {
+        if (state.host || !state.reportTool)
+            return undefined;
+        try {
+            return state.reportTool() ? REPORT_TOOL_NAME : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
     /** Where recorded outputs come from, when they may stand in at all. */
     recordedSource(state, force = false) {
         if (!force && !this.recordedFallback)
@@ -2801,6 +3003,37 @@ export class ReplayController {
             // carries the verdict, so the recording page says why it never runs.
             blame: true,
         });
+        // The agent's own day may show only now (issue 1212): its host writes a
+        // system prompt's "Today's date is …" just after the prompt hook. Values
+        // read for another day are read again, before the first step runs.
+        if (!opts.adHoc && state.rederive && state.agentDayNow && plan.currentStepIndex === 0) {
+            const now = systemDay(state.agentDayNow());
+            // A new line, unless it says the very day the values were read for. A
+            // line with the day in words is read by the service.
+            if (now && now.line !== state.deriveLine && (now.day === undefined || now.day !== state.deriveDay)) {
+                logLine("replay.rederive", {
+                    scenario: state.scenarioId ?? undefined,
+                    from: state.deriveDay,
+                    to: now.day ?? "said in words",
+                });
+                state.deriveLine = now.line;
+                if (now.day)
+                    state.deriveDay = now.day;
+                const targets = targetKeys(plan.paramsSchema);
+                // A reading that did not answer names no target, as at the prompt
+                // (gate 7): never the recorded person or date in its place.
+                const again = state.rederive(now).then((r) => {
+                    if (r.derived)
+                        return r;
+                    const params = { ...r.params };
+                    for (const key of targets)
+                        params[key] = null;
+                    return { ...r, params, missing: [...targets] };
+                });
+                again.then((r) => (state.rederivedMissing = r.missing), () => (state.rederivedMissing = [...targets]));
+                plan.resetParams(again.then((r) => r.params));
+            }
+        }
         if (!plan.parametersSettled) {
             let failure;
             const settled = plan.ready().then(() => true, (err) => {
@@ -2839,6 +3072,21 @@ export class ReplayController {
                 }
             }
         }
+        // The second reading left a value unnamed that this plan would act on.
+        const missingAgain = state.rederivedMissing;
+        state.rederivedMissing = undefined;
+        if (missingAgain && !opts.adHoc) {
+            const planned = plan.allEntries().slice(0, plan.stepCount);
+            const blocked = blockingTargets(missingAgain, plan.paramsSchema, planned, plan.paramsLogic);
+            if (blocked.length > 0) {
+                return {
+                    ok: false,
+                    error: `the value of ${blocked[0]} could not be read from this request for ${state.deriveDay}`,
+                    stage: "derive_params",
+                    blame: false,
+                };
+            }
+        }
         const sink = opts.adHoc
             ? undefined
             : sinkOfPlan(plan.allEntries().slice(0, plan.stepCount), state.host?.sinks);
@@ -3103,17 +3351,10 @@ export class ReplayController {
             this.upgrade(state, outcome);
         // Only a plan that *finished* stops the clock (segmented.md R-MONEY-3). A
         // hand-over or a divergence takes no mark: the agent's next tokens are the
-        // consequence of this plan stopping, and belong to its bill.
-        if (completing) {
-            state.retiredAt = Date.now();
-            try {
-                state.retiredMark = state.markUsage?.();
-            }
-            catch {
-                // An unreadable transcript leaves the mark undefined, and the window
-                // falls back to the next arm or the end of the turn.
-            }
-        }
+        // consequence of this plan stopping, and belong to its bill. (A decision
+        // hand-over takes one of its own: `markRetired`.)
+        if (completing)
+            this.markRetired(state);
         state.retired = true;
         state.pinned.clear();
         // A note naming a step to call next is void once the plan is: after a
@@ -3125,6 +3366,21 @@ export class ReplayController {
         // A call waiting for a pin to thread has nothing left to wait for.
         this.notifyPins(state);
     }
+    /**
+     * Where the plan's work ended, for its bill: now, and the transcript's
+     * watermark now. Taken at a completing retire, and at a decision hand-over
+     * after a step ran (the service's segmentsbreakdown.md SB-26).
+     */
+    markRetired(state) {
+        state.retiredAt = Date.now();
+        try {
+            state.retiredMark = state.markUsage?.();
+        }
+        catch {
+            // An unreadable transcript leaves the mark undefined, and the window
+            // falls back to the next arm or the end of the turn.
+        }
+    }
 }
 /** Every target of a schema. A parameter with no kind is one (R-PARAM-3). */
 function targetKeys(schema) {