@basein/runner 0.3.14 → 0.3.16

package/dist/control/server.js

@@ -1811,6 +1811,11 @@ export class ControlServer {
         // the jail it may not leave (replay/builtins.ts). The session's own cwd
         // from the hook payloads, never the daemon's.
         state.sessionCwd = session.cwd ?? this.opts.cwd;
+        // The service offered to record this turn as the recording's newest run:
+        // should the agent redo the task after the plan, the plan's own calls go
+        // into that run first, so they are kept whole as they run (AC2).
+        if (match.repeat?.runId)
+            state.keepCalls = true;
         this.declineWithoutDeliveryTool(state);
         // A steer plan with a shell or file-write step can only be followed if the
         // directive shows its computed arguments (the pin guard holds those steps
@@ -2290,14 +2295,24 @@ export class ControlServer {
         // including when it declined to steer, which is a *baseline* sample and is
         // what every saving is measured against (docs/calculatedReplay.md §11).
         this.reportExecution(session, run, durationMs, cost, cutShort);
+        // The plan's calls kept for a redo went into the repeat when it opened
+        // (AC2); nothing reads them after the turn, and they can run to megabytes
+        // on a sealed run the session keeps as its previous one.
+        for (const s of run.replays.length > 0 ? run.replays : run.replay ? [run.replay] : []) {
+            s.turnCalls = undefined;
+            s.turnCallChars = 0;
+        }
         // A fragment is recorded from the hand-over on (fallbk.md D7), so its cost
         // and duration are the model's own work, not the steps the scenario did.
-        // Another host hands over one number for the whole run, and it is the
-        // fragment's: the plan's own steps made no model call, so all of it was
-        // spent after the hand-over.
+        // So is a repeat opened after the plan ran to its end (newestRun.md N7). Another host
+        // hands over one number for the whole run, and it is the fragment's: the
+        // plan's own steps made no model call, so all of it was spent after the
+        // hand-over.
         const fragment = run.fragment?.state === "open" ? run.fragment : undefined;
-        const recordedCost = fragment && !other ? this.costSince(session, fragment.usageMark) : cost;
-        const recordedMs = fragment?.startedAtMs ? Date.now() - fragment.startedAtMs : durationMs;
+        const repeatAfterPlan = !fragment && run.repeat?.state === "open" && run.repeat.startedAtMs !== undefined ? run.repeat : undefined;
+        const ownWork = fragment ?? repeatAfterPlan;
+        const recordedCost = ownWork && !other ? this.costSince(session, ownWork.usageMark) : cost;
+        const recordedMs = ownWork?.startedAtMs ? Date.now() - ownWork.startedAtMs : durationMs;
         if (run.recording) {
             const transcriptPath = session.transcriptPath;
             // The answer is the host's when it handed one over, and the
@@ -2444,6 +2459,14 @@ export class ControlServer {
         // Another host hands over one number for the whole run. It cannot be
         // split between two plans, so with more than one neither is measured.
         const unsplit = otherHost(session) && states.length > 1;
+        // The plan ran to its end and the agent redid the task in a repeat the
+        // service took (newestRun.md N7): the prompt plan's report says so, with
+        // the repeat's id and the agent's own calls in it (autocorrect.md AC1).
+        const r = run.repeat;
+        const redoneBy = r?.state === "open" && r.reason === "redone" && r.openedRunId
+            ? { runId: r.openedRunId, ownCalls: r.ownCalls ?? 0 }
+            : undefined;
+        const prompt = states.find((s) => s.armedBy === "prompt");
         // One report per plan armed this turn (fallbk.md §Runner 4). Each is billed
         // for its own window of the transcript — from when it armed to when the next
         // one did — so the turn's tokens are split between them, never counted twice.
@@ -2481,6 +2504,7 @@ export class ControlServer {
                 siblings: states,
                 runId: run.runId,
                 cutShort: cutShort || undefined,
+                redoneBy: state === prompt && state.ranToEnd === true ? redoneBy : undefined,
             });
             if (!report)
                 return;
@@ -2891,6 +2915,7 @@ export class ControlServer {
                 if (!steering.retired) {
                     steering.pinned.clear();
                     steering.retired = true;
+                    steering.skipNote = undefined;
                     logLine("replay.pin_overran", {
                         scenario: steering.scenarioId ?? undefined,
                         tool: toolName,
@@ -2912,9 +2937,25 @@ export class ControlServer {
                     if (verdict.ok) {
                         pinned = action.input;
                         this.declinedPins.delete(steering);
+                        this.replay.pinTaken(steering);
                     }
                     else {
                         steering.pinned.delete(toolUseId);
+                        // Not the next step — and perhaps the step a test just left out,
+                        // which shares its tool, made because the note saying so had not
+                        // reached the model yet (AC5). The note goes in its place: a step
+                        // left out never runs because the note was late. The plan stays
+                        // armed for the step that is next.
+                        const skipped = this.replay.skipNoteFor(steering, toolName);
+                        if (skipped) {
+                            logLine("replay.pin_declined", {
+                                scenario: steering.scenarioId ?? undefined,
+                                tool: toolName,
+                                step: action.stepIndex,
+                                why: "a call to the step a test left out — the note saying so is given in its place",
+                            });
+                            return this.preToolAnswer(this.replay.deliverInstead(skipped, toolName));
+                        }
                         this.declinedPins.add(steering);
                         logLine("replay.pin_declined", {
                             scenario: steering.scenarioId ?? undefined,
@@ -2935,6 +2976,13 @@ export class ControlServer {
         // a plan nobody would ever hear of.
         if (!overran && !pinned && (!run.replay?.plan || run.replay.retired)) {
             // ── falling back to the model (fallbk.md) ──────────────────────────────
+            // 0. A call to a step a test left out (AC5), when the note saying so has
+            //    not reached the model yet — the plan may have finished on it. The
+            //    note goes in its place: a step left out must never run because the
+            //    note was late.
+            const skipped = planning ? undefined : this.replay.skipNoteFor(run.replay, toolName);
+            if (skipped)
+                return this.preToolAnswer(this.replay.deliverInstead(skipped, toolName));
             // 1. A hand-over noticed where no hook answer could carry it — a proxy
             //    report threaded after its PostToolUse had already answered — reaches
             //    the model in place of this call. Never silence (D4).
@@ -3068,6 +3116,7 @@ export class ControlServer {
             ? (run.replay?.scenarioId ?? undefined)
             : undefined;
         if (run.recording) {
+            this.noteOwnCall(run, pinnedBy);
             this.queue.push(() => {
                 this.recorder.recordToolSelected(run.runId, pair.selected, {
                     toolName,
@@ -3299,6 +3348,7 @@ export class ControlServer {
             toolName,
         });
         if (run.recording) {
+            this.noteOwnCall(run);
             const toolInput = serializeCapped(redact(modelArgs));
             this.queue.push(() => {
                 this.recorder.recordToolSelected(run.runId, pair.selected, {
@@ -3357,6 +3407,7 @@ export class ControlServer {
         state.retired = true;
         state.retiredAt = Date.now();
         state.pinned.clear();
+        state.skipNote = undefined;
         this.directCalls = this.directCalls.filter((c) => c.state !== state);
         logLine("replay.vetoed", {
             run: run.runId,
@@ -3387,6 +3438,8 @@ export class ControlServer {
         state.retired = true;
         state.retiredAt = Date.now();
         state.pinned.clear();
+        // A note naming a step to call next is void with the plan (AC5 review).
+        state.skipNote = undefined;
         run.handback = HANDBACK_NOTE;
         logLine("replay.pin_abandoned", {
             run: run.runId,
@@ -4032,10 +4085,20 @@ export class ControlServer {
     }
     /**
      * Whether this matched turn's task is now the model's own, so its work is
-     * the repeat the service offered to record (the service's newestRun.md N1):
-     * offered, nothing recording, no fragment, and no plan of the prompt match
-     * that ran a step or still may. A plan that handed over is the fragment's to
-     * record (fallbk.md D7).
+     * the repeat the service offered to record: offered, nothing recording, no
+     * fragment, and the prompt match's plan done with — retired, not running,
+     * not diverging — and either:
+     *
+     *  - it ran no step: the model does the whole task (newestRun.md N1); or
+     *  - it ran to its end, and the model, told to answer from its results,
+     *    called tools of its own instead (N7). Before 0.3.15 that work was
+     *    lost: a model that did not take the plan's result as the answer and
+     *    did the task again left nothing to fix the plan from.
+     *
+     * A plan that handed over is the fragment's to record (fallbk.md D7). One
+     * that ran part of the task and stopped without a hand-over records
+     * nothing, as before: the call where it stopped ran while it was still
+     * live, so a run of what came after would lack the step that matters.
      */
     repeatDue(run) {
         const r = run.repeat;
@@ -4044,23 +4107,34 @@ export class ControlServer {
         const prompt = run.replays.find((s) => s.armedBy === "prompt");
         if (!prompt?.plan)
             return true;
-        return prompt.retired && prompt.stepsPinned === 0 && !prompt.handover;
+        if (!prompt.retired || prompt.diverging || this.runningPlans.has(prompt) || prompt.handover)
+            return false;
+        return prompt.stepsPinned === 0 || prompt.ranToEnd === true;
     }
     /**
-     * Open the repeat run and record from this call on (newestRun.md N1).
+     * Whether the prompt match's plan ran to its end before the model went on
+     * by itself (newestRun.md N7). False when it ran no step, which is N1.
+     */
+    redoneAfterPlan(run) {
+        const prompt = run.replays.find((s) => s.armedBy === "prompt");
+        return prompt?.plan !== undefined && prompt.ranToEnd === true;
+    }
+    /**
+     * Open the repeat run and record from this call on (newestRun.md N1, N7).
      *
      * The same swap as {@link openFragment}: nothing allocated before it belongs
-     * to it. Unlike a fragment it carries the turn's prompt, and its cost and
-     * duration are the whole turn's, because no plan did any of the task. Nothing
-     * waits for the service's answer: the steps queue behind the create, and a
-     * create answered `id: null` — the service records no repeat of it — drops
-     * them.
+     * to it. Unlike a fragment it carries the turn's prompt. When no plan did
+     * any of the task, its cost and duration are the whole turn's; after a plan
+     * that ran to its end, they start here, as a fragment's do. Nothing waits
+     * for the service's answer: the steps queue behind the create, and a create
+     * answered `id: null` — the service records no repeat of it — drops them.
      */
     openRepeat(session, run) {
         const r = run.repeat;
         if (!r || r.state !== "offered")
             return;
-        const reason = this.repeatReason(run);
+        const redone = this.redoneAfterPlan(run);
+        const reason = redone ? "redone" : this.repeatReason(run);
         const repeatOf = reason ? { runId: r.runId, reason } : { runId: r.runId };
         // The repeat is a run of the same host as the turn it records.
         const framework = frameworkOf(session);
@@ -4075,11 +4149,27 @@ export class ControlServer {
         run.ordering = new StepIndexAllocator();
         run.recording = true;
         r.state = "open";
+        r.openedRunId = id;
+        r.reason = reason;
+        r.ownCalls = 0;
+        // The plan's own calls of this turn go in first, whole and marked, so the
+        // newest run holds the whole turn: the agent's work is built on what the
+        // plan's calls returned (the service's autocorrect.md AC2).
+        const planCalls = redone ? this.recordPlanCalls(run, id) : 0;
+        if (redone) {
+            // The plan's steps are not the model's work: this run is billed and
+            // timed from its own first call on, as a fragment is.
+            r.usageMark = markTranscriptUsage(session.transcriptPath);
+            r.startedAtMs = Date.now();
+        }
         logLine("run.repeat", {
             run: id,
             of: r.runId,
             reason,
-            why: "the agent is doing a recorded task itself — recorded as that recording's newest run",
+            planCalls: planCalls || undefined,
+            why: redone
+                ? "the plan ran to its end, and the agent went on with calls of its own instead of answering from its results — recorded as that recording's newest run"
+                : "the agent is doing a recorded task itself — recorded as that recording's newest run",
         });
         if (!isRunCreationAware(this.recorder))
             return;
@@ -4087,10 +4177,15 @@ export class ControlServer {
             .runCreated(id)
             .catch(() => ({ created: true }))
             .then((created) => {
-            if (created.created || run.runId !== id)
+            if (created.created)
                 return;
-            run.recording = false;
+            // Refused: never named as the turn's redo (the service's
+            // autocorrect.md AC1) — also when the turn has moved on to another
+            // run since, which used to leave the repeat `open` and named.
             r.state = "refused";
+            if (run.runId !== id)
+                return;
+            run.recording = false;
             logLine("run.repeat_refused", {
                 run: id,
                 of: r.runId,
@@ -4098,6 +4193,54 @@ export class ControlServer {
             });
         });
     }
+    /**
+     * Record the prompt plan's own calls of this turn into the `redone` repeat
+     * `id`, in the order they went out, before the agent's first call of its
+     * own (the service's autocorrect.md AC2). Each is a pair, both rows marked
+     * `byPlan` with the plan, its step and its chain revision, so the service
+     * stores them without a vector and counts none of them as the agent's.
+     * Payloads are whole — redacted and capped as any recorded call's — where
+     * the report has only 3,800 bytes of each. Returns how many it recorded.
+     */
+    recordPlanCalls(run, id) {
+        const prompt = run.replays.find((s) => s.armedBy === "prompt");
+        const calls = this.replay.turnCallsOf(prompt);
+        for (const call of calls) {
+            const pair = run.ordering.allocatePair();
+            const byPlan = {
+                scenarioId: call.scenarioId,
+                stepIndex: call.stepIndex,
+                // Left out, never null, when the plan was served without one: the
+                // service's row schema takes a number or nothing.
+                ...(call.chainRevision !== null ? { chainRevision: call.chainRevision } : {}),
+            };
+            this.queue.push(() => {
+                this.recorder.recordToolSelected(id, pair.selected, {
+                    toolName: call.toolName,
+                    toolInput: call.input,
+                    metadata: { byPlan },
+                });
+                this.recorder.recordToolResponse(id, pair.response, {
+                    toolName: call.toolName,
+                    toolOutput: call.error === undefined ? call.output : undefined,
+                    toolError: call.error,
+                    metadata: { byPlan },
+                });
+            });
+        }
+        return calls.length;
+    }
+    /**
+     * One tool call of the model's own was recorded into `run`: counted for
+     * the plan's report when it is the `redone` repeat (AC1). A step a plan
+     * pinned is the plan's doing, not the model's, and is not counted.
+     */
+    noteOwnCall(run, pinnedBy) {
+        const r = run.repeat;
+        if (pinnedBy || !r || r.state !== "open" || run.runId !== r.openedRunId)
+            return;
+        r.ownCalls = (r.ownCalls ?? 0) + 1;
+    }
     /**
      * Why the matched turn's plan did not run, as the service shows it: what
      * the service withheld it for, else the code of the gate that declined it
@@ -4143,6 +4286,11 @@ export class ControlServer {
             const note = this.replay.takeNote(run.replay);
             if (note)
                 context.push(note);
+            // The steps a test just left out (AC5): said before the model makes its
+            // next call, which must not be one of them.
+            const skipped = this.replay.takeSkipNote(run.replay);
+            if (skipped)
+                context.push(skipped);
             if (run.handback) {
                 context.push(run.handback);
                 run.handback = undefined;
@@ -5118,6 +5266,7 @@ export class ControlServer {
     record(run, pair, d) {
         if (!run.recording)
             return;
+        this.noteOwnCall(run, d.pinnedBy);
         const toolInput = serializeCapped(redact(d.args));
         const toolOutput = d.isError ? undefined : serializeCapped(redact(d.result));
         const toolError = d.isError

package/dist/record/recorder.d.ts

@@ -13,9 +13,12 @@ export interface StartRunOptions {
     };
     /**
      * Marks a *repeat* (the service's newestRun.md): a matched turn whose plan
-     * did not run, so the model is doing the recording's task itself. Sent only
-     * when the match offered it ({@link RunMatch.repeat}). `reason` is why the
-     * plan did not run. The service never prompt-matches a repeat.
+     * did not run, so the model is doing the recording's task itself — or whose
+     * plan ran to its end, after which the model went on with calls of its own
+     * instead of answering from its results (N7). Sent only when the match
+     * offered it ({@link RunMatch.repeat}). `reason` is why the plan did not
+     * run, or `redone` after a plan that ran to its end. The service never
+     * prompt-matches a repeat.
      */
     repeatOf?: {
         runId: string;
@@ -58,6 +61,27 @@ export interface FlushOptions {
      */
     timeoutMs?: number;
 }
+/**
+ * A plan's own call recorded into the turn's newest run (the service's
+ * autocorrect.md AC2): which plan made it, which of its steps, and the chain
+ * revision it was served at — left out when the service served none, since
+ * its schema takes a number or nothing, never null.
+ */
+export interface PlanCallMark {
+    scenarioId: string;
+    stepIndex: number;
+    chainRevision?: number;
+}
+/**
+ * A recorded step's metadata. `pinnedBy`: a plan executed this step live in
+ * the turn (R-INTENT-7). `byPlan`: the plan made this call before the agent
+ * redid the task, and it is recorded first into the agent's repeat so the
+ * repeat holds the whole turn (AC2). The service stores neither with a vector.
+ */
+export type StepMetadata = {
+    pinnedBy?: string;
+    byPlan?: PlanCallMark;
+};
 export interface Recorder {
     /**
      * Create the run; returns the client-generated runId synchronously.
@@ -83,17 +107,18 @@ export interface Recorder {
         };
         /**
          * Set when a plan executed this step, to the plan's scenario id
-         * (R-INTENT-7). The service stores such a step without a vector, so the
+         * (R-INTENT-7), or made it before the agent redid the task (`byPlan`,
+         * AC2). The service stores such a step without a vector, so the
          * system's own replays never count as recurrences of the work.
          */
-        metadata?: {
-            pinnedBy: string;
-        };
+        metadata?: StepMetadata;
     }): string;
     recordToolResponse(runId: string, stepIndex: number, d: {
         toolName: string;
         toolOutput?: string;
         toolError?: string;
+        /** `byPlan` on the answer of a plan's own call (AC2); omitted otherwise. */
+        metadata?: StepMetadata;
     }): string;
     recordFinalAnswer(runId: string, stepIndex: number, d: {
         answer: string;
@@ -414,6 +439,19 @@ export interface ExecutionReport {
      * person reading the audit log, this is for the console.
      */
     declined?: string;
+    /**
+     * The plan ran to its end and the agent did not take its result: it went on
+     * with calls of its own, recorded as the recording's newest run with the
+     * reason `redone` (the service's newestRun.md N7, autocorrect.md AC1).
+     * `runId` is that repeat's own id; `ownCalls` the agent's own tool calls
+     * recorded into it — not the plan's calls recorded first (AC2), and not a
+     * step a plan pinned. Only on the report of the prompt's plan, and only when
+     * the service took the repeat; an older service drops the field.
+     */
+    redoneBy?: {
+        runId: string;
+        ownCalls: number;
+    };
 }
 /** Optional capability: reporting needs a service, and a NullRecorder has none. */
 export interface ScenarioReporter {

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

@@ -50,7 +50,7 @@
  */
 import { type AuthSession } from "../auth/client.js";
 import { type ServiceHealth } from "../util/service-health.js";
-import type { ExecutionReport, FlushOptions, IntentMatchAnswer, IntentMatchOptions, IntentMatchRequest, Recorder, RecorderHealth, RecorderHealthReporter, RunCreation, RunMatch, RunMetrics, StartRunOptions } from "./recorder.js";
+import type { ExecutionReport, FlushOptions, IntentMatchAnswer, IntentMatchOptions, IntentMatchRequest, Recorder, RecorderHealth, RecorderHealthReporter, RunCreation, RunMatch, RunMetrics, StartRunOptions, StepMetadata } 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,
@@ -225,14 +225,13 @@ export declare class RemoteRecorder implements Recorder, RecorderHealthReporter
             text: string;
             source: "thinking";
         };
-        metadata?: {
-            pinnedBy: string;
-        };
+        metadata?: StepMetadata;
     }): string;
     recordToolResponse(runId: string, stepIndex: number, data: {
         toolName: string;
         toolOutput?: string;
         toolError?: string;
+        metadata?: StepMetadata;
     }): string;
     recordFinalAnswer(runId: string, stepIndex: number, data: {
         answer: string;

package/dist/record/remote-recorder.js

@@ -674,6 +674,10 @@ export class RemoteRecorder {
             toolName: data.toolName,
             toolOutput: out(toolOutput),
             toolError: out(toolError),
+            // Omitted, not nulled, when absent: an ordinary answer is the body it
+            // has always been. Only a plan's own call recorded into a redo carries
+            // one (`byPlan`, the service's autocorrect.md AC2).
+            metadata: data.metadata,
         }));
         return id;
     }
@@ -744,6 +748,12 @@ export class RemoteRecorder {
             kind: "report",
             bytes: sizeOf(prompt, error, ...(steps ?? []).flatMap((s) => [s.toolInput, s.toolOutput])) + 1024,
             send: async () => {
+                // A redo whose run the service refused to create is no run of its:
+                // never named (the service's autocorrect.md AC1), even when the
+                // refusal came after the report was built.
+                const redoneBy = report.redoneBy && this.runs.get(report.redoneBy.runId)?.settled?.created.created === false
+                    ? undefined
+                    : report.redoneBy;
                 const body = await this.request("POST", `/scenarios/${report.scenarioId}/executions`, 
                 // Per-step verdicts and the headline failure (errorshandling.md) ride
                 // beside the costs. All optional on the service side, so an older
@@ -776,6 +786,9 @@ export class RemoteRecorder {
                     // Why nothing ran, when nothing ran. Additive: an older service drops
                     // the field and books the cost exactly as it always did.
                     declined: report.declined,
+                    // The plan ran to its end and the agent redid the task (the
+                    // service's autocorrect.md AC1). Additive, like `declined`.
+                    redoneBy,
                 }, steps), { retryTransient: Boolean(report.ticket) });
                 const r = (body ?? {});
                 const failed = report.steps?.filter((s) => s.status === "failed").length ?? 0;
@@ -795,6 +808,9 @@ export class RemoteRecorder {
                     baselineEligible: report.baselineEligible === false ? false : undefined,
                     sharedWith: report.sharedWith?.length,
                     declined: report.declined,
+                    // `bir investigate` prints it beside the outcome: "redone by run_…".
+                    redoneBy: report.redoneBy?.runId,
+                    ownCalls: report.redoneBy?.ownCalls,
                 });
             },
         });

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

@@ -90,11 +90,7 @@ export declare class SwitchableRecorder implements Recorder {
     currentAccessToken(): string | undefined;
     startRun(input: string, metadata?: Record<string, unknown>, options?: StartRunOptions): string;
     recordToolSelected(runId: string, stepIndex: number, d: Parameters<Recorder["recordToolSelected"]>[2]): string;
-    recordToolResponse(runId: string, stepIndex: number, d: {
-        toolName: string;
-        toolOutput?: string;
-        toolError?: string;
-    }): string;
+    recordToolResponse(runId: string, stepIndex: number, d: Parameters<Recorder["recordToolResponse"]>[2]): string;
     recordFinalAnswer(runId: string, stepIndex: number, d: {
         answer: string;
     }): string;

package/dist/replay/bundle.d.ts

@@ -34,7 +34,17 @@ export interface BundleEntry {
     response: string;
     /** True when `response` is a recorded output, not a fresh run. */
     recorded?: boolean;
+    /**
+     * Set on a step its test left out (the service's autocorrect.md AC5): no
+     * call was made, and the bundle says so in its place, so the model can tell
+     * a whole answer from a part. `text` is the test in words, when it has some.
+     */
+    notNeeded?: {
+        text: string | null;
+    };
 }
+/** The test's words, one line and short, for a bundle or a note. */
+export declare function testWords(text: string | null | undefined): string | null;
 /** Cap a computed input for inclusion in a bundle. */
 export declare function bundleInput(value: unknown): string;
 export interface AssembleOptions {

package/dist/replay/bundle.js

@@ -30,6 +30,13 @@ export const BASH_CHANNEL_MAX = 25_000;
 const MAX_INPUT_CHARS = 2_000;
 /** Fixed structural overhead reserved per step (labels, separators). */
 const PER_STEP_OVERHEAD = 80;
+/** The test's words, one line and short, for a bundle or a note. */
+export function testWords(text) {
+    const line = (text ?? "").trim().split(/\r?\n/, 1)[0]?.trim() ?? "";
+    if (!line)
+        return null;
+    return line.length > 200 ? `${line.slice(0, 200)}…` : line;
+}
 /** Cap a computed input for inclusion in a bundle. */
 export function bundleInput(value) {
     let text;
@@ -90,7 +97,9 @@ const SUBTASK_FOOTER = "\n\nThe calls above are done. Continue your task, callin
  * Compose the bundle. `maxChars` is a hard ceiling on the returned string.
  */
 export function assembleBundle(entries, maxChars, opts = {}) {
-    const n = entries.length;
+    // A step left out has no response to share the budget with: only the steps
+    // that answered split it.
+    const n = entries.filter((e) => !e.notNeeded).length;
     const anyRecorded = entries.some((e) => e.recorded);
     // A hand-over outranks a sub-task: it says "continue" too, and it also has to
     // say that the plan stopped short. A sub-task outranks the live and mixed
@@ -111,10 +120,22 @@ export function assembleBundle(entries, maxChars, opts = {}) {
                 : LIVE_FOOTER;
     const fixedCost = header.length +
         footer.length +
-        entries.reduce((sum, e) => sum + PER_STEP_OVERHEAD + e.toolName.length + e.input.length, 0);
+        entries.reduce((sum, e) => sum +
+            PER_STEP_OVERHEAD +
+            e.toolName.length +
+            e.input.length +
+            // A left-out step's line, which has no response to take from.
+            (e.notNeeded ? PER_STEP_OVERHEAD + (testWords(e.notNeeded.text)?.length ?? 0) : 0), 0);
     const responseBudget = Math.max(0, maxChars - fixedCost);
     const perResponse = n > 0 ? Math.floor(responseBudget / n) : responseBudget;
     const sections = entries.map((e, i) => {
+        if (e.notNeeded) {
+            // Never "skipped" or "failed": the step was left out on purpose, because
+            // this request does not need it, and nothing is missing for its absence.
+            const why = testWords(e.notNeeded.text);
+            return (`\n\n--- Step ${i + 1}: ${e.toolName} (not needed) ---\n` +
+                `Not run: this request does not need it${why ? ` — it is only for when ${why}` : ""}.`);
+        }
         const response = truncate(e.response, perResponse);
         return (`\n\n--- Step ${i + 1}: ${e.toolName} ---\n` +
             `Call: ${e.input}\n` +