@basein/runner 0.3.27 → 0.3.28

package/dist/control/transcript.js

@@ -126,7 +126,8 @@ const indexes = new Map();
  * ({@link subagentUsage}): transcript path → the main index they were read
  * beside, one usage-only index per file, and `gone`: what the files whose
  * index was let go of had used (one past {@link MAX_SUBAGENT_FILES}, one read
- * again from its start after a rewrite). Dropped with the main index.
+ * again from its start after a rewrite), and `goneCalls`: their model calls.
+ * Dropped with the main index.
  */
 const subagentIndexes = new Map();
 /** Sub-agent files read per transcript, at most. */
@@ -150,6 +151,7 @@ function freshIndex(st, usageOnly) {
         // A sub-agent's file shares its transcript's set: a message that a host
         // writes into both files is counted once, whichever is read first.
         usageSeen: usageOnly?.seen ?? new Set(),
+        calls: 0,
         lastAssistantText: "",
         firstUserPrompt: "",
         sawPrompt: false,
@@ -388,6 +390,8 @@ function subagentFiles(transcriptPath) {
  * read beside the transcript's set of counted messages, so nothing counts
  * twice. A total that fell made the turn across the fall cost $0 for that
  * model, the main transcript's own tokens with it, and the file $0 for good.
+ *
+ * `calls` is the same files' model calls, on the same terms.
  */
 function subagentUsage(transcriptPath, main) {
     const files = subagentFiles(transcriptPath);
@@ -397,16 +401,26 @@ function subagentUsage(transcriptPath, main) {
         known = undefined;
     }
     if (files.length === 0 && !known)
-        return [];
+        return { usage: [], calls: 0 };
     if (!known) {
-        known = { beside: main, files: new Map(), gone: new Map() };
+        known = { beside: main, files: new Map(), gone: new Map(), goneCalls: 0 };
         subagentIndexes.set(transcriptPath, known);
     }
-    const gone = known.gone;
-    const usageOnly = { seen: main.usageSeen, retire: (old) => addUsage(gone, old.usage) };
+    const store = known;
+    const usageOnly = {
+        seen: main.usageSeen,
+        retire: (old) => {
+            addUsage(store.gone, old.usage);
+            store.goneCalls += old.calls;
+        },
+    };
     for (const file of files)
-        indexIn(known.files, file, MAX_SUBAGENT_FILES, usageOnly);
-    return [gone, ...[...known.files.values()].map((idx) => idx.usage)];
+        indexIn(store.files, file, MAX_SUBAGENT_FILES, usageOnly);
+    const read = [...store.files.values()];
+    return {
+        usage: [store.gone, ...read.map((idx) => idx.usage)],
+        calls: read.reduce((n, idx) => n + idx.calls, store.goneCalls),
+    };
 }
 /** `from`'s tokens added into `into`, key by key. */
 function addUsage(into, from) {
@@ -478,6 +492,9 @@ function foldUsage(idx, message) {
         return;
     if (id)
         idx.usageSeen.add(id);
+    // One message is one request: a model call (LP11), on the very terms its
+    // tokens are counted.
+    idx.calls += 1;
     const model = message?.model ?? "unknown";
     const input = count(usage.input_tokens);
     const read = count(usage.cache_read_input_tokens);
@@ -938,19 +955,49 @@ const count = (value) => typeof value === "number" && Number.isFinite(value) &&
  *
  * The running totals live in the index ({@link foldLine}); this returns a copy,
  * because a mark is kept and compared long after the index has moved on.
+ *
+ * The model calls those totals were counted from ride beside the copy, in
+ * {@link MARK_CALLS}: a key of the map would be read as a model, and priced.
  */
 function totalUsage(transcriptPath) {
     const totals = new Map();
     const idx = indexFor(transcriptPath);
-    if (!idx)
+    if (!idx) {
+        MARK_CALLS.set(totals, 0);
         return totals;
+    }
     for (const [model, u] of idx.usage)
         totals.set(model, { ...u });
     // And what the session's sub-agents used, each in a file of its own.
-    for (const usage of subagentUsage(transcriptPath, idx))
+    const subagents = subagentUsage(transcriptPath, idx);
+    for (const usage of subagents.usage)
         addUsage(totals, usage);
+    MARK_CALLS.set(totals, idx.calls + subagents.calls);
     return totals;
 }
+/**
+ * Model calls counted into a mark, by the mark: every mark this module makes
+ * has its entry, and a map made anywhere else has none ({@link callsBetween}).
+ * Weak, so a mark nobody holds any more takes its count with it.
+ */
+const MARK_CALLS = new WeakMap();
+/**
+ * The model calls between two marks of one transcript, `from` the earlier:
+ * assistant messages, each counted once by its `message.id` as its tokens are
+ * ({@link totalUsage}), the sub-agents' files included — the calls behind the
+ * tokens {@link usageBetween} gives for the same two marks. No `mark` counts
+ * from the start, as there. Clamped at 0, as the tokens are, for a transcript
+ * rewritten between the two. Undefined when either mark was not made here.
+ */
+export function callsBetween(mark, now) {
+    const to = MARK_CALLS.get(now);
+    if (to === undefined)
+        return undefined;
+    if (mark === undefined)
+        return to;
+    const from = MARK_CALLS.get(mark);
+    return from === undefined ? undefined : Math.max(0, to - from);
+}
 /**
  * Snapshot cumulative usage at the moment a run starts.
  *

package/dist/record/recorder.d.ts

@@ -471,7 +471,57 @@ export interface ExecutionReport {
      * (record/remote-recorder.ts, `answerCallsBody`).
      */
     answerCalls?: AnswerCall[];
+    /**
+     * What the runner can say of the turn beyond its cost (the service's
+     * learningPhase.md LP11): how the plan ran, the model calls and tokens of
+     * the window its cost was read for, how much the plan handed the agent to
+     * read, and why it handed over. The learning phase's rules about cost and
+     * time read it (P7, P8). Additive: an older service drops it, and a report
+     * without it is the body it always was.
+     */
+    turn?: ExecutionTurn;
+}
+/**
+ * {@link ExecutionReport.turn}. Every key is always there, `null` when the
+ * runner does not know it: no transcript mark, another host's run, nothing
+ * handed to the agent, no answer read.
+ */
+export interface ExecutionTurn {
+    /** How the plan ran, as coverage.ts decided it when it armed; null for a plan that never armed. */
+    mode: "direct" | "steer" | null;
+    /** The window's model calls: assistant messages, counted once per `message.id`, sub-agents' files included. */
+    modelCalls: number | null;
+    inputTokens: number | null;
+    outputTokens: number | null;
+    cacheReadTokens: number | null;
+    /** Every cache write, the 1-hour ones among them. */
+    cacheWriteTokens: number | null;
+    /**
+     * Characters of what the plan handed the agent to read: `run_scenario`'s
+     * answer (the bundle, or the hand-over note), a divergence's bundle, and
+     * the notes told in place of a call or beside its result. The announcement
+     * the prompt carries is not counted. Null for a plan that never armed.
+     */
+    bundleChars: number | null;
+    /** The brief bundle (0.3.25) was handed; false for a full one; null when no bundle was. */
+    brief: boolean | null;
+    /** Characters of the agent's final answer, when the runner read it (AC11); else null. */
+    answerChars: number | null;
+    /**
+     * On a hand-over: where the stopped step stood (`stop`, as a fragment's
+     * create call sends it — `not_run`, `failed`, `ran`, `uncertain`, …; null
+     * for a stop in front of a parked step or the other half) and why it
+     * stopped (`reason`: `budget`, `cancelled`, `test_failed`, `concurrent`,
+     * `failed`, … for a step that stopped, else the hand-over's kind). Null
+     * when the plan did not hand over.
+     */
+    handover: {
+        stop: string | null;
+        reason: string | null;
+    } | null;
 }
+/** The part of {@link ExecutionTurn} that only the transcript can say: the control server reads it. */
+export type TurnUsage = Pick<ExecutionTurn, "modelCalls" | "inputTokens" | "outputTokens" | "cacheReadTokens" | "cacheWriteTokens">;
 /** One call of a plan, whole, as {@link ExecutionReport.answerCalls} carries it. */
 export interface AnswerCall {
     /** The step's own `stepIndex`. */

package/dist/record/remote-recorder.d.ts

@@ -61,7 +61,7 @@
  */
 import { type AuthSession } from "../auth/client.js";
 import { type ServiceHealth } from "../util/service-health.js";
-import type { AnswerCall, AttentionPlan, DisputeAnswer, ExecutionReport, FlushOptions, IntentMatchAnswer, IntentMatchOptions, IntentMatchRequest, Recorder, RecorderHealth, RecorderHealthReporter, RunCreation, RunMatch, RunMetrics, StartRunOptions, StepMetadata, ToolListEntry } from "./recorder.js";
+import type { AnswerCall, AttentionPlan, DisputeAnswer, ExecutionReport, ExecutionTurn, FlushOptions, IntentMatchAnswer, IntentMatchOptions, IntentMatchRequest, Recorder, RecorderHealth, RecorderHealthReporter, RunCreation, RunMatch, RunMetrics, StartRunOptions, StepMetadata, ToolListEntry } from "./recorder.js";
 /**
  * Caps for the free text this recorder sends, in UTF-8 bytes. Tool payloads
  * arrive capped at 64 KiB by their producers; text never passed through one,
@@ -129,6 +129,14 @@ export interface RemoteRecorderOptions {
     /** The longest one queued send waits for a failing service ({@link COOLDOWN_WAIT_MAX_MS}). Tests shorten it. */
     cooldownWaitMaxMs?: number;
 }
+/**
+ * A report's `turn` as it is sent (the service's learningPhase.md LP11): its
+ * ten keys and no other, each a whole count of at least 0, a short code or
+ * null — so that no value a service's schema could refuse costs the report
+ * that carries it, and with it the turn's cost. Undefined, and so left out of
+ * the body, when the report has none.
+ */
+export declare function turnBody(turn: ExecutionTurn | undefined): ExecutionTurn | undefined;
 /** What one answered turn's call may carry of its output, in UTF-8 bytes (review item 12). */
 export declare const ANSWER_CALL_OUTPUT_MAX_BYTES: number;
 /** All of one report's answer calls together, serialized, in UTF-8 bytes. */

package/dist/record/remote-recorder.js

@@ -274,6 +274,39 @@ function reportBody(fields, steps, extra = {}) {
         add(i, "toolOutput");
     return JSON.stringify({ ...fields, steps: sent, ...extra });
 }
+/** Longest `stop` or `reason` a report's `turn` carries: they are codes. */
+const TURN_CODE_MAX = 64;
+/**
+ * A report's `turn` as it is sent (the service's learningPhase.md LP11): its
+ * ten keys and no other, each a whole count of at least 0, a short code or
+ * null — so that no value a service's schema could refuse costs the report
+ * that carries it, and with it the turn's cost. Undefined, and so left out of
+ * the body, when the report has none.
+ */
+export function turnBody(turn) {
+    if (!turn || typeof turn !== "object")
+        return undefined;
+    const count = (n) => typeof n === "number" && Number.isFinite(n) && n >= 0 ? Math.round(n) : null;
+    const code = (s) => (typeof s === "string" && s !== "" ? s.slice(0, TURN_CODE_MAX) : null);
+    try {
+        const h = turn.handover;
+        return {
+            mode: turn.mode === "direct" || turn.mode === "steer" ? turn.mode : null,
+            modelCalls: count(turn.modelCalls),
+            inputTokens: count(turn.inputTokens),
+            outputTokens: count(turn.outputTokens),
+            cacheReadTokens: count(turn.cacheReadTokens),
+            cacheWriteTokens: count(turn.cacheWriteTokens),
+            bundleChars: count(turn.bundleChars),
+            brief: typeof turn.brief === "boolean" ? turn.brief : null,
+            answerChars: count(turn.answerChars),
+            handover: h && typeof h === "object" ? { stop: code(h.stop), reason: code(h.reason) } : null,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
 /** What one answered turn's call may carry of its output, in UTF-8 bytes (review item 12). */
 export const ANSWER_CALL_OUTPUT_MAX_BYTES = 64 * 1024;
 /** All of one report's answer calls together, serialized, in UTF-8 bytes. */
@@ -1139,6 +1172,11 @@ export class RemoteRecorder {
                     // ...or only answered: its answer, capped and redacted like any
                     // text (AC11). Additive, like `redoneBy`.
                     answer: out(answer),
+                    // How the plan ran, its model calls and tokens, what the agent
+                    // read and why it handed over (the service's learningPhase.md
+                    // LP11). A few hundred bytes, inside the budget the payloads give
+                    // way to. Additive: an older service drops it.
+                    turn: turnBody(report.turn),
                 }, steps, 
                 // Beside the answer, the plan's calls whole (review item 12),
                 // outside the steps' budget. Additive: an older service drops them.

package/dist/replay/controller.d.ts

@@ -11,7 +11,7 @@
  * degrades to "run the turn normally" or returns something the session can
  * ignore. Nothing throws at a hook.
  */
-import type { ExecutionReport } from "../record/recorder.js";
+import type { ExecutionReport, ExecutionTurn, TurnUsage } from "../record/recorder.js";
 import { type ReplayMode, type StepReach } from "./coverage.js";
 import { deriveParameters, type AgentDay, type DeriveContext, type DeriveResult } from "./derive.js";
 import { type HandoverStopReason } from "./handover.js";
@@ -360,6 +360,15 @@ export interface Handover {
     error?: string;
     /** For a `step_failed`: where the stopped step stood ({@link stopOf}). */
     stop?: string;
+    /**
+     * Why it stopped, as a code: for a `step_failed` the stop's own reason
+     * (`budget`, `cancelled`, `test_failed`, `concurrent`, `host_rejected`, …),
+     * `failed` for a plain failure; for another kind the kind itself. Only the
+     * report reads it (the service's learningPhase.md LP11): {@link stop}
+     * folds the stops in front of a step into `not_run`, and that is all the
+     * service needs to continue one, not to tell why a plan stopped.
+     */
+    reason?: string;
     /** What the model is told. Always built, even when delivery fails. */
     note: string;
     /** Set once the note reached the model, so it is never delivered twice. */
@@ -468,6 +477,16 @@ export interface ReplayState {
     bashCwd?: string;
     /** Set when the plan handed the task to the model part-way (fallbk.md). */
     handover?: Handover;
+    /**
+     * Characters this plan handed the agent to read so far — `run_scenario`'s
+     * answer, a divergence's bundle, the notes told in place of a call or
+     * beside its result — for the report's `turn` (the service's
+     * learningPhase.md LP11). Counted where the text leaves for the agent,
+     * never where it is built: a note made and never delivered was not read.
+     */
+    handedChars?: number;
+    /** The bundle this plan handed the agent, when it handed one: brief (0.3.25), or the full one. */
+    bundleKind?: "brief" | "full";
     /**
      * Every planned step ran and the model was handed the results to answer
      * from: a steered plan whose last step threaded, a direct run that ran to
@@ -725,6 +744,14 @@ export interface ContinuationOf {
  * user's request: it ends with the answer.
  */
 export declare function isSubTask(state: Pick<ReplayState, "armedBy" | "continuation">): boolean;
+/**
+ * The report's `turn` (the service's learningPhase.md LP11): what this plan
+ * did in the turn, from its state, and the window's tokens and model calls,
+ * which only the control server can read (`usage`; undefined when it could
+ * not). Every value is null when it is not known, and nothing here throws: a
+ * state it cannot read is a `turn` of nulls, never a report lost.
+ */
+export declare function turnOf(state: ReplayState, usage?: TurnUsage): ExecutionTurn;
 /** What `PreToolUse` should do about this call. */
 export type PreToolAction = 
 /** Pin the arguments and let the real tool run. */
@@ -903,6 +930,13 @@ export declare class ReplayController {
      * Returns it once and marks it delivered; undefined when there is none.
      */
     takeNote(state: ReplayState | undefined): string | undefined;
+    /**
+     * The hand-over note `run_scenario` answers with: claimed when it is still
+     * to tell ({@link takeNote}), and told again when it was told already — the
+     * same text the run always answered (`takeNote(state) ?? the note`), now
+     * counted as read either way.
+     */
+    private runNote;
     /** Whether a note about this plan is still to be told to the model: a hand-over's, or the unseen results'. */
     hasUndeliveredNote(state: ReplayState | undefined): boolean;
     /**
@@ -1120,6 +1154,12 @@ export declare class ReplayController {
          * own baseline, so the turn's saving is booked somewhere.
          */
         booksOwnSaving?: boolean;
+        /**
+         * The model calls and tokens of the window `sessionCostUsd` was read
+         * for, for the report's `turn` (the service's learningPhase.md LP11).
+         * Only the control server holds the transcript; absent, they are null.
+         */
+        usage?: TurnUsage;
     }): ExecutionReport | undefined;
     /**
      * The step a failed replay is fairly blamed on: the first whose own logic

package/dist/replay/controller.js

@@ -221,6 +221,10 @@ export function sentACall(state) {
     }
     return false;
 }
+/** {@link Handover.reason}: a stopped step's own reason, `failed` for a plain failure, else the kind. */
+function handoverReason(kind, stopReason) {
+    return kind === "step_failed" ? (stopReason ?? "failed") : kind;
+}
 /**
  * How long a call waits for the previous pin to thread before it is judged to
  * be running beside it: the control server's hook-view fallback
@@ -255,6 +259,59 @@ const TURN_CALLS_MAX_CHARS = 8 * 1024 * 1024;
 export function isSubTask(state) {
     return state.armedBy === "intent" && state.continuation === undefined;
 }
+/**
+ * Count text the plan hands the agent to read ({@link ReplayState.handedChars}),
+ * where it leaves for the agent. Adds a length and nothing else.
+ */
+function handed(state, text) {
+    if (!state || typeof text !== "string" || text.length === 0)
+        return;
+    state.handedChars = (state.handedChars ?? 0) + text.length;
+}
+/** Longest `stop` or `reason` a report's `turn` carries: they are codes, and a code is short. */
+const TURN_CODE_MAX = 64;
+const turnCode = (value) => typeof value === "string" && value !== "" ? value.slice(0, TURN_CODE_MAX) : null;
+/**
+ * The report's `turn` (the service's learningPhase.md LP11): what this plan
+ * did in the turn, from its state, and the window's tokens and model calls,
+ * which only the control server can read (`usage`; undefined when it could
+ * not). Every value is null when it is not known, and nothing here throws: a
+ * state it cannot read is a `turn` of nulls, never a report lost.
+ */
+export function turnOf(state, usage) {
+    const count = (n) => typeof n === "number" && Number.isFinite(n) && n >= 0 ? Math.round(n) : null;
+    try {
+        const armed = state.mode === "direct" || state.mode === "steer";
+        const h = state.handover;
+        return {
+            mode: armed ? state.mode : null,
+            modelCalls: count(usage?.modelCalls),
+            inputTokens: count(usage?.inputTokens),
+            outputTokens: count(usage?.outputTokens),
+            cacheReadTokens: count(usage?.cacheReadTokens),
+            cacheWriteTokens: count(usage?.cacheWriteTokens),
+            bundleChars: armed ? count(state.handedChars ?? 0) : null,
+            brief: state.bundleKind === "brief" ? true : state.bundleKind === "full" ? false : null,
+            // Read by the control server after the turn, when it reads the answer (AC11).
+            answerChars: null,
+            handover: h ? { stop: turnCode(h.stop), reason: turnCode(h.reason) } : null,
+        };
+    }
+    catch {
+        return {
+            mode: null,
+            modelCalls: null,
+            inputTokens: null,
+            outputTokens: null,
+            cacheReadTokens: null,
+            cacheWriteTokens: null,
+            bundleChars: null,
+            brief: null,
+            answerChars: null,
+            handover: null,
+        };
+    }
+}
 export class ReplayController {
     enabled;
     work = new ProxyWorkQueue();
@@ -970,6 +1027,7 @@ export class ReplayController {
                 scenario: state.scenarioId ?? undefined,
                 bytes: h.note.length,
             });
+            handed(state, h.note);
             return h.note;
         }
         // A plan that ran to its end with nobody there to read it has no
@@ -978,10 +1036,25 @@ export class ReplayController {
         if (u && !u.delivered) {
             u.delivered = true;
             logDetail("replay.unseen_delivered", { scenario: state.scenarioId ?? undefined, bytes: u.note.length });
+            handed(state, u.note);
             return u.note;
         }
         return undefined;
     }
+    /**
+     * The hand-over note `run_scenario` answers with: claimed when it is still
+     * to tell ({@link takeNote}), and told again when it was told already — the
+     * same text the run always answered (`takeNote(state) ?? the note`), now
+     * counted as read either way.
+     */
+    runNote(state) {
+        const note = this.takeNote(state);
+        if (note !== undefined)
+            return note;
+        const again = state.handover?.note;
+        handed(state, again);
+        return again;
+    }
     /** Whether a note about this plan is still to be told to the model: a hand-over's, or the unseen results'. */
     hasUndeliveredNote(state) {
         return Boolean((state?.handover && !state.handover.delivered) || (state?.unseen && !state.unseen.delivered));
@@ -1155,6 +1228,7 @@ export class ReplayController {
             if (skip && toolName !== plan.expectedTool() && skip.tools.has(toolName) && (skip.refused ?? 0) < 2) {
                 skip.delivered = true;
                 skip.refused = (skip.refused ?? 0) + 1;
+                handed(state, skip.text);
                 return this.deliverInstead(skip.text, toolName, otherHost);
             }
             // A call to the next step's tool: a note the model has read is done
@@ -1686,6 +1760,7 @@ export class ReplayController {
         if (!skip || skip.delivered)
             return undefined;
         skip.delivered = true;
+        handed(state, skip.text);
         return skip.text;
     }
     /**
@@ -1699,6 +1774,7 @@ export class ReplayController {
         if (!skip || skip.delivered || !skip.tools.has(toolName))
             return undefined;
         skip.delivered = true;
+        handed(state, skip.text);
         return skip.text;
     }
     /**
@@ -1887,7 +1963,7 @@ export class ReplayController {
                 delivery: "none",
                 stopReason: "not_run",
             });
-            return handedOver(this.takeNote(state) ?? state.handover?.note) ?? { ok: false, why: ready.error };
+            return handedOver(this.runNote(state)) ?? { ok: false, why: ready.error };
         }
         const deadline = Date.now() + this.budgets.planMs;
         let result;
@@ -1981,12 +2057,15 @@ export class ReplayController {
                     ? { ok: true, text: `${note}\n\n${result.text}`, responseModel: {}, steps: result.executed + result.recorded, partial: true }
                     : (handedOver(note) ?? { ok: false, why: note });
             }
-            const note = this.takeNote(state) ?? state.handover?.note ?? "";
+            const note = this.runNote(state) ?? "";
             if (!live) {
                 // Nothing ran: the tool answers with an error that says so, which is
                 // what a model reacts to best.
                 return handedOver(note) ?? { ok: false, why: note };
             }
+            // The note in front was counted as it was claimed; the rest of the answer here.
+            handed(state, `\n\n${result.text}`);
+            state.bundleKind = result.brief ? "brief" : "full";
             return {
                 ok: true,
                 text: `${note}\n\n${result.text}`,
@@ -2006,7 +2085,7 @@ export class ReplayController {
                 ran: 0,
                 noneNeeded: true,
             });
-            return handedOver(this.takeNote(state) ?? state.handover?.note) ?? { ok: false, why: "" };
+            return handedOver(this.runNote(state)) ?? { ok: false, why: "" };
         }
         if (result.executed === 0) {
             // Every step stood on its recorded output (BIR_REPLAY_RECORDED_OUTPUTS):
@@ -2021,7 +2100,7 @@ export class ReplayController {
                 stopReason: "not_run",
                 ran: 0,
             });
-            return handedOver(this.takeNote(state) ?? state.handover?.note) ?? { ok: false, why: "" };
+            return handedOver(this.runNote(state)) ?? { ok: false, why: "" };
         }
         // Live steps only, as above: a recorded stand-in did no work here.
         state.stepsPinned += result.executed;
@@ -2087,6 +2166,19 @@ export class ReplayController {
                 why: "the caller went away during the last step — every step ran and nobody read the results",
             });
         }
+        else {
+            // What `run_scenario` hands the agent: the bundle, and the response
+            // model `bir-scenario` puts under it when there is one.
+            handed(state, result.text);
+            try {
+                if (Object.keys(responseModel).length > 0)
+                    handed(state, JSON.stringify(responseModel));
+            }
+            catch {
+                // A model no JSON can carry reaches the agent as nothing: nothing to count.
+            }
+            state.bundleKind = result.brief ? "brief" : "full";
+        }
         return {
             ok: true,
             text: result.text,
@@ -2202,6 +2294,10 @@ export class ReplayController {
                 d.cutShort === true
                 ? false
                 : undefined,
+            // How the plan ran, what the turn's model calls and tokens were, what
+            // the agent was handed to read, and why it handed over (LP11). Only
+            // facts the runner already had; an older service drops the field.
+            turn: turnOf(state, d.usage),
         };
     }
     /**
@@ -2582,12 +2678,14 @@ export class ReplayController {
             // done its work, and the model must know before it does the task itself.
             if (stop?.reason === "uncertain" && stop.position !== undefined) {
                 const note = this.stopNote(state, plan, stop, "none", composed.left);
+                handed(state, note);
                 return this.deliverInstead(note, toolName, state.host !== undefined);
             }
             // The rest is the other half (AC5): the model is told so, in place of
             // its call, before it does any of the plan's remaining steps.
             if (stop?.kind === "other_branch" && stop.position !== undefined) {
                 const note = this.stopNote(state, plan, stop, "none", composed.left);
+                handed(state, note);
                 return this.deliverInstead(note, toolName, state.host !== undefined);
             }
             // Every remaining step was left out by its test: the steps the session
@@ -2615,6 +2713,7 @@ export class ReplayController {
                 kind: stopKind,
                 stepIndex: parked.stepIndex,
                 toolName: parked.toolName ?? undefined,
+                reason: stopKind,
                 note: this.noteFor(state, {
                     kind: stopKind,
                     step: parked,
@@ -2638,6 +2737,10 @@ export class ReplayController {
         // reason is read as adversarial interception.
         const action = this.deliverInstead(text, toolName, state.host !== undefined);
         logDetail("replay.inject", { channel: action.kind, bytes: text.length });
+        // What the agent reads of it: the whole text as a refusal's reason, as
+        // much as the channel carries as a command's output.
+        handed(state, action.kind === "bash" ? text.slice(0, BASH_CHANNEL_MAX) : text);
+        state.bundleKind = "full";
         return action;
     }
     /**
@@ -2675,6 +2778,7 @@ export class ReplayController {
             ...(stop.kind === "step_failed"
                 ? { stop: stopOf({ ranThisStep: stop.stage === "tool_output_logic", stopReason: stop.reason }) }
                 : {}),
+            reason: handoverReason(stop.kind, stop.reason),
             note,
             delivered: true,
         };
@@ -2699,6 +2803,7 @@ export class ReplayController {
             toolName: h.step?.toolName ?? undefined,
             error: h.error,
             ...(h.kind === "step_failed" ? { stop: stopOf(h) } : {}),
+            reason: handoverReason(h.kind, h.stopReason),
             note: this.noteFor(state, h),
             delivered: false,
         };