@basein/runner 0.2.7 → 0.2.10

package/dist/control/server.d.ts

@@ -53,6 +53,14 @@ export interface ControlServerOptions {
     cwd: string;
     /** Preferred port; 0 (or a busy port) falls back to an ephemeral one. */
     port?: number;
+    /**
+     * Whether a busy `port` may fall back to an ephemeral one. Default true — a
+     * recorder in a terminal is better on some port than not at all. A background
+     * recorder whose port is written into a project's hooks passes false: on a
+     * fallback port it would answer SessionStart and then every other hook would
+     * post into the void, which is worse than exiting with a reason.
+     */
+    portFallback?: boolean;
     /** Loopback bearer token. Generated when omitted. */
     token?: string;
     /** Config keys of the servers a proxy wraps. Grows as proxies register. */
@@ -90,6 +98,26 @@ export interface ControlServerOptions {
      * recording and nothing else happens.
      */
     replay?: ReplayOptions;
+    /**
+     * Where the replay switches came from — the environment, the project's
+     * stored policy, or the defaults. Reported on `/health` so `bir doctor` can
+     * say which, because "the allow-list I set is gone" has exactly one cause.
+     */
+    replaySource?: "env" | "sidecar" | "default";
+    /**
+     * Whose account the recordings land in, for `/health` and `bir doctor`. "The
+     * run is not in Recordings" is, more often than not, "it is in somebody
+     * else's", and nothing said which until now.
+     */
+    account?: string;
+    /**
+     * What 'POST /control/stop' does after answering. 'bir-hooks' passes its own
+     * shutdown; a test passes nothing and the route merely says it would. The
+     * route exists so a background recorder can be stopped the way Ctrl-C stops
+     * one in a terminal — finishing the run and draining the queue — rather than
+     * killed, which on Windows is the only other option.
+     */
+    onStopRequested?: () => void;
 }
 export interface ControlServerAddress {
     url: string;

package/dist/control/server.js

@@ -38,6 +38,7 @@ import { calculateCostUsd } from "../replay/pricing.js";
 import { logDetail, logLine, errText } from "../util/log.js";
 import { journal } from "../util/journal.js";
 import { packageVersion } from "../util/version.js";
+import { resolveAuthUrl } from "../auth/client.js";
 /** How long a `/tool/post` waits for the proxy's own report before recording its own view. */
 const PROXY_REPORT_GRACE_MS = 1_500;
 /** One MCP call, as seen from up to two sides. */
@@ -127,7 +128,7 @@ export class ControlServer {
                     resolve(this.address);
                 });
             };
-            bind(preferred, preferred !== 0);
+            bind(preferred, preferred !== 0 && this.opts.portFallback !== false);
         });
     }
     async close() {
@@ -150,6 +151,10 @@ export class ControlServer {
         const sessions = [...this.sessions.values()].map((s) => ({
             sessionId: s.sessionId,
             runId: s.run?.runId,
+            // Mid-run right now. What 'ensureDaemon' reads before it dares to restart
+            // an out-of-date recorder: a restart between turns costs nothing, one
+            // during a turn loses the turn.
+            active: Boolean(s.run) && !s.run.finished,
             steps: s.run?.ordering.next ?? 0,
             recording: s.run?.recording ?? false,
             replay: s.run?.replay
@@ -187,12 +192,13 @@ export class ControlServer {
             tier: "bound",
             // The authoritative answer to "is anything actually being saved?".
             recording: this.opts.recording ?? !(this.recorder instanceof NullRecorder),
+            account: this.opts.account ?? null,
             // Whether a handed-out segment may actually run mid-task, or whether the
             // runner is only watching (R-OUT-10, R-LIFE-8). Observe-only must never
             // be invisible: an operator has to be able to see which of the two this
             // machine is doing without reading a log file.
             segmentArm: this.replay.segmentArm,
-            authUrl: process.env.BIR_AUTH_URL ?? null,
+            authUrl: resolveAuthUrl() || null,
             sessionId: this.sessionId,
             pid: process.pid,
             cwd: this.opts.cwd,
@@ -210,6 +216,7 @@ export class ControlServer {
             // (docs/calculatedReplay.md §13.2, mitigation 3).
             replay: {
                 enabled: this.replay.enabled,
+                source: this.opts.replaySource ?? null,
                 minSimilarity: this.opts.replay?.minSimilarity ?? null,
                 allowServers: this.opts.replay?.allowServers ? [...this.opts.replay.allowServers] : null,
                 deriveKey: Boolean(this.opts.replay?.apiKey ?? process.env.ANTHROPIC_API_KEY),
@@ -248,6 +255,12 @@ export class ControlServer {
             }
             const body = await this.readJson(req);
             switch (route) {
+                case "/control/stop":
+                    // Answer first, then leave: the caller is polling for the pid to go.
+                    this.send(res, 200, { ok: Boolean(this.opts.onStopRequested) });
+                    if (this.opts.onStopRequested)
+                        setImmediate(() => this.opts.onStopRequested?.());
+                    return;
                 case "/session/start":
                     this.send(res, 200, this.onSessionStart(body));
                     return;
@@ -944,11 +957,14 @@ export class ControlServer {
                 continue;
             let position;
             if (!state.plan) {
-                // Only a known-bad first step means the turn is committed to doing this
-                // recording's work itself from position 0 (R-HIT-14); every other
-                // decline leaves the recording untouched.
-                if (state.declined === "known_bad_first_step")
+                // Only a first step the plan cannot start on — parked, or a judgement
+                // — means the turn is committed to doing this recording's work itself
+                // from position 0 (R-HIT-14); every other decline leaves the recording
+                // untouched.
+                if (state.declined === "known_bad_first_step" ||
+                    state.declined === "nondeterministic_first_step") {
                     position = 0;
+                }
             }
             else if (state.handover) {
                 position = state.handover.stepIndex;

package/dist/proxy/session.d.ts

@@ -25,7 +25,14 @@ import type { UpstreamClient } from "../upstream/client.js";
 import type { ProxyStepReport } from "../control/correlation.js";
 import { type Recorder } from "../record/recorder.js";
 /** How long a proxy waits for a control server before falling to Tier 2. */
-export declare const DISCOVERY_WINDOW_MS = 5000;
+/**
+ * Ten seconds, not five: the recorder is now started by the SessionStart hook,
+ * which fires while the host is also spawning this proxy, and a cold start
+ * (sign-in refresh, the service's /health probe, then listen) has been
+ * measured at one to four seconds. Steps are buffered meanwhile, never
+ * dropped, and a host session is never waiting on this.
+ */
+export declare const DISCOVERY_WINDOW_MS = 10000;
 export type Tier = "bound" | "standalone" | "pending";
 export interface ProxySessionOptions {
     serverName: string;

package/dist/proxy/session.js

@@ -26,7 +26,7 @@ import { hostname } from "node:os";
 import { ControlClient } from "../control/client.js";
 import { resolveControl } from "../control/discovery.js";
 import { qualifyToolName } from "../control/correlation.js";
-import { authenticate } from "../auth/client.js";
+import { authenticate, resolveAuthUrl } from "../auth/client.js";
 import { NullRecorder } from "../record/recorder.js";
 import { RemoteRecorder } from "../record/remote-recorder.js";
 import { StepQueue } from "../record/queue.js";
@@ -36,7 +36,14 @@ import { redact } from "../record/redact.js";
 import { logLine, logDetail, errText } from "../util/log.js";
 import { packageVersion } from "../util/version.js";
 /** How long a proxy waits for a control server before falling to Tier 2. */
-export const DISCOVERY_WINDOW_MS = 5_000;
+/**
+ * Ten seconds, not five: the recorder is now started by the SessionStart hook,
+ * which fires while the host is also spawning this proxy, and a cold start
+ * (sign-in refresh, the service's /health probe, then listen) has been
+ * measured at one to four seconds. Steps are buffered meanwhile, never
+ * dropped, and a host session is never waiting on this.
+ */
+export const DISCOVERY_WINDOW_MS = 10_000;
 export class ProxySession {
     serverName;
     /** This proxy process, as the control server tells proxies apart (replay/executor.ts). */
@@ -98,6 +105,7 @@ export class ProxySession {
             return;
         }
         const window = this.opts.discoveryWindowMs ?? DISCOVERY_WINDOW_MS;
+        const deadline = Date.now() + window;
         const found = await resolveControl(this.opts.cwd, window);
         if (!found?.url) {
             await this.becomeStandalone(`no control server within ${window}ms`);
@@ -108,12 +116,24 @@ export class ProxySession {
             startedAt: this.startedAt,
             pid: process.pid,
         });
-        const registered = await client.register({
+        const info = {
             serverName: this.serverName,
             pid: process.pid,
             cwd: this.opts.cwd,
             version: packageVersion(),
-        });
+        };
+        // A control server that is still coming up — the SessionStart hook is
+        // starting it while the host spawns us — answers nothing for a moment.
+        // Keep trying inside the same window rather than settle for Tier 2 on the
+        // first refusal.
+        let registered = await client.register(info);
+        while (!registered && Date.now() < deadline) {
+            await new Promise((resolve) => {
+                const t = setTimeout(resolve, 250);
+                t.unref?.();
+            });
+            registered = await client.register(info);
+        }
         if (!registered) {
             await this.becomeStandalone("control server did not answer /proxy/register");
             return;
@@ -216,9 +236,11 @@ export class ProxySession {
         if (this.opts.recorderFactory) {
             return (await this.opts.recorderFactory()) ?? new NullRecorder();
         }
-        const baseUrl = (process.env.BIR_AUTH_URL ?? "").replace(/\/+$/, "");
+        // BIR_AUTH_URL, or the address 'bir setup' stored — the same lookup the
+        // control server and the CLI make, so no two processes disagree about it.
+        const baseUrl = resolveAuthUrl();
         if (!baseUrl) {
-            logLine("recorder.disabled", { why: "BIR_AUTH_URL is not set" });
+            logLine("recorder.disabled", { why: "no service address — run 'bir setup', or set BIR_AUTH_URL" });
             return new NullRecorder();
         }
         // A proxy runs inside the host's process tree with its stdio bound to the

package/dist/replay/controller.d.ts

@@ -219,7 +219,7 @@ export interface ReplayState {
  * Why a match did not arm. One code per gate of the ladder, so the caller can
  * act on a decline without parsing the sentence that explains it.
  */
-export type DeclineCode = "replay_disabled" | "not_ready" | "flatten_failed" | "similarity" | "known_bad_first_step" | "unusable_first_step" | "coverage" | "missing_target" | "no_derive_key";
+export type DeclineCode = "replay_disabled" | "not_ready" | "flatten_failed" | "similarity" | "known_bad_first_step" | "nondeterministic_first_step" | "unusable_first_step" | "coverage" | "missing_target" | "no_derive_key";
 /** What `PreToolUse` should do about this call. */
 export type PreToolAction = 
 /** Pin the arguments and let the real tool run. */
@@ -417,6 +417,13 @@ export declare class ReplayController {
      * scenario that did nothing has nothing to book, and is a baseline sample.
      */
     private handOver;
+    /**
+     * Which kind of stop a plan's end is (plan-services.md D8). The stopping
+     * step's own served reason wins — the calculation's verdict is more exact
+     * than a counter — then a call the service could not answer, then a parked
+     * step.
+     */
+    private stopKindOf;
     private noteFor;
     /**
      * The executor handed to a plan: dispatch a step to the proxy that owns its
@@ -476,6 +483,22 @@ export interface RunMatchLike {
     /** The frozen name, beside the runtime intent the plan runs on (R-INTENT-12). */
     intentName?: string;
 }
+/**
+ * The old rule, for a service that sends no `stop`: the position of the first
+ * step whose failure count is above `maxStepFailures` (fallbk.md D3), or
+ * undefined when none is — including when the service sent no policy, which an
+ * older service never does.
+ */
 export declare function knownBadStepIndex(steps: readonly SerializedScenarioStep[], maxStepFailures: number | undefined): number | undefined;
+/**
+ * Position of the first step the plan must stop in front of (plan-services.md
+ * D8), or undefined when there is none.
+ *
+ * A step that carries `stop` was decided by the service — `null` means run it,
+ * even when its count is past the limit: its retry is due. A step without the
+ * field came from an older service, and the old counter rule decides it. Both
+ * can sit in one chain, since a called segment is served on its own terms.
+ */
+export declare function stopIndex(steps: readonly SerializedScenarioStep[], maxStepFailures: number | undefined): number | undefined;
 export {};
 //# sourceMappingURL=controller.d.ts.map

package/dist/replay/controller.js

@@ -204,20 +204,31 @@ export class ReplayController {
         const entries = flat.entries;
         if (entries.length === 0)
             return decline("the chain has no runnable step", "not_ready");
-        // Gate 5 — known-bad steps (fallbk.md D3). The plan ends in front of the
-        // first step the service has seen fail more than its limit — the counter on
-        // whichever scenario owns that step (R-CALL-30). A call the service could
-        // not answer stops the plan the same way, and the earlier of the two wins.
-        const badAt = knownBadStepIndex(entries.map((e) => e.step), match.fallback?.maxStepFailures);
+        // Gate 5 — steps the plan must stop in front of (fallbk.md D3,
+        // plan-services.md D8): a step the service parked — failed more than its
+        // limit, retry not due — or one the calculation marked non-deterministic,
+        // on whichever scenario owns it (R-CALL-30). A call the service could not
+        // answer stops the plan the same way, and the earliest of them wins.
+        const badAt = stopIndex(entries.map((e) => e.step), match.fallback?.maxStepFailures);
         const rawStop = [flat.stopAt, badAt].filter((n) => typeof n === "number");
         // Clamped to the start of the outermost called frame it falls in: a plan
         // never runs half a sub-task and leaves its result mapping unevaluated.
         const stopAt = rawStop.length > 0 ? clampToFrameStart(entries, Math.min(...rawStop)) : undefined;
         if (stopAt === 0) {
-            const why = flat.stopAt === 0 && flat.stopReason
-                ? `its first step is a call that cannot run: ${flat.stopReason.reason}`
-                : `its first step has failed ${entries[0].step.failureCount ?? 0} times — the agent does this task`;
-            return decline(why, flat.stopAt === 0 && flat.stopReason ? "unusable_first_step" : "known_bad_first_step");
+            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";
+            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`;
+            return decline(why, unusable
+                ? "unusable_first_step"
+                : judgement
+                    ? "nondeterministic_first_step"
+                    : "known_bad_first_step");
         }
         const planned = stopAt === undefined ? entries : entries.slice(0, stopAt);
         // Gate 6 — tool coverage, over the steps that will actually run.
@@ -333,6 +344,8 @@ export class ReplayController {
             // What this chain calls, and what answers each call right now (R-CALL-32).
             calls: callLines(scenario),
             unusable: flat.stopReason?.reason,
+            // Which steps the service told this plan to stop in front of, and why.
+            stops: stopLines(entries),
             coverage: coverageOf(entries.map((e) => e.step), wrapped, this.opts.allowServers).join(","),
             tools: entries.map((e) => e.step.toolName ?? "").join(","),
         });
@@ -562,7 +575,7 @@ export class ReplayController {
             // is a call the service could not answer (segmented.md R-CALL-29).
             const parked = plan.stopStep();
             this.handOver(state, {
-                kind: state.flatStop ? "unusable_call" : "known_bad_step",
+                kind: this.stopKindOf(state, plan.stopEntry()),
                 step: parked,
                 entry: plan.stopEntry(),
                 position: plan.stepCount,
@@ -639,7 +652,10 @@ export class ReplayController {
             const position = stop.flatIndex ?? plan.stepCount;
             const step = plan.allSteps()[position];
             this.handOver(state, {
-                kind: stop.kind,
+                // The plan only knows it stopped in front of its end; which kind of
+                // stop that is — parked, a judgement, a call that cannot run — is
+                // decided here, where the served reasons are.
+                kind: stop.kind === "known_bad_step" ? this.stopKindOf(state, plan.stopEntry()) : stop.kind,
                 step,
                 entry: plan.allEntries()[position],
                 position,
@@ -1070,7 +1086,7 @@ export class ReplayController {
         let text = composed.text;
         if (plan.stopsEarly()) {
             const parked = plan.stopStep();
-            const stopKind = state.flatStop ? "unusable_call" : "known_bad_step";
+            const stopKind = this.stopKindOf(state, plan.stopEntry());
             state.handover = {
                 kind: stopKind,
                 stepIndex: parked.stepIndex,
@@ -1132,9 +1148,22 @@ export class ReplayController {
                 ? "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"
-                    : "a step broke — the agent continues from here",
+                    : h.kind === "nondeterministic_step"
+                        ? "the next step needs a judgement the plan cannot compute — the agent makes it"
+                        : "a step broke — the agent continues from here",
         });
     }
+    /**
+     * Which kind of stop a plan's end is (plan-services.md D8). The stopping
+     * step's own served reason wins — the calculation's verdict is more exact
+     * than a counter — then a call the service could not answer, then a parked
+     * step.
+     */
+    stopKindOf(state, entry) {
+        if (entry?.step.stop?.kind === "nondeterministic")
+            return "nondeterministic_step";
+        return state.flatStop ? "unusable_call" : "known_bad_step";
+    }
     noteFor(state, h) {
         const plan = state.plan;
         const executed = h.ranThisStep ? h.position + 1 : h.position;
@@ -1243,6 +1272,9 @@ export class ReplayController {
             stage: info.stage ?? (status === "skipped" ? "tool_call" : undefined),
             error,
             durationMs: info.ms,
+            // The tool is gone from its server: the service repairs the plan without
+            // waiting out the grace (plan-services.md D8, kind 2).
+            toolMissing: info.toolMissing || undefined,
             // A verdict about a called segment's step is counted on that segment, at
             // the revision it was served (R-CALL-13).
             scenarioId: info.entry && info.entry.depth > 0 ? info.entry.scenarioId : undefined,
@@ -1340,11 +1372,6 @@ function targetKeys(schema) {
         return [];
     return Object.keys(schema).filter((k) => schema[k]?.kind !== "setting");
 }
-/**
- * Position of the first step whose failure count is above `maxStepFailures`
- * (fallbk.md D3), or undefined when none is — including when the service sent
- * no policy, which an older service never does.
- */
 /**
  * The index a hand-over reports, in the *caller's* chain (R-CALL-32).
  *
@@ -1369,10 +1396,39 @@ function callLines(scenario) {
         .map((s) => `${s.segmentId ?? "-"}:${s.unusable ?? s.resolution?.state ?? "resolved"}`)
         .join(",");
 }
+/** The served stops in a flat chain, for the `plan.armed` line (plan-services.md D8). */
+function stopLines(entries) {
+    const lines = entries
+        .map((e, i) => e.step.stop ? `${i}:${e.step.stop.kind}${e.step.stop.repairDue ? "/repair" : ""}` : undefined)
+        .filter((s) => s !== undefined);
+    return lines.length > 0 ? lines.join(",") : undefined;
+}
+/**
+ * The old rule, for a service that sends no `stop`: the position of the first
+ * step whose failure count is above `maxStepFailures` (fallbk.md D3), or
+ * undefined when none is — including when the service sent no policy, which an
+ * older service never does.
+ */
 export function knownBadStepIndex(steps, maxStepFailures) {
+    const i = steps.findIndex((s) => isKnownBad(s, maxStepFailures));
+    return i < 0 ? undefined : i;
+}
+function isKnownBad(step, maxStepFailures) {
     if (typeof maxStepFailures !== "number" || !Number.isFinite(maxStepFailures))
-        return undefined;
-    const i = steps.findIndex((s) => (s.failureCount ?? 0) > maxStepFailures);
+        return false;
+    return (step.failureCount ?? 0) > maxStepFailures;
+}
+/**
+ * Position of the first step the plan must stop in front of (plan-services.md
+ * D8), or undefined when there is none.
+ *
+ * A step that carries `stop` was decided by the service — `null` means run it,
+ * even when its count is past the limit: its retry is due. A step without the
+ * field came from an older service, and the old counter rule decides it. Both
+ * can sit in one chain, since a called segment is served on its own terms.
+ */
+export function stopIndex(steps, maxStepFailures) {
+    const i = steps.findIndex((s) => s.stop !== undefined ? s.stop !== null : isKnownBad(s, maxStepFailures));
     return i < 0 ? undefined : i;
 }
 //# sourceMappingURL=controller.js.map

package/dist/replay/handover.js

@@ -60,6 +60,11 @@ export function buildHandoverNote(n) {
             : "";
         lines.push(`Step ${human} of ${n.totalSteps}${tool.replace(/\)$/, `${owner})`)} did not run: it has failed${times} before, so the scenario stops in front of it.`);
     }
+    else if (n.kind === "nondeterministic_step") {
+        // The calculation could not write code for this step's input: it is a
+        // judgement, and the agent is the one to make it (plan-services.md D8).
+        lines.push(`Step ${human} of ${n.totalSteps}${tool} did not run: its input needs a judgement the scenario cannot compute. Make that choice yourself and carry on.`);
+    }
     else {
         const error = n.error ? `: ${truncate(n.error, MAX_ERROR_CHARS)}` : "";
         lines.push(`Step ${human} of ${n.totalSteps}${tool} failed${error}`);

package/dist/replay/plan.d.ts

@@ -65,6 +65,8 @@ export interface StepInfo {
     error?: string;
     derivedKeys?: string[];
     ms: number;
+    /** The tool is gone from its server, read from the error (plan-services.md D8). */
+    toolMissing?: boolean;
 }
 export type StepObserver = (info: StepInfo) => void;
 export interface ComposeResult {

package/dist/replay/plan.js

@@ -23,7 +23,7 @@
 import { evalParamMapLogic, evalParamsLogic, evalResponseParamsLogic, evalResultMapLogic, evalToolInputLogic, evalToolOutputLogic, } from "./logic.js";
 import { flatEntriesOf } from "./flatten.js";
 import { assembleBundle, bundleInput, MAX_REPLAY_REASON } from "./bundle.js";
-import { toolResultError } from "./tool-error.js";
+import { isMissingToolError, toolResultError } from "./tool-error.js";
 /**
  * The recorded values for the *settings* a mapping did not name (R-CALL-21).
  *
@@ -433,13 +433,29 @@ export class ScenarioReplayPlan {
                     : undefined) ?? (await recordedOutputFor?.(entry).catch(() => undefined));
                 if (!fallback) {
                     skipped += 1;
-                    onStep?.({ step, entry, input: computed, outcome: "skipped", error, ms: Date.now() - startedAt });
+                    onStep?.({
+                        step,
+                        entry,
+                        input: computed,
+                        outcome: "skipped",
+                        error,
+                        toolMissing: isMissingToolError(error) || undefined,
+                        ms: Date.now() - startedAt,
+                    });
                     continue;
                 }
                 response = fallback;
                 recorded = true;
                 recordedCount += 1;
-                onStep?.({ step, entry, input: computed, outcome: "recorded", error, ms: Date.now() - startedAt });
+                onStep?.({
+                    step,
+                    entry,
+                    input: computed,
+                    outcome: "recorded",
+                    error,
+                    toolMissing: isMissingToolError(error) || undefined,
+                    ms: Date.now() - startedAt,
+                });
             }
             // Thread the output for later steps' inputs. A recorded output threads
             // too: `toolOutputLogic` was authored against exactly this shape, and a
@@ -465,6 +481,7 @@ export class ScenarioReplayPlan {
                     outcome: error ? "failed" : "executed",
                     stage: error ? "tool_call" : undefined,
                     error,
+                    toolMissing: isMissingToolError(error) || undefined,
                     derivedKeys,
                     ms: Date.now() - startedAt,
                 });
@@ -518,6 +535,9 @@ export class ScenarioReplayPlan {
             }
             const entry = this.entries[this.stepIndex];
             const step = entry.step;
+            // Where this step sits in the flat list — what a stop reports. Taken now,
+            // because the cursor has moved on by the time some stops are written.
+            const flatIndex = this.stepIndex;
             const startedAt = Date.now();
             let computed;
             try {
@@ -529,6 +549,7 @@ export class ScenarioReplayPlan {
                 stopped = {
                     kind: "step_failed",
                     stepIndex: step.stepIndex,
+                    flatIndex,
                     stage: "tool_input_logic",
                     error: errText(err),
                 };
@@ -547,7 +568,15 @@ export class ScenarioReplayPlan {
                     : undefined) ?? (await recordedOutputFor?.(entry).catch(() => undefined));
                 if (!fallback) {
                     skipped += 1;
-                    onStep?.({ step, entry, input: computed, outcome: "skipped", error, ms: Date.now() - startedAt });
+                    onStep?.({
+                        step,
+                        entry,
+                        input: computed,
+                        outcome: "skipped",
+                        error,
+                        toolMissing: isMissingToolError(error) || undefined,
+                        ms: Date.now() - startedAt,
+                    });
                     // Advance past a step that cannot run, without threading anything.
                     // The frame is still left behind it: a sub-task whose last step could
                     // not run here still hands back whatever its earlier steps emitted.
@@ -558,7 +587,15 @@ export class ScenarioReplayPlan {
                 response = fallback;
                 recorded = true;
                 recordedCount += 1;
-                onStep?.({ step, entry, input: computed, outcome: "recorded", error, ms: Date.now() - startedAt });
+                onStep?.({
+                    step,
+                    entry,
+                    input: computed,
+                    outcome: "recorded",
+                    error,
+                    toolMissing: isMissingToolError(error) || undefined,
+                    ms: Date.now() - startedAt,
+                });
             }
             if (stopOnFailure && !recorded) {
                 // Judged before the output logic, which was written against a success
@@ -573,6 +610,7 @@ export class ScenarioReplayPlan {
                         outcome: "failed",
                         stage: "tool_call",
                         error: toolError,
+                        toolMissing: isMissingToolError(toolError) || undefined,
                         ms: Date.now() - startedAt,
                     });
                     entries.push({
@@ -585,6 +623,7 @@ export class ScenarioReplayPlan {
                     stopped = {
                         kind: "step_failed",
                         stepIndex: step.stepIndex,
+                        flatIndex,
                         stage: "tool_call",
                         error: toolError,
                     };
@@ -608,6 +647,7 @@ export class ScenarioReplayPlan {
                 stopped = {
                     kind: "step_failed",
                     stepIndex: step.stepIndex,
+                    flatIndex,
                     stage: "tool_output_logic",
                     error: errText(err),
                 };
@@ -627,6 +667,7 @@ export class ScenarioReplayPlan {
                     outcome: error ? "failed" : "executed",
                     stage: error ? "tool_call" : undefined,
                     error,
+                    toolMissing: isMissingToolError(error) || undefined,
                     derivedKeys,
                     ms: Date.now() - startedAt,
                 });
@@ -640,7 +681,13 @@ export class ScenarioReplayPlan {
         }
         // Every planned step ran and the plan ends in front of a parked one.
         if (!stopped && !partial && this.stopsEarly() && this.isDone()) {
-            stopped = { kind: "known_bad_step", stepIndex: this.entries[this.stopAt].stepIndex };
+            // `known_bad_step` here means "in front of the plan's end": the
+            // controller reads the served reason and names the kind (D8).
+            stopped = {
+                kind: "known_bad_step",
+                stepIndex: this.entries[this.stopAt].stepIndex,
+                flatIndex: this.stopAt,
+            };
         }
         return {
             text: assembleBundle(entries, maxChars, {

package/dist/replay/pricing.d.ts

@@ -17,7 +17,7 @@
  * Bump the version — on **every** side — whenever a row changes.
  */
 /** Identifies {@link MODEL_PRICING}. Must equal the service's constant. */
-export declare const PRICING_VERSION = "2026-08-30";
+export declare const PRICING_VERSION = "2026-09-24";
 /**
  * Tolerate provider prefixes (`anthropic/`, `us.anthropic.`), date snapshots and
  * unseen version bumps by falling back to the longest matching family, so a new

package/dist/replay/pricing.js

@@ -17,24 +17,32 @@
  * Bump the version — on **every** side — whenever a row changes.
  */
 /** Identifies {@link MODEL_PRICING}. Must equal the service's constant. */
-export const PRICING_VERSION = "2026-08-30";
-/** Cache reads bill at 0.1x input; a 5-minute cache write at 1.25x. */
-const priced = (input, output) => ({
+export const PRICING_VERSION = "2026-09-24";
+/**
+ * A 5-minute cache write bills at 1.25x input. Cache reads bill at 0.1x input,
+ * except on models whose list price says otherwise (Opus 5.5, Fable 5.1), which
+ * pass their read price in dollars.
+ */
+const priced = (input, output, cacheRead = input * 0.1) => ({
     input,
     output,
-    cacheRead: input * 0.1,
+    cacheRead,
     cacheWrite: input * 1.25,
 });
 const MODEL_PRICING = {
     "claude-haiku-4-5": priced(1.0, 5.0),
     "claude-haiku-4-5-20251001": priced(1.0, 5.0),
+    "claude-sonnet-4-5": priced(3.0, 15.0),
     "claude-sonnet-4-6": priced(3.0, 15.0),
     "claude-sonnet-5": priced(2.0, 10.0),
+    "claude-opus-4-5": priced(5.0, 25.0),
     "claude-opus-4-6": priced(5.0, 25.0),
     "claude-opus-4-7": priced(5.0, 25.0),
     "claude-opus-4-8": priced(5.0, 25.0),
     "claude-opus-5": priced(5.0, 25.0),
+    "claude-opus-5-5": priced(4.0, 20.0, 0.2),
     "claude-fable-5": priced(10.0, 50.0),
+    "claude-fable-5-1": priced(10.0, 50.0, 0.25),
 };
 /**
  * Tolerate provider prefixes (`anthropic/`, `us.anthropic.`), date snapshots and