@animalabs/agent-framework 0.26.0 → 0.26.2

package/dist/src/framework.js

@@ -45,7 +45,7 @@ import { safeSlice } from './safe-slice.js';
 import { SEND_TOOLS, bareToolName } from './send-tools.js';
 import { boundedErrorMessage, errorMessage } from './error-message.js';
 import { ProviderWaits, EVERY_MODEL, isReleaseModel, withoutControls } from './provider-waits.js';
-import { nonErrorResultText, toolResultDataToHistoryString, truncateForHistory, DEFAULT_TOOL_RESULT_INLINE_MAX_CHARS, } from './tool-result-history.js';
+import { nonErrorResultText, shownToScript, shownToScriptFromServer, toolResultDataToHistoryString, truncateForHistory, DEFAULT_TOOL_RESULT_INLINE_MAX_CHARS, } from './tool-result-history.js';
 import { TOOL_IMAGE_REF_RE, ToolImageLedger, cutStoredToolResultToFit, formatKeptImageSlots, parseImagePlaceholders, sha256Hex, storedImageSlots, toolResultCutAt, toolResultShare, } from './tool-image-ledger.js';
 import { randomUUID, createHash } from 'node:crypto';
 import { describeCodeExecution, CODE_EXECUTION_TOOL_NAME, isolateSettings, validateCodeExecutionConfig, } from './code-execution/tool-definition.js';
@@ -671,6 +671,63 @@ function announcedDomainsOf(announce) {
 function resumesLogicalTurn(reason) {
     return reason === 'context_budget_restart' || reason === 'tool_result_guard_retry';
 }
+/**
+ * Marks a held turn's retry: the request a provider hold keeps for a turn
+ * whose call failed into it, or whose compile it held with nothing sent.
+ * That turn has begun and not ended: it starts again when the hold releases
+ * (a new start of its open turn, as 0.26.0 started it). So, as a
+ * continuation on its way does (continuesTurn), it keeps its agent's turn
+ * alive meanwhile, passes a quiesce, and goes with an abandon, a stop() or
+ * its agent's removal. A symbol, not a field: hosts build requests too, and
+ * only the framework may say one is a turn's own retry. Spreads and rests
+ * copy it, as every copy of a request the scheduler makes is one.
+ */
+const TURN_RETRY = Symbol('turn-retry');
+/**
+ * The batch a start that carries a turn on (continuesTurn) was merged from,
+ * when the scheduler merged wakes that aren't the turn's into it: every
+ * request it took in, as each was. Until the start takes its turn token it
+ * stands for them all. A scheduler pass that takes it back puts the batch in
+ * its place, each request with its own identity and flags; a quiesce at the
+ * auxiliary park sends the batch back to the scheduler; and a caller's stop
+ * or an abandon that drops the start puts back the batch's wakes, the
+ * requests that don't carry the turn on (dropContinuations), where they run
+ * as a turn of their own, as wakes queued while a turn streams do. Once the
+ * start takes its token the turn reads them, and beginAgentTurn drops the
+ * record. A symbol, as TURN_RETRY is, so spreads and rests copy it.
+ */
+const MERGED_BATCH = Symbol('merged-batch');
+function mergedBatch(request) {
+    return request[MERGED_BATCH];
+}
+/** The wakes of a merged start's batch (MERGED_BATCH): its requests that
+ *  don't carry the turn on. */
+function mergedWakes(request) {
+    return (mergedBatch(request) ?? []).filter((r) => !continuesTurn(r));
+}
+function isTurnRetry(request) {
+    return request[TURN_RETRY] === true;
+}
+/** How to go on sooner than a hold keeping a turn's retry lets the turn go
+ *  on: what surgery's and the puppet's refusals advise. */
+function heldTurnWayOn(statedWait) {
+    return 'a quiesce lets a held turn start when its hold ends and finish, so to go on sooner, end it with quiesce ' +
+        'with abandon: true, which ends it once the quiesce\'s wait for the drain runs out (at once on a host ' +
+        'already quiesced)' +
+        (statedWait
+            ? ", or lift a stated wait with release-provider-wait, so the turn tries again once no host's or " +
+                'acceleration hold binds it'
+            : '');
+}
+/** A copy of a held turn's trigger, marked as its retry (TURN_RETRY). */
+function asTurnRetry(trigger) {
+    return { ...trigger, [TURN_RETRY]: true };
+}
+/** A request that carries its agent's turn on: a continuation of it, or the
+ *  retry a provider hold keeps for it (TURN_RETRY). */
+function continuesTurn(request) {
+    return resumesLogicalTurn(request.reason) || isTurnRetry(request);
+}
 /**
  * The answers dispatchScriptToolCall's safety timer made, when no result came
  * for a script's call: the tool may still be running, or its result was lost,
@@ -678,6 +735,19 @@ function resumesLogicalTurn(reason) {
  * place in the host taken until its run ends.
  */
 const SCRIPT_CALL_NO_RESULT = new WeakSet();
+/**
+ * An MCPL peer's results whose blocks couldn't be given RFC-005's treatment
+ * for a script, because JSON couldn't hold them (dispatchMcplToolCall's
+ * reading), each with why. The failure is the script lane's alone: the
+ * model's lane reads the same answer with no such round trip. So such a
+ * result keeps the peer's own outcome, its blocks dropped, and the trace and
+ * the call's terminal report what the peer answered, as on v0.26.1, while
+ * the script lane's exit answers it as a result it can't convert to JSON
+ * (scriptResultAnswer). A module's result that JSON can't hold differs: no
+ * route can store or send it, so its dispatch makes it an error result for
+ * everyone (checkedToolResult).
+ */
+const SCRIPT_RESULT_UNCONVERTIBLE = new WeakMap();
 /** The last TurnRouting.turnId given out: ids increase, and are unique within the process. */
 let lastTurnId = 0;
 function freshTurnRouting() {
@@ -705,17 +775,27 @@ function ephemeralRunStopped(name, observed) {
 }
 /** The reason on the inference:aborted that ends a turn whose retry stop()
  *  cancelled, whichever frame was waiting to retry: beginAgentTurn's, when
- *  the stream couldn't start, or driveStream's, when it failed once started.
- *  Its inference:failed came first, and this says no retry follows it. */
+ *  the stream couldn't start, or driveStream's, when it failed once started;
+ *  or whose failure a provider hold would have kept for its retry once stop()
+ *  had closed admission (endFailureAtStop). Its inference:failed came first,
+ *  and this says no retry follows it. */
 const RETRY_CANCELLED_BY_STOP = 'a retry waiting while the framework was stopping is dropped before it sends anything';
 /** The reason on the inference:aborted that ends a turn whose start waited to
  *  retry a failed compile across a stop() and a start(): the retry would
  *  revive the earlier lifecycle's turn in the next one. */
 const RETRY_ACROSS_RESTART = 'a retry waiting while the framework was stopped and started again is dropped before it sends anything';
+/** The reason on the inference:aborted that ends a turn whose continuation
+ *  was dropped before it started, other than by an abandon or a stop. */
+const CONTINUATION_DROPPED = "a turn's continuation was dropped before it started";
 function isTurnContinuation(reason) {
     return reason === 'context_budget_restart' || reason === 'tool_results_ready'
         || reason === 'tool_result_guard_retry';
 }
+/** A request a quiesce lets through, so a turn already alive can finish:
+ *  a continuation of the turn, or a held turn's retry (TURN_RETRY). */
+function passesQuiesce(request) {
+    return request !== undefined && (isTurnContinuation(request.reason) || isTurnRetry(request));
+}
 /** Wake sources the framework generates for itself (bounce wakes,
  *  continuations, retries, unsticks, admission requeues). A wake from any
  *  other source — a channel message, a heartbeat or other server event, a
@@ -1187,12 +1267,14 @@ function scriptResultBrief(content) {
 }
 /**
  * What a script gets for a tool result that can't be converted to JSON,
- * such as a cyclic object or a BigInt that an in-process module returned.
+ * such as a cyclic object or a BigInt that an in-process module returned,
+ * or an MCPL peer's blocks nested deeper than JSON.stringify can take.
  * It names the tool, and says the call itself completed, so a script that
  * reports it doesn't invite a blind retry. The host's log gets the same
- * line, since the tool that returned it needs fixing whether or not the
- * script reports it. The reason and the tool's own error are cut to
- * VALUE_CHARS each, so the failure reaches the script whatever its memory.
+ * line, since the tool, a module's or a server's, returns what a script
+ * can't receive, whether or not the script reports it. The reason and the
+ * tool's own error are cut to VALUE_CHARS each, so the failure reaches the
+ * script whatever its memory.
  */
 function unconvertibleScriptResult(toolName, err, ownError) {
     let reason;
@@ -1221,13 +1303,15 @@ const SCRIPT_TEXT_ANSWER_ENVELOPE_BYTES = Buffer.byteLength(JSON.stringify({ con
  * memoryMaxBytes. So the figure moves with memoryMaxBytes. What it can't
  * count: a result's `structured` value, which the measure leaves out and the
  * answer carries as JSON beside the content, and that result's blocks past
- * their text, which the answer carries as they are (each further block's
- * keys, an image's data); nesting past 2,000 levels; and a
+ * their text, which the answer carries as the script lane gives them (each
+ * further block's keys, an image's data); nesting past 2,000 levels; and a
  * parse that needs more of the script's memory than is free, as for JSON
  * dense in small objects or a script already holding most of its memory.
  * Such a result, or one past the figure that doesn't fit, reaches the script
  * as ResultTooLarge, saying the call took effect, and nothing of it is cut or
- * saved.
+ * saved. One the host can't convert to JSON at all, such as one nested deeper
+ * than its runtime's JSON.stringify can take, is answered instead as a
+ * failure naming the tool and saying the call itself completed.
  */
 const scriptResultMaxChars = (memoryMaxBytes) => Math.max(0, Math.floor((Math.min(maxResultBytes(memoryMaxBytes), bufferConstants.MAX_STRING_LENGTH) - SCRIPT_TEXT_ANSWER_ENVELOPE_BYTES) / 6));
 /**
@@ -1918,6 +2002,15 @@ export class AgentFramework {
     // and its settle except that turn's own blocks, and, before its checkpoint,
     // the inputs its start writes (flushForStart).
     activeTurnTokens = new Map();
+    /** Each running scheduler pass's requests, which it took from
+     *  pendingRequests: it holds those of the agents it hasn't taken up yet
+     *  while it awaits an earlier agent's start, so a continuation among them
+     *  is still on its way (pendingContinuationAgents). */
+    passRequests = new Set();
+    /** Continuations whose start waits on provider admission behind an
+     *  auxiliary call, in no queue meanwhile. A drop takes one out and gives
+     *  its admission back; the park, woken, then finds it gone. */
+    parkedContinuations = new Set();
     /** Each turn whose settle has ended it (settleAgent, endDroppedTurn), for
      *  its agent's scripts: its start's teardown can still hold the agent's
      *  token, and a turn that has ended isn't live (liveTurns). A later start
@@ -1962,12 +2055,14 @@ export class AgentFramework {
      * is still the agent's, so a start that ends after a later frame opened
      * one, such as its retry's stream waiting to retry, leaves that one open.
      * An operator's abandon marks the window, and the frame's check collects
-     * the mark, which goes with the window. abortInference() and the abandon
-     * count a turn with no stream only here; a stop made anywhere else, as
-     * while an agent is idle, a turn finishes its last delivery or a provider
-     * hold has parked it, has no check to end it, and the next start drops
-     * it. Keyed by the Agent, so a replacement agent under the same name
-     * never shares one.
+     * the mark, which goes with the window. A stop of a turn with no stream
+     * lands here, or, for a turn whose continuation or retry is on its way (a
+     * provider hold's, a park's, the queue's or a pass's), through
+     * abortInference(), an abandon or stop(), which drop that continuation or
+     * retry (dropContinuations); a stop made anywhere else, as while an agent
+     * is idle or a turn finishes its last delivery, has no check to end it,
+     * and the next start drops it. Keyed by the Agent, so a replacement agent
+     * under the same name never shares one.
      */
     checkAhead = new Map();
     /** Structured calls executed in the current logical turn. Unlike the
@@ -2050,7 +2145,15 @@ export class AgentFramework {
     // config.codeExecution.enabled: its settings, and every agent's scripts,
     // each in a process of its own on the engine (AgentScripts). Waiters
     // resolve script-inner tool calls dispatched through the normal
-    // dispatchToolCall path.
+    // dispatchToolCall path. A waiter's route is where the dispatch sent its
+    // call: `toServer` is set when it went to a server's own tool (an MCPL or
+    // MCP-only peer's), so the script lane's exit treats every other result as
+    // a module's (scriptResultAnswer), by where the call went rather than by a
+    // name lookup a connect or disconnect can change while it runs. A
+    // framework tool that talks to a server itself, such as a channel tool,
+    // builds its own result, which counts as a module's. A caller of
+    // dispatchScriptToolCall that passes no route gets one left false, the
+    // reading that withholds more.
     codeExecution = null;
     scriptToolWaiters = new Map();
     /** Per agent, a round that called code_execution and waits for those calls'
@@ -3026,6 +3129,16 @@ export class AgentFramework {
         // Retained tool images are per-process by design; a retained stopped
         // framework must not keep up to the whole ledger budget referenced.
         this.toolImageLedgers.clear();
+        // A turn whose continuation is still on its way ends with the stop, as
+        // a turn's start a stop reaches does: the continuation would start only
+        // after a start(), in a lifecycle where its logical turn is gone
+        // (openLogical, below). Before the holds and the parks go, so the
+        // continuation leaves them with its turn.
+        step(() => {
+            for (const agentName of this.pendingContinuationAgents()) {
+                this.dropContinuations(agentName, { kind: 'shutdown', why: 'the framework is stopping' });
+            }
+        });
         // A stopped host must never hang behind its own cooldown.
         step(() => this.cancelProviderAdmission());
         // An open logical turn doesn't survive a stop: a start after a restart
@@ -3619,6 +3732,23 @@ export class AgentFramework {
             a.coalescingSubject === b.coalescingSubject && batchSubjects(a) === batchSubjects(b) &&
             a.readsDeferredWrite === b.readsDeferredWrite;
     }
+    /** Keep `request` among a hold's `held` requests, once by
+     *  sameInferenceRequest. A held turn's retry (TURN_RETRY) whose equal is
+     *  already held marks that one, so the hold still keeps the turn alive. */
+    holdRequest(held, request) {
+        const same = held.find((r) => this.sameInferenceRequest(r, request));
+        if (!same) {
+            held.push(request);
+            return;
+        }
+        if (isTurnRetry(request))
+            same[TURN_RETRY] = true;
+        // A merged start's batch (MERGED_BATCH) stays recorded on the request
+        // kept in its place, which then stands for it, as the start did.
+        const batch = mergedBatch(request);
+        if (batch)
+            same[MERGED_BATCH] = [...new Set([...(mergedBatch(same) ?? []), ...batch])];
+    }
     consultProviderHold(error, agentName) {
         if (!this.providerHoldHook)
             return undefined;
@@ -3676,15 +3806,21 @@ export class AgentFramework {
         // failure streak), and the wait applies to the calls that follow it.
         if (!acceleration && !hostHold) {
             return wait !== undefined && isMembraneError(error) && error.retryable === true
-                && this.holdForProviderWait(agent, wait, trigger ? [trigger] : [], true);
+                && this.holdForProviderWait(agent, wait, trigger ? [asTurnRetry(trigger)] : [], true);
         }
+        // As in holdForProviderWait: once stop() has closed admission, nothing is
+        // held, and nothing started.
+        if (this.providerAdmissionClosed)
+            return true;
         const now = Date.now();
         const pacing = hostHold ? undefined : this.accelerationCooldownMs(agent.name, error);
         const delayMs = hostHold ? hostHold.holdMs : pacing.delayMs;
         const existing = this.providerAccelerationCooldowns.get(agent.name);
         const held = existing?.heldRequests ?? [];
-        if (trigger && !held.some((r) => this.sameInferenceRequest(r, trigger)))
-            held.push(trigger);
+        // The failed turn's own request, kept as its retry (TURN_RETRY). An
+        // auxiliary call's failure passes no trigger: it holds no turn of its own.
+        if (trigger)
+            this.holdRequest(held, asTurnRetry(trigger));
         if (existing)
             clearTimeout(existing.timer);
         const timer = setTimeout(() => this.releaseProviderAccelerationCooldown(agent.name), Math.min(delayMs, MAX_TIMER_DELAY_MS));
@@ -3695,7 +3831,8 @@ export class AgentFramework {
             // The stated wait (recorded above for agent.model) set this hold's
             // length: an operator release of it returns the hold to AF's own pacing.
             ...(pacing?.stated ? { statedWait: { model: agent.model, ownUntil: now + pacing.ownMs } } : {}),
-            ...(auxiliary && (!existing || existing.auxiliaryOrigin) ? { auxiliaryOrigin: true } : {}) });
+            ...(auxiliary && (!existing || existing.auxiliaryOrigin) ? { auxiliaryOrigin: true } : {}),
+            ...(existing?.emptiedByDrop && held.length === 0 ? { emptiedByDrop: true } : {}) });
         if (auxiliary && !existing) {
             console.error(`[provider-cooldown] agent=${agent.name} host hold (${hostHold.reason}) from an auxiliary call — ` +
                 `holding primary/auxiliary for ${delayMs}ms`);
@@ -3736,7 +3873,7 @@ export class AgentFramework {
             return undefined;
         if (this.conversationAgentHomes.has(agent.name)) {
             const wait = this.recordProviderWait(agent.name, agent.model, error);
-            return error.retryable === true && wait !== undefined && this.holdForProviderWait(agent, wait, trigger ? [trigger] : [], true)
+            return error.retryable === true && wait !== undefined && this.holdForProviderWait(agent, wait, trigger ? [asTurnRetry(trigger)] : [], true)
                 ? 'held'
                 : undefined;
         }
@@ -3808,9 +3945,13 @@ export class AgentFramework {
                     ? `no longer holds primary turns: the primary model is now ${model} (the wait stays recorded)`
                     : `primary hold ended after ${Date.now() - cooldown.startedAt}ms`));
         }
-        if (cooldown.auxiliaryOrigin && cooldown.heldRequests.length === 0) {
-            // Nobody asked for an inference while parked: just reopen the gate.
-            console.error(`[provider-cooldown] agent=${agentName} auxiliary hold released after ${Date.now() - cooldown.startedAt}ms`);
+        if ((cooldown.auxiliaryOrigin || cooldown.emptiedByDrop) && cooldown.heldRequests.length === 0) {
+            // Nobody asked for an inference while parked, or what was held was a
+            // continuation since dropped with its turn: just reopen the gate. A
+            // primary the hold left pending won't run, so its recovery ends.
+            console.error(`[provider-cooldown] agent=${agentName} ${cooldown.auxiliaryOrigin ? 'auxiliary hold' : 'hold, its held continuation dropped,'} released after ${Date.now() - cooldown.startedAt}ms`);
+            if (cooldown.emptiedByDrop)
+                this.endPendingPrimary(agentName);
             this.flushAuxiliaryAdmission(agentName);
             return;
         }
@@ -3887,19 +4028,33 @@ export class AgentFramework {
      * Hold this agent's primary turns for a provider wait on its model. The
      * requests are kept and released together, into one fresh compile, when
      * the wait ends: the same path an acceleration cooldown takes, without
-     * parking auxiliary calls to other models.
+     * parking auxiliary calls to other models. `report`, once the wait is
+     * found to bind, runs before anything is held: a caller that reports its
+     * turn's end there (inference:failed) does so before the hold takes the
+     * turn's retry, as every failure site does.
      */
-    holdForProviderWait(agent, wait, requests, failed = false) {
+    holdForProviderWait(agent, wait, requests, failed = false, report) {
         const now = Date.now();
         const until = wait.until ?? Number.POSITIVE_INFINITY;
         if (until <= now)
             return false;
+        report?.();
+        // stop() has cleared every hold and dropped every turn on its way: a
+        // failure or start reaching here after it holds nothing, so no retry
+        // outlives the stop as a turn still alive. Nothing is started either.
+        if (this.providerAdmissionClosed)
+            return true;
+        // A listener of the report may have released the wait
+        // (releaseProviderWait) before anything was held: nothing binds now, so
+        // the requests start, as the release of an installed hold starts them.
+        if (report && !this.providerWaits?.active(agent.name, wait.model)) {
+            this.pendingRequests.push(...requests);
+            return true;
+        }
         const existing = this.providerAccelerationCooldowns.get(agent.name);
         const held = existing?.heldRequests ?? [];
-        for (const request of requests) {
-            if (!held.some((r) => this.sameInferenceRequest(r, request)))
-                held.push(request);
-        }
+        for (const request of requests)
+            this.holdRequest(held, request);
         // An acceleration or host hold already parks the whole agent; its release
         // re-checks this wait at admission.
         if (existing && existing.waitModel === undefined)
@@ -4479,9 +4634,11 @@ export class AgentFramework {
     }
     /**
      * Abort an in-flight inference for an agent. True when there was one to
-     * stop: a stream, or a turn with no stream and one of its checks ahead (its
+     * stop: a stream; a turn with no stream and one of its checks ahead (its
      * hooks or compile, a wait to retry, the tool-result guard's wait), which
-     * ends at that check, before it sends anything more.
+     * ends at that check, before it sends anything more; or a turn whose
+     * continuation or retry is on its way (queued, kept by a provider hold,
+     * parked at admission or in a scheduler pass), which ends here.
      */
     abortInference(agentName, reason) {
         const agent = this.agents.get(agentName);
@@ -4511,6 +4668,20 @@ export class AgentFramework {
             checkWindow.wake?.();
             return true;
         }
+        // A turn whose continuation or retry is on its way (a budget restart or
+        // a guard retry, or a failed turn's retry a provider hold keeps:
+        // pendingContinuationAgents) ends here, as a stop of a turn's start ends
+        // one, whether or not the frame that handed it on has let go of its
+        // token yet (that frame ends on its own and settles nothing more): the
+        // continuation or retry is dropped, with one inference:aborted carrying
+        // the stop's reason. Wakes that arrived meanwhile aren't the turn's, and
+        // still run; a hold of such wakes alone keeps no turn, and has nothing to
+        // stop. Every failure site reports inference:failed before a hold takes
+        // the retry, so a listener of it finds nothing held, and reports false.
+        if (!result && this.pendingContinuationAgents().has(agentName)) {
+            this.dropContinuations(agentName, { kind: 'caller', reason, why: 'a stop ended the turn' });
+            return true;
+        }
         return !!result;
     }
     /**
@@ -5393,16 +5564,83 @@ export class AgentFramework {
         }
         return n;
     }
+    /**
+     * A continuation the framework makes for a turn (a budget restart's, which
+     * it queues, or a tool-result guard's retry, which its frame starts at
+     * once) holds no turn token until its start takes one. Once its turn's
+     * frame has let go of its token, its start can wait in the queue, a
+     * provider hold, a park on admission or a scheduler pass's hands. Its turn
+     * is alive meanwhile. So is a turn whose call failed into a provider hold,
+     * which keeps the turn's retry (TURN_RETRY), until that retry starts,
+     * wherever it waits. These are the agents with one on its way. A
+     * `tool_results_ready` continuation follows a tool round left waiting with
+     * no stream, which only the direct Agent API makes (Agent's
+     * runInferenceWithInjections; the framework's own rounds wait with their
+     * stream, enterWaitingForTools). Its caller owns that turn's timing, so it
+     * isn't counted.
+     */
+    pendingContinuationAgents() {
+        const agents = new Set();
+        const add = (r) => { if (continuesTurn(r))
+            agents.add(r.agentName); };
+        // Read defensively: a framework built from the prototype, as the
+        // operator tests build one, sets none of these.
+        for (const r of this.pendingRequests ?? [])
+            add(r);
+        for (const cooldown of this.providerAccelerationCooldowns?.values() ?? [])
+            for (const r of cooldown.heldRequests)
+                add(r);
+        for (const r of this.parkedContinuations ?? [])
+            add(r);
+        for (const pass of this.passRequests ?? [])
+            for (const requests of pass.values())
+                for (const r of requests)
+                    add(r);
+        return agents;
+    }
+    /** The agents with a turn alive: holding a turn token, or with a
+     *  continuation of their turn, or its retry, on its way. */
+    turnHolders() {
+        const holders = this.pendingContinuationAgents();
+        for (const name of this.activeTurnTokens.keys())
+            holders.add(name);
+        return holders;
+    }
+    hasTurn(agentName) {
+        return this.activeTurnTokens.has(agentName) || this.pendingContinuationAgents().has(agentName);
+    }
+    /** The provider hold keeping `agentName`'s turn for its retry (TURN_RETRY),
+     *  in words naming its end and its reason, and whether a stated wait holds
+     *  it; undefined when no hold keeps one. */
+    heldTurnRetry(agentName) {
+        // Optional, as pendingContinuationAgents reads it: a framework built from
+        // its prototype, as some suites build one, has no map of holds.
+        const hold = this.providerAccelerationCooldowns?.get(agentName);
+        if (!hold?.heldRequests.some(isTurnRetry))
+            return undefined;
+        // A deadline past what a Date can name (an infinite wait, or a stated
+        // one too long for an instant) is one only a release ends.
+        const end = new Date(hold.until);
+        const until = Number.isNaN(end.getTime()) ? 'until released' : `until ${end.toISOString()}`;
+        return {
+            says: `a provider hold keeps its turn to start again, ${until}: ${hold.reason}`,
+            // release-provider-wait lifts a stated wait's hold, not a host's or an
+            // acceleration cooldown's own pacing.
+            statedWait: hold.waitModel !== undefined || hold.statedWait !== undefined,
+        };
+    }
     getHostModeStatus() {
         const parkedAdmissions = this.parkedAdmissionCount();
+        const holders = this.turnHolders();
         return {
             quiesced: this.quiesced,
             ...(this.quiesceReason ? { reason: this.quiesceReason } : {}),
             ...(this.quiescedAt !== undefined ? { since: this.quiescedAt } : {}),
-            drained: this.activeTurnTokens.size === 0 && parkedAdmissions === 0,
-            activeTurns: this.activeTurnTokens.size,
+            drained: holders.size === 0 && parkedAdmissions === 0,
+            activeTurns: holders.size,
+            activeTurnAgents: [...holders].sort(),
             parkedAdmissions,
-            gatedRequests: this.pendingRequests.filter((r) => !isTurnContinuation(r.reason)).length,
+            gatedRequests: this.pendingRequests.filter((r) => !passesQuiesce(r)).length,
             backgroundScripts: this.codeExecution?.scripts.leftRunning() ?? 0,
             deferredWrites: this.deferredMessages.length,
             ...(this.lastUnabandonable.length > 0 ? { unabandonable: [...this.lastUnabandonable] } : {}),
@@ -5417,8 +5655,10 @@ export class AgentFramework {
     /**
      * Enter quiesce mode: write the deferred-write queue, persist the flag,
      * suppress gate deliveries, pause all MCPL data planes, and wait for
-     * in-flight turns to settle (turn-alive is `activeTurnTokens`, which spans
-     * dequeue → settled teardown). Idempotent, but for the queue's write, which
+     * in-flight turns to settle (turn-alive is a turn token, which spans
+     * dequeue → settled teardown, a continuation of the turn on its way to its
+     * start, or the turn's retry, which a provider hold keeps or which waits
+     * to start: turnHolders). Idempotent, but for the queue's write, which
      * every call makes first: when the queue can't reach disk, because its
      * write fails or it's over the cap, the call rejects with a
      * QuiesceBlockedError and the host's mode as it was, unless it has
@@ -5428,7 +5668,10 @@ export class AgentFramework {
      * On drain timeout the host STAYS quiesced (`drained: false` in the
      * result); with `abandon: true` the undrained streams are cancelled via a
      * dedicated cancel kind that settles the turn without feeding the
-     * inference-failure accounting.
+     * inference-failure accounting, and a turn whose continuation or retry
+     * hasn't started ends with it dropped. Drain covers the framework's
+     * own turns: a caller of the direct Agent API (`Agent.runInference`) owns
+     * its turns' timing.
      */
     async quiesce(opts) {
         this.refuseOperatorAfterStop('quiesce');
@@ -5445,13 +5688,13 @@ export class AgentFramework {
             // out undrained must be escalatable with a second quiesce({abandon})
             // without resume()+re-quiesce (which would reopen data planes and
             // release parked wakes mid-surgery).
-            if (opts?.abandon && this.activeTurnTokens.size > 0) {
+            if (opts?.abandon && this.turnHolders().size > 0) {
                 const unabandonable = await this.abandonActiveTurns();
                 this.emitTrace({
                     type: 'host:quiesce',
                     ...(this.quiesceReason ? { reason: this.quiesceReason } : {}),
-                    drained: this.activeTurnTokens.size === 0,
-                    activeTurns: this.activeTurnTokens.size,
+                    drained: this.turnHolders().size === 0,
+                    activeTurns: this.turnHolders().size,
                     abandoned: true,
                     ...(unabandonable.length > 0 ? { unabandonable } : {}),
                 });
@@ -5476,7 +5719,7 @@ export class AgentFramework {
         this.quiescedAt = since;
         this.lastUnabandonable = [];
         console.error(`[host-mode] quiescing${opts?.reason ? ` (${opts.reason})` : ''}: parking wakes, ` +
-            `pausing MCPL data planes, draining ${this.activeTurnTokens.size} in-flight turn(s)`);
+            `pausing MCPL data planes, draining ${this.turnHolders().size} in-flight turn(s)`);
         this.eventGate?.setQuiesced(true);
         for (const connection of this.mcplServerRegistry?.getAllServers() ?? []) {
             connection.pauseDataPlane();
@@ -5496,7 +5739,7 @@ export class AgentFramework {
         // continuation's quiesce recheck requeues it — wait for that to happen).
         while (this.quiesced &&
             !this.queue?.isClosed &&
-            (this.activeTurnTokens.size > 0 || this.parkedAdmissionCount() > 0) &&
+            (this.turnHolders().size > 0 || this.parkedAdmissionCount() > 0) &&
             Date.now() < deadline) {
             await new Promise((resolve) => setTimeout(resolve, 250));
         }
@@ -5517,7 +5760,7 @@ export class AgentFramework {
         }
         let abandoned = false;
         let unabandonable = [];
-        if (this.activeTurnTokens.size > 0 && opts?.abandon) {
+        if (this.turnHolders().size > 0 && opts?.abandon) {
             abandoned = true;
             unabandonable = await this.abandonActiveTurns();
             if (!this.quiesced)
@@ -5547,7 +5790,19 @@ export class AgentFramework {
      *  the already-quiesced escalation path. */
     async abandonActiveTurns() {
         const unabandonable = [];
+        // A turn whose continuation is still on its way ends with the
+        // continuation dropped. Its stream has ended; a frame still letting go of
+        // its token ends on its own, and settles nothing, since it handed the turn
+        // to the continuation.
+        const handedOff = new Set();
+        for (const agentName of this.pendingContinuationAgents()) {
+            console.error(`[host-mode] abandoning ${agentName}'s turn before its continuation or held retry starts: it is dropped`);
+            this.dropContinuations(agentName, { kind: 'quiesce_abandoned', why: 'its turn was abandoned' });
+            handedOff.add(agentName);
+        }
         for (const agentName of [...this.activeTurnTokens.keys()]) {
+            if (handedOff.has(agentName))
+                continue;
             const agent = this.agents.get(agentName);
             const state = agent?.state;
             const stream = state && 'stream' in state ? state.stream : undefined;
@@ -7496,6 +7751,9 @@ export class AgentFramework {
             this.activeTurnTokens.delete(agent.name);
             this.activeTurnTriggers.delete(agent.name);
             this.logicalTurnToolCalls.delete(agent);
+            // A continuation of its turn still on its way goes too: the run, and
+            // with it the turn, has ended above.
+            this.dropContinuations(agent.name, null);
         }
     }
     /**
@@ -8887,7 +9145,8 @@ export class AgentFramework {
      * by stop() while it runs.
      *
      * The branch moves under every agent sharing the store, so the switch
-     * reserves the store as a surgery does: every agent must be idle, or it is
+     * reserves the store as a surgery does: every agent must be idle with no
+     * turn alive (no continuation or held retry of one on its way), or it is
      * refused (OperatorActionError 'agent-busy'), and no turn starts until the
      * switch is done.
      */
@@ -9101,18 +9360,35 @@ export class AgentFramework {
             throw new OperatorActionError('agent-busy', `Cannot ${verb}: a live ${this.surgeryHold.verb} for ${this.surgeryHold.agentName} is already in progress`);
         }
         const busy = [];
+        let heldTurns = false;
+        let statedWaits = false;
         for (const [name, a] of this.agents) {
-            if (a.state.status !== 'idle')
+            if (a.state.status !== 'idle') {
                 busy.push(`${name} is ${a.state.status}`);
-            else if (this.activeTurnTokens.has(name))
+                continue;
+            }
+            if (!this.hasTurn(name))
+                continue;
+            // A provider hold keeping the turn's retry is named: a quiesce alone
+            // doesn't end that turn.
+            const held = this.heldTurnRetry(name);
+            if (held) {
+                heldTurns = true;
+                if (held.statedWait)
+                    statedWaits = true;
+                busy.push(`${name} is idle+turn-alive (${held.says})`);
+            }
+            else {
                 busy.push(`${name} is idle+turn-alive`);
+            }
         }
         for (const name of this.activeTurnTokens.keys()) {
             if (!this.agents.has(name))
                 busy.push(`${name} is turn-alive`);
         }
         if (busy.length > 0) {
-            throw new OperatorActionError('agent-busy', `Cannot ${verb} while ${busy.join(', ')} — every agent sharing the store must be idle (quiesce the host first)`);
+            throw new OperatorActionError('agent-busy', `Cannot ${verb} while ${busy.join(', ')} — every agent sharing the store must be idle (quiesce the host first)` +
+                (heldTurns ? `; ${heldTurnWayOn(statedWaits)}` : ''));
         }
         const reserved = new Map();
         for (const name of this.agents.keys()) {
@@ -9894,9 +10170,10 @@ export class AgentFramework {
             // Direct inference requests (e.g. runEphemeralToCompletion) bypass the
             // event queue — without this the loop can exit before they're drained.
             // While quiesced, gate-parked requests are NOT progress and must not
-            // block idle (only a budget restart can still run); identity-equivalent
-            // to `.length > 0` when not quiesced.
-            this.pendingRequests.some((r) => !this.quiesced || isTurnContinuation(r.reason)) ||
+            // block idle; what a quiesce lets through (passesQuiesce: a turn's
+            // continuation, or a held turn's retry) can still run, and is.
+            // Identity-equivalent to `.length > 0` when not quiesced.
+            this.pendingRequests.some((r) => !this.quiesced || passesQuiesce(r)) ||
             this.activeStreams.size > 0 ||
             Array.from(this.agents.values()).some((a) => a.state.status !== 'idle')) {
             await this.processNextEvent();
@@ -10087,7 +10364,7 @@ export class AgentFramework {
                 // was killed while the call ran: the result reaches no one, but the
                 // call did finish.
                 this.toolLifecycleEmitter?.onResult(event.agentName, event.callId, event.result);
-                scriptWaiter(event.result);
+                scriptWaiter.resolve(event.result);
                 return;
             }
             // RFC-007: the call's terminal (completed / failed) — the result
@@ -10513,7 +10790,27 @@ export class AgentFramework {
                         }
                         this.emitTrace({ type: 'inference:turn_ended', agentName: agent.name });
                     }
+                    else if ((overBudget || overPhysical) && this.providerAdmissionClosed) {
+                        // A stopping framework starts no continuation: the turn ends with
+                        // its stream, as stop() ends a live stream's turn.
+                        if (currentState.stream)
+                            this.frameworkCancelledStreams.set(`${agent.name}:${agent.streamId}`, 'shutdown');
+                        agent.cancelStream();
+                    }
                     else if (overBudget || overPhysical) {
+                        // The continuation is queued, and the stream cancelled, before the
+                        // boundary's usage report and the restart's trace, so a listener
+                        // that stops or quiesces the host on either finds the turn waiting
+                        // for its continuation, with nothing left of the stream to end.
+                        const continuation = {
+                            agentName: agent.name,
+                            reason: 'context_budget_restart',
+                            source: 'framework',
+                            timestamp: Date.now(),
+                            suppressProse: this.activeTurnTriggers.get(agent.name)?.suppressProse,
+                            silentHeartbeat: this.activeTurnTriggers.get(agent.name)?.silentHeartbeat,
+                        };
+                        this.pendingRequests.push(continuation);
                         // Context budget exceeded: break the stream, let compile() compress.
                         // Mark the cancel as framework-initiated BEFORE cancelling: the
                         // membrane delivers `aborted` before the restart bumps streamId,
@@ -10521,13 +10818,23 @@ export class AgentFramework {
                         // a terminal failure — rejecting an ephemeral's promise mid-run
                         // and emitting a spurious inference:exhausted (same race shape as
                         // endTurn above).
-                        if (currentState.stream) {
+                        if (currentState.stream)
                             this.frameworkCancelledStreams.set(`${agent.name}:${agent.streamId}`, 'budget_restart');
-                            // Its rounds were billed; the restart opens a fresh stream
-                            // with its own usage.
-                            this.streamBoundaryEnds.get(currentState.stream)?.(overBudget ? 'context_budget' : 'physical_window');
+                        try {
+                            agent.cancelStream();
+                        }
+                        catch (error) {
+                            // The cancel failed and the stream is still live, so the turn
+                            // has no continuation: take it back out of the queue.
+                            this.pendingRequests = this.pendingRequests.filter((r) => r !== continuation);
+                            throw error;
+                        }
+                        finally {
+                            // Its rounds were billed, even when the cancel throws; the
+                            // restart opens a fresh stream with its own usage.
+                            if (currentState.stream)
+                                this.streamBoundaryEnds.get(currentState.stream)?.(overBudget ? 'context_budget' : 'physical_window');
                         }
-                        agent.cancelStream();
                         this.emitTrace({
                             type: 'inference:stream_restarted',
                             agentName: agent.name,
@@ -10538,14 +10845,6 @@ export class AgentFramework {
                             inputTokens: overBudget ? agent.lastStreamInputTokens : projectedRealTokens,
                             budget: overBudget ? agent.maxStreamTokens : (agent.physicalWindowTokens ?? 0),
                         });
-                        this.pendingRequests.push({
-                            agentName: agent.name,
-                            reason: 'context_budget_restart',
-                            source: 'framework',
-                            timestamp: Date.now(),
-                            suppressProse: this.activeTurnTriggers.get(agent.name)?.suppressProse,
-                            silentHeartbeat: this.activeTurnTriggers.get(agent.name)?.silentHeartbeat,
-                        });
                     }
                     else if (currentState.stream) {
                         // What this round appends is in the next call's prompt. If that
@@ -11306,6 +11605,8 @@ export class AgentFramework {
      */
     disposeConversationAgent(agentName) {
         this.closingConversationAgents.delete(agentName);
+        // A continuation of its turn still on its way goes with it.
+        this.dropContinuations(agentName, { kind: 'dropped', why: 'its agent was disposed' });
         const channelId = this.conversationAgentHomes.get(agentName);
         const agent = this.agents.get(agentName);
         // A fork stop() ends can still be running: its stream, its tool round.
@@ -11429,9 +11730,12 @@ export class AgentFramework {
         // (request dropped as stale, inference policy veto) would otherwise stay
         // registered forever. No turn, no active stream and no pending request =
         // done. A turn holds its token from dequeue, through its hooks and
-        // compile, before its stream registers, so a fork mid-compile is busy.
+        // compile, before its stream registers, so a fork mid-compile is busy;
+        // and a turn is alive while its continuation or a provider hold's retry
+        // of it is on its way (hasTurn), so a closure turn held for its retry
+        // finishes when the hold ends.
         for (const agentName of [...this.closingConversationAgents]) {
-            if (!this.activeTurnTokens.has(agentName) &&
+            if (!this.hasTurn(agentName) &&
                 !this.activeStreams.has(agentName) &&
                 !this.pendingRequests.some((r) => r.agentName === agentName)) {
                 this.disposeConversationAgent(agentName);
@@ -11780,9 +12084,19 @@ export class AgentFramework {
             recordReceipt: (record) => {
                 // Written now, not at the throttled flush: an acknowledged acceptance
                 // must not lose its receipt, the subject's birth, or (deferred) the
-                // accepted work itself to a crash. A failure here fails the acceptance.
+                // accepted work itself to a crash. A failure here fails the answer:
+                // the coalescer keeps the receipt, and the producer's retry writes it
+                // again, with the subject's state as it is then. So a record whose
+                // write failed leaves the list: a later write would carry it after
+                // the batch it holds had moved on.
                 this.coalescingRecentReceipts.push(record);
-                this.store.setStateJson(COALESCING_RECENT_ID, this.coalescingRecentReceipts);
+                try {
+                    this.store.setStateJson(COALESCING_RECENT_ID, this.coalescingRecentReceipts);
+                }
+                catch (error) {
+                    this.coalescingRecentReceipts.pop();
+                    throw error;
+                }
             },
             // The acceptance of coalesced work (deferred included) is observed
             // here, once; its later delivery reuses the frozen envelope.
@@ -11904,6 +12218,9 @@ export class AgentFramework {
         }
         catch (err) {
             console.error('[coalescing] could not persist coalescing state:', err);
+            // Still unsaved: the next persist, or the stop's flush, writes it. No
+            // timer of its own, so a store that keeps failing isn't retried here.
+            this.coalescingSnapshotDirty ??= snapshot;
         }
     }
     /** Serialize both lanes' admissions: create, edit and delete of one subject stay ordered. */
@@ -12205,6 +12522,24 @@ export class AgentFramework {
         for (const cooldown of this.providerAccelerationCooldowns.values()) {
             cooldown.heldRequests = cooldown.heldRequests.filter((r) => r.coalescingSubject !== subject);
         }
+        // A wake of the subject's merged into a start that carries a turn on
+        // (MERGED_BATCH) is withdrawn from the start's batch, so no stop puts
+        // it back and no pass unpacks it.
+        const unrecord = (r) => {
+            const batch = mergedBatch(r);
+            if (batch?.some((w) => w.coalescingSubject === subject)) {
+                r[MERGED_BATCH] = batch.filter((w) => w.coalescingSubject !== subject);
+            }
+        };
+        for (const r of this.pendingRequests)
+            unrecord(r);
+        for (const cooldown of this.providerAccelerationCooldowns.values())
+            cooldown.heldRequests.forEach(unrecord);
+        for (const r of this.parkedContinuations ?? [])
+            unrecord(r);
+        for (const pass of this.passRequests ?? [])
+            for (const requests of pass.values())
+                requests.forEach(unrecord);
     }
     /**
      * A placement in the deferred queue is upgraded in place once the flush has
@@ -12532,15 +12867,26 @@ export class AgentFramework {
         }
         return undefined;
     }
+    /** One scheduler pass, whose requests stay visible as on their way until
+     *  it takes their agent up (passRequests). */
     async processInferenceRequests() {
         if (this.pendingRequests.length === 0) {
             return;
         }
+        const requestsByAgent = new Map();
+        this.passRequests?.add(requestsByAgent);
+        try {
+            await this.runInferencePass(requestsByAgent);
+        }
+        finally {
+            this.passRequests?.delete(requestsByAgent);
+        }
+    }
+    async runInferencePass(requestsByAgent) {
         const STALE_REQUEST_MS = 30_000;
         const now = Date.now();
         const state = this.createFrameworkState();
         // Group requests by agent
-        const requestsByAgent = new Map();
         for (const req of this.pendingRequests) {
             const existing = requestsByAgent.get(req.agentName) ?? [];
             existing.push(req);
@@ -12551,6 +12897,14 @@ export class AgentFramework {
         // Check each agent
         for (const [agentName, groupedRequests] of requestsByAgent) {
             let requests = groupedRequests;
+            // Taken up now: from here to its start's turn token (or its hold or
+            // park) nothing awaits, so the requests leave the pass's map, which
+            // shows only what the pass still holds while it awaits a start.
+            requestsByAgent.delete(agentName);
+            // A drop while this pass awaited an earlier agent's start can have
+            // taken every request of this agent's (dropContinuations).
+            if (requests.length === 0)
+                continue;
             const agent = this.agents.get(agentName);
             if (!agent) {
                 // Agent not found — request is orphaned. Emit warning and drop.
@@ -12563,6 +12917,10 @@ export class AgentFramework {
                     oldestRequestAge: now - oldest,
                 });
                 console.error(`[inference-dropped] agent=${agentName} reason=agent_not_found requests=${requests.length}`);
+                // A continuation among them leaves its turn to end here.
+                if (requests.some(continuesTurn)) {
+                    this.endContinuedTurn(agentName, { kind: 'dropped', why: 'its agent is gone' });
+                }
                 continue;
             }
             const providerCooldown = this.providerAccelerationCooldowns?.get(agentName);
@@ -12571,11 +12929,8 @@ export class AgentFramework {
                 // selected now, the turn proceeds (the wait stays recorded).
                 const otherModel = providerCooldown.waitModel !== undefined && providerCooldown.waitModel !== agent.model;
                 if (!otherModel && (now < providerCooldown.until || this.extendHostProviderHold(agentName, providerCooldown))) {
-                    for (const req of requests) {
-                        if (!providerCooldown.heldRequests.some((r) => this.sameInferenceRequest(r, req))) {
-                            providerCooldown.heldRequests.push(req);
-                        }
-                    }
+                    for (const req of requests)
+                        this.holdRequest(providerCooldown.heldRequests, req);
                     const recovery = this.providerAccelerationRecoveries.get(agentName);
                     if (recovery)
                         recovery.heldRequests = providerCooldown.heldRequests.length;
@@ -12591,6 +12946,16 @@ export class AgentFramework {
                     recovery.releasedAt = now;
                 requests = [...providerCooldown.heldRequests, ...requests];
             }
+            // A start that carries a turn on and came back before it took its
+            // token stands for the batch it was merged from (MERGED_BATCH),
+            // including one a hold released just now. The batch takes its place,
+            // each request as it was, judged one by one from here: a wait holds
+            // them apart, a quiesce parks the wakes while the turn's request
+            // passes, and the read check and the policy decide on them all; the
+            // merge below records the batch anew.
+            if (requests.some((r) => mergedBatch(r) !== undefined)) {
+                requests = requests.flatMap((r) => mergedBatch(r) ?? [r]);
+            }
             // A provider's stated wait on this agent's primary model, including one
             // recorded before a restart, holds the turn until it passes. An
             // ephemeral run records nothing, its name being single-use, so no wait,
@@ -12624,9 +12989,10 @@ export class AgentFramework {
             // bounds a multi-day maintenance window's accumulation.
             if (this.quiesced) {
                 // Continuations of a held turn (budget restart, non-streaming tool
-                // results) pass; everything else parks.
-                const passThrough = requests.filter((r) => isTurnContinuation(r.reason));
-                const parked = requests.filter((r) => !isTurnContinuation(r.reason));
+                // results) pass, and so does a held turn's retry (passesQuiesce), so
+                // a turn alive at the quiesce can finish; everything else parks.
+                const passThrough = requests.filter((r) => passesQuiesce(r));
+                const parked = requests.filter((r) => !passesQuiesce(r));
                 // Coalesce per (reason, addressed): every channel wake shares one
                 // reason, so keying on reason alone would let an ambient message
                 // parked later evict a DM/mention parked earlier — and the
@@ -12652,7 +13018,10 @@ export class AgentFramework {
                 requests.length = 0;
                 requests.push(...passThrough);
             }
-            const turnAlive = !budgetRestart && this.activeTurnTokens.has(agentName);
+            // Turn-alive includes a continuation of the agent's turn still on its
+            // way elsewhere (a park, another pass's hands): a fresh wake waits for
+            // it, as for a turn holding its token.
+            const turnAlive = !budgetRestart && this.hasTurn(agentName);
             const providerGate = this.providerGates?.get(agentName);
             // A primary can own provider admission while yielding to an already in-flight
             // auxiliary call. Keep this agent's later wakes queued, but do not block the
@@ -12722,10 +13091,12 @@ export class AgentFramework {
                 // exactly this class of silent drop. One stderr line per drop.
                 console.error(`[inference-dropped] agent=${agentName} reason=policy-skip ` +
                     `requests=${requests.length} triggers=${requests.map((r) => r.reason).join(',')}`);
-                // A context-budget restart inherits the predecessor's EventGate liveness.
-                // If policy drops the queued successor, no driveStream remains to release it.
-                if (budgetRestart)
-                    this.eventGate?.onInferenceEnded(agentName);
+                // A continuation inherits its predecessor's EventGate liveness and
+                // logical turn. If policy drops it, no driveStream remains to end them,
+                // so its turn ends here (endContinuedTurn).
+                if (requests.some(continuesTurn)) {
+                    this.endContinuedTurn(agentName, { kind: 'dropped', why: 'the inference policy dropped its continuation' });
+                }
                 this.endPendingPrimary(agentName);
                 continue;
             }
@@ -12805,7 +13176,7 @@ export class AgentFramework {
             // exists only once assembly renders it. Recorded for the whole batch
             // (not inherited from requests[0]), so a requeued trigger stays honest.
             const batchOnly = !budgetRestart && requests.every((r) => r.coalescingBatch === true && !!r.coalescingSubject);
-            await this.startAgentStream(agent, {
+            const merged = {
                 ...trigger,
                 coalescingBatch: batchOnly || undefined,
                 coalescingBatchSubjects: batchOnly
@@ -12833,7 +13204,19 @@ export class AgentFramework {
                 counterparty: budgetRestart ? undefined : provReq?.counterparty,
                 wakeChannelId: budgetRestart ? undefined : provReq?.wakeChannelId,
                 wakeAt: budgetRestart ? undefined : provReq?.wakeAt,
-            });
+            };
+            // A held turn's retry merged with other wakes leaves the start its
+            // turn's retry (TURN_RETRY), whichever request leads the merge: held
+            // again before it takes a token, it keeps the turn alive as before.
+            const start = requests.some(isTurnRetry) ? asTurnRetry(merged) : merged;
+            // A start that carries a turn on and took in wakes that don't records
+            // the batch it was merged from (MERGED_BATCH): until it takes its
+            // token it stands for them all.
+            if (continuesTurn(start) && requests.some((r) => !continuesTurn(r)))
+                start[MERGED_BATCH] = [...requests];
+            else
+                delete start[MERGED_BATCH];
+            await this.startAgentStream(agent, start);
         }
     }
     /**
@@ -15078,7 +15461,14 @@ export class AgentFramework {
                 // Do not await inside processInferenceRequests: one slow auxiliary call for
                 // this resident must not block events or other residents. Admission stays
                 // owned and the continuation receives it after the in-flight call settles.
+                const parkedContinuation = trigger !== undefined && continuesTurn(trigger);
+                if (parkedContinuation)
+                    this.parkedContinuations.add(trigger);
                 void this.waitForAuxiliaryIdle(agent.name).then(async () => {
+                    // A continuation dropped while it was parked left the set then, with
+                    // its admission given back.
+                    if (parkedContinuation && !this.parkedContinuations.delete(trigger))
+                        return;
                     if (this.providerAdmissionClosed) {
                         this.releasePrimaryProviderGate(agent.name);
                         return;
@@ -15105,8 +15495,9 @@ export class AgentFramework {
                     // park; starting here would bypass it and run a turn against a
                     // context the operator believes frozen. Give admission back and
                     // requeue — the scheduler re-parks it (coalesced) until resume.
-                    // Continuations of a held turn pass, as they do at the gate.
-                    if (this.quiesced && !isTurnContinuation(trigger?.reason ?? '')) {
+                    // Continuations of a held turn, and a held turn's retry, pass, as
+                    // they do at the gate (passesQuiesce).
+                    if (this.quiesced && !passesQuiesce(trigger)) {
                         this.releasePrimaryProviderGate(agent.name);
                         this.pendingRequests.push(trigger ?? {
                             agentName: agent.name, reason: 'provider-admission:requeue', source: 'scheduler', timestamp: Date.now(),
@@ -15114,6 +15505,16 @@ export class AgentFramework {
                         console.error(`[provider-admission] ${agent.name}: host quiesced while parked — wake requeued, not started`);
                         return;
                     }
+                    // A start that stands for a merged batch (MERGED_BATCH) goes back
+                    // to the scheduler as that batch: its gate lets the turn's request
+                    // through alone and parks the wakes until resume.
+                    const batch = trigger && mergedBatch(trigger);
+                    if (this.quiesced && batch) {
+                        this.releasePrimaryProviderGate(agent.name);
+                        this.pendingRequests.push(...batch);
+                        console.error(`[provider-admission] ${agent.name}: host quiesced while parked — the merged start goes back as its ${batch.length} requests`);
+                        return;
+                    }
                     await this.startAgentStream(agent, trigger, attempt, true);
                 }).catch((error) => {
                     this.releasePrimaryProviderGate(agent.name);
@@ -15243,6 +15644,143 @@ export class AgentFramework {
             }
         }
     }
+    /**
+     * Drop every continuation of `agentName`'s turn still on its way, wherever
+     * it waits: the queue, a provider hold (which, left empty, then releases
+     * with nothing to run), a park on admission (whose admission it gives
+     * back), or a scheduler pass's hands (which then never reach it). If one
+     * was there, the turn ends (endContinuedTurn), unless `drop` is null: the
+     * caller has ended the turn already.
+     */
+    dropContinuations(agentName, drop) {
+        const isContinuation = (r) => r.agentName === agentName && continuesTurn(r);
+        // A caller's stop and an abandon end the turn, not the wakes merged into
+        // a start of it that hasn't taken its token (MERGED_BATCH): they go back
+        // in the queue. A stop() or a disposal ends the agent's work, and puts
+        // nothing back.
+        const putsBack = drop?.kind === 'caller' || drop?.kind === 'quiesce_abandoned';
+        const back = [];
+        let dropped = false;
+        const take = (requests) => {
+            const left = [];
+            for (const r of requests) {
+                if (!isContinuation(r))
+                    left.push(r);
+                else {
+                    dropped = true;
+                    if (putsBack)
+                        back.push(...mergedWakes(r));
+                }
+            }
+            return left;
+        };
+        this.pendingRequests = take(this.pendingRequests);
+        const hold = this.providerAccelerationCooldowns.get(agentName);
+        if (hold) {
+            const held = hold.heldRequests.length;
+            hold.heldRequests = take(hold.heldRequests);
+            if (held > 0 && hold.heldRequests.length === 0)
+                hold.emptiedByDrop = true;
+        }
+        for (const parked of [...this.parkedContinuations]) {
+            if (!isContinuation(parked))
+                continue;
+            this.parkedContinuations.delete(parked);
+            this.releasePrimaryProviderGate(agentName);
+            dropped = true;
+            if (putsBack)
+                back.push(...mergedWakes(parked));
+        }
+        for (const pass of this.passRequests) {
+            const requests = pass.get(agentName);
+            if (!requests)
+                continue;
+            const left = take(requests);
+            requests.length = 0;
+            requests.push(...left);
+        }
+        this.pendingRequests.push(...back);
+        if (!dropped || !drop)
+            return;
+        // A primary a provider hold left pending for what it released won't run
+        // now, when nothing else of the agent's waits (endPendingPrimary).
+        if (!this.pendingRequests.some((r) => r.agentName === agentName) && !this.providerAccelerationCooldowns.get(agentName)?.heldRequests.length) {
+            this.endPendingPrimary(agentName);
+        }
+        this.endContinuedTurn(agentName, drop);
+    }
+    /**
+     * End a turn whose continuation won't run. The frame that handed the turn
+     * to it kept the turn open for it: its logical turn, the EventGate's
+     * window, the tool-result guard's batch and recovery, its typing. An
+     * abandon or a stop of a registered agent settles the turn as it settles a
+     * turn's start (endStoppedStart: one inference:aborted, the turn settled,
+     * the gate released). Any other drop ends it as a start dropped before it
+     * sends anything ends. That frame, if it hasn't let go of its token yet,
+     * ends on its own and settles nothing. What was deferred for the agent
+     * lands now, or at that frame's end.
+     */
+    endContinuedTurn(agentName, drop) {
+        console.error(`[turn-continuation] ${agentName}: its turn ends without its continuation: ${drop.why}`);
+        const agent = this.agents.get(agentName);
+        const startedAt = this.lastInferenceAt.get(agentName)?.startedAt ?? Date.now();
+        if (agent && drop.kind !== 'dropped') {
+            const routing = this.openLogical.get(agentName) ?? this.routingOf(agentName);
+            this.endStoppedStart(agent, drop.kind === 'caller' ? { kind: 'caller', reason: drop.reason } : { kind: drop.kind }, routing, startedAt, undefined, false);
+        }
+        else {
+            const owner = this.activeTurnTokens.get(agentName);
+            this.abortDroppedTurn(agentName, owner ?? -1, drop.kind === 'dropped' ? CONTINUATION_DROPPED : drop.kind === 'caller' ? (drop.reason ?? 'user') : drop.kind, startedAt);
+            this.channelRegistry?.stopTyping();
+            if (agent) {
+                agent.toolResultGuard.recovering = false;
+                if (agent.toolResultGuard.hasPending) {
+                    try {
+                        agent.toolResultGuard.abandon('aborted');
+                    }
+                    catch (error) {
+                        console.error(`[tool-result-guard] agent=${agentName} failed to record aborted batch:`, error);
+                    }
+                }
+            }
+            const routing = this.openLogical.get(agentName) ?? this.turnRouting.get(agentName);
+            if (routing)
+                this.endDroppedTurn(agentName, routing);
+            this.eventGate?.onInferenceEnded(agentName);
+        }
+        if (!this.activeTurnTokens.has(agentName) && this.deferredMessages.length > 0 && !this.pendingAssistantBlocks.has(agentName)) {
+            this.readdDrained(this.drainDeferredFor(agentName), 'continuation-drop flush');
+            this.ackDeferredWrites();
+        }
+    }
+    /**
+     * After a failure a provider hold would take: once stop() has closed
+     * admission, the hold installs nothing (holdForProviderWait,
+     * holdProviderAcceleration), so no retry follows the turn's
+     * inference:failed, and the turn ends as a retry a stop cancelled ends, with
+     * an inference:aborted saying so. Nothing is written. True when it ended
+     * the turn.
+     */
+    endFailureAtStop(agentName, turnToken, startedAt) {
+        if (!this.providerAdmissionClosed)
+            return false;
+        this.abortDroppedTurn(agentName, turnToken, RETRY_CANCELLED_BY_STOP, startedAt);
+        return true;
+    }
+    /**
+     * A turn's start whose failure a provider hold took (or, once stop() has
+     * closed admission, would have: endFailureAtStop) ends here. Its window
+     * closes now, not at the start's finally a few microtasks on: no check of
+     * this start is ahead, and a stop made after the failure's report must
+     * find the held retry (abortInference's drop), not a window nothing will
+     * collect.
+     */
+    endHeldStart(agent, checkWindow, turnToken, startedAt) {
+        if (this.checkAhead.get(agent) === checkWindow)
+            this.checkAhead.delete(agent);
+        this.endFailureAtStop(agent.name, turnToken, startedAt);
+        this.eventGate?.onInferenceEnded(agent.name);
+    }
     /**
      * End a turn that beginAgentTurn drops before it sends anything. The turn
      * emitted inference:started, and listeners that bracket a turn, such as a
@@ -15297,7 +15835,7 @@ export class AgentFramework {
      *  continues one (a restart or a retry) may follow rounds already sent,
      *  so the note says it was stopped before it finished. */
     opensTurn) {
-        console.error(`[turn] ${agent.name}: ${stop.kind === 'caller' ? 'a stop' : 'a quiesce abandon'} reached the turn's start before it ${opensTurn ? 'sent anything' : 'finished'}; it ends there`);
+        console.error(`[turn] ${agent.name}: ${stop.kind === 'caller' ? 'a stop' : stop.kind === 'shutdown' ? "the framework's stop" : 'a quiesce abandon'} reached the turn's start before it ${opensTurn ? 'sent anything' : 'finished'}; it ends there`);
         this.channelRegistry?.stopTyping();
         // A start that continues a turn (a budget or guard restart) follows a
         // frame that kept the turn's tool-result batch, and the guard's recovery,
@@ -15325,7 +15863,7 @@ export class AgentFramework {
             this.settleDeliberateCancel({ ...common, reason: stop.reason ?? 'user', before: opensTurn ? 'sending' : 'finishing' });
         }
         else {
-            this.settleFrameworkCancel({ ...common, kind: 'quiesce_abandoned' });
+            this.settleFrameworkCancel({ ...common, kind: stop.kind });
         }
         const last = this.lastInferenceAt.get(agent.name);
         if (last?.startedAt === turnStartedAt)
@@ -15461,6 +15999,12 @@ export class AgentFramework {
             const { coalescingSubject: _subject, coalescingBatch: _batch, coalescingBatchSubjects: _subjects, readsDeferredWrite: _read, ...retry } = trigger;
             trigger = retry;
         }
+        // The wakes merged into this start are the turn's now: it reads them,
+        // so a later drop of its retry puts none of them back (MERGED_BATCH).
+        if (trigger && mergedBatch(trigger)) {
+            const { [MERGED_BATCH]: _batch, ...own } = trigger;
+            trigger = own;
+        }
         // Record turn checkpoint before inference (only on first attempt, not retries)
         if (attempt === 0 && trigger?.reason !== 'tool_result_guard_retry') {
             this.recordTurnCheckpoint(agent.name);
@@ -15746,9 +16290,8 @@ export class AgentFramework {
             // hold the turn as the boundary would rather than send it into the wait.
             if (this.conversationAgentHomes.has(agent.name)) {
                 const wait = this.providerWaits?.active(agent.name, agent.model);
-                if (wait && this.holdForProviderWait(agent, wait, trigger ? [trigger] : [])) {
-                    console.error(`[provider-wait] agent=${agent.name} model=${agent.model} binds after the compile ` +
-                        `(recorded while the turn compiled); turn held, nothing sent`);
+                // The turn has begun (inference:started), so the hold keeps its retry.
+                if (wait && this.holdForProviderWait(agent, wait, trigger ? [asTurnRetry(trigger)] : [], false, () => {
                     // The stream the compile made won't be sent: it's cancelled, and
                     // this start's window closes, before the hold is reported, so a stop
                     // made while inference:failed is delivered finds neither, and the
@@ -15760,8 +16303,15 @@ export class AgentFramework {
                         this.checkAhead.delete(agent);
                     // The turn emitted inference:started before its compile; every turn
                     // that does gets one terminal event, which listeners (a typing loop)
-                    // rely on, as the failure sites' holds emit inference:failed.
+                    // rely on. It's reported before the hold takes the turn's retry, as
+                    // at every failure site, so a listener's stop finds nothing held.
                     this.emitTrace({ type: 'inference:failed', agentName: agent.name, error: providerWaitText(agent.name, agent.model, wait) });
+                })) {
+                    console.error(`[provider-wait] agent=${agent.name} model=${agent.model} binds after the compile ` +
+                        `(recorded while the turn compiled); ${this.providerAdmissionClosed ? 'the framework is stopping, so nothing is held'
+                            : this.providerAccelerationCooldowns.get(agent.name)?.heldRequests.some(isTurnRetry) ? 'turn held'
+                                : 'the wait was released as the failure was reported, so the retry is queued'}, nothing sent`);
+                    this.endFailureAtStop(agent.name, turnToken, turnStartedAt);
                     this.activeStreams.delete(agent.name);
                     this.pendingAssistantBlocks.delete(agent.name);
                     this.channelRegistry?.stopTyping();
@@ -15836,14 +16386,16 @@ export class AgentFramework {
             if (ownsProviderGate && this.holdProviderAcceleration(agent, err, trigger)) {
                 // Capacity scheduling is not poisoned history. The cooldown timer owns
                 // one later fresh compile; no immediate retry or exhaustion marker.
-                this.eventGate?.onInferenceEnded(agent.name);
+                // (Once stop() has closed admission, nothing is held, and the turn
+                // ends here: endFailureAtStop.)
+                this.endHeldStart(agent, checkWindow, turnToken, turnStartedAt);
                 return false;
             }
             const statedWait = ownsProviderGate ? undefined : this.nonOwningProviderWait(agent, err, trigger);
             if (statedWait === 'held') {
                 // A conversation agent held by the provider's stated wait, as a
                 // resident is: the hold's release owns the later compile.
-                this.eventGate?.onInferenceEnded(agent.name);
+                this.endHeldStart(agent, checkWindow, turnToken, turnStartedAt);
                 return false;
             }
             const action = statedWait === 'fail' ? { retry: false } : this.errorPolicy.onInferenceError(err, agent.name, attempt);
@@ -15876,7 +16428,16 @@ export class AgentFramework {
                 }
                 // The retry re-enters startAgentStream, which replaces this frame's
                 // turn token with its own; cleanup belongs to the innermost frame.
-                await this.startAgentStream(agent, trigger, attempt + 1);
+                // The retry is its turn's (TURN_RETRY): this frame has begun the turn,
+                // and once the retry's start is held at the last admission boundary
+                // (a conversation agent's own compression can record a wait during
+                // the policy's delay), this frame lets go of its token. No check of
+                // this start is ahead now, so its window closes first: a stop made
+                // once the retry is held finds the held retry (abortInference's
+                // drop), not a window nothing will collect.
+                if (this.checkAhead.get(agent) === checkWindow)
+                    this.checkAhead.delete(agent);
+                await this.startAgentStream(agent, trigger && asTurnRetry(trigger), attempt + 1);
             }
             else {
                 // Terminal failure with no driveStream: this frame owns teardown.
@@ -16019,8 +16580,8 @@ export class AgentFramework {
                 this.recordProviderAccelerationRecovery(agent, compiledRequest, end);
             // The accounting writes to the store, and a write that fails must not
             // skip what the boundary does after this call: the rest of a turn's
-            // end, or a restart's cancel and its request, and then the event's
-            // dispatch to modules.
+            // end, or a restart's trace (its cancel and its request come before
+            // this call), and then the event's dispatch to modules.
             try {
                 if (turnEnded) {
                     completeTurn(latestUsage, durationMs);
@@ -17360,13 +17921,17 @@ export class AgentFramework {
                         if (agent.streamId !== myStreamId)
                             break;
                         this.abandonAgentScripts(agent.name, 'stream error', streamRouting);
+                        // A hold takes the turn's retry, or, once stop() has closed
+                        // admission, the turn ends here (endFailureAtStop).
                         if (ownsProviderGate && this.holdProviderAcceleration(agent, err, trigger)) {
+                            this.endFailureAtStop(agent.name, myTurnToken ?? -1, startTime);
                             if (this.agents.get(agent.name) === agent && agent.streamId === myStreamId)
                                 this.eventGate?.onInferenceEnded(agent.name);
                             break;
                         }
                         const statedWait = ownsProviderGate ? undefined : this.nonOwningProviderWait(agent, err, trigger);
                         if (statedWait === 'held') {
+                            this.endFailureAtStop(agent.name, myTurnToken ?? -1, startTime);
                             if (this.agents.get(agent.name) === agent && agent.streamId === myStreamId)
                                 this.eventGate?.onInferenceEnded(agent.name);
                             break;
@@ -17405,7 +17970,8 @@ export class AgentFramework {
                                     }
                                     return;
                                 }
-                                await this.startAgentStream(agent, trigger, attempt + 1);
+                                // Marked as its turn's retry, as at the start's failure.
+                                await this.startAgentStream(agent, trigger && asTurnRetry(trigger), attempt + 1);
                             }
                             else {
                                 // The turn ends here, and its inference:failed doesn't say so,
@@ -17715,10 +18281,16 @@ export class AgentFramework {
             const durationMs = Date.now() - startTime;
             // The stream won't go on: the agent stops holding it before the
             // failure is reported, as at the stream's error event, so a stop made
-            // while inference:failed is delivered finds no stream.
+            // while inference:failed is delivered finds no stream. It's reported
+            // once, before a provider hold takes the turn's retry, as at the
+            // stream's error event and at a start's failure: a listener's stop
+            // finds nothing held, and one made after it ends the held turn.
             agent.reset();
+            this.emitTrace({ type: 'inference:failed', agentName: agent.name, error: err.message, stack: err.stack });
             if (ownsProviderGate && this.holdProviderAcceleration(agent, err, trigger)) {
-                this.emitTrace({ type: 'inference:failed', agentName: agent.name, error: err.message, stack: err.stack });
+                // Once stop() has closed admission, nothing is held, and the turn
+                // ends here (endFailureAtStop).
+                this.endFailureAtStop(agent.name, myTurnToken ?? -1, startTime);
                 logStream({ success: false,
                     error: `Provider acceleration cooldown: ${err.message}`,
                     request: compiledRequest ?? { note: 'streaming request rate-limited' }, durationMs });
@@ -17735,7 +18307,7 @@ export class AgentFramework {
             // says why it ends.
             const statedWait = ownsProviderGate ? undefined : this.nonOwningProviderWait(agent, err, trigger);
             if (statedWait === 'held') {
-                this.emitTrace({ type: 'inference:failed', agentName: agent.name, error: err.message, stack: err.stack });
+                this.endFailureAtStop(agent.name, myTurnToken ?? -1, startTime);
                 logStream({ success: false,
                     error: `Provider wait: ${err.message}`,
                     request: compiledRequest ?? { note: 'streaming request rate-limited' }, durationMs });
@@ -17746,12 +18318,6 @@ export class AgentFramework {
                     this.eventGate?.onInferenceEnded(agent.name);
                 return;
             }
-            this.emitTrace({
-                type: 'inference:failed',
-                agentName: agent.name,
-                error: err.message,
-                stack: err.stack,
-            });
             this.settleAgent(agent.name, {
                 stopReason: 'exhausted',
                 speech: '',
@@ -17933,7 +18499,11 @@ export class AgentFramework {
             // its ids when a successor turn has already taken the agent. A fork or
             // run deregistered while the host is quiesced leaves its queue to its
             // window's release at resume (drainDeferredFor).
-            if (frameReachedTerminal && this.deferredMessages.length > 0 && !this.pendingAssistantBlocks.has(agent.name)) {
+            // A frame that handed its turn to a continuation since dropped
+            // (endContinuedTurn, which couldn't land it while this frame held the
+            // token) lands it too: the turn is over.
+            const handedOffTurnOver = preserveEventGateForSuccessor && !this.hasTurn(agent.name);
+            if ((frameReachedTerminal || handedOffTurnOver) && this.deferredMessages.length > 0 && !this.pendingAssistantBlocks.has(agent.name)) {
                 this.readdDrained(this.drainDeferredFor(agent.name), 'turn-end flush');
                 this.ackDeferredWrites();
             }
@@ -17955,8 +18525,11 @@ export class AgentFramework {
             // frame that ends the turn disposes it, after the flush above, so what
             // was held for the turn's end lands in the fork's store instead of
             // being dropped as addressed to no agent. A frame that hands the turn
-            // to a successor (a guard or budget restart) leaves the fork to it.
-            if (frameReachedTerminal && ownsPhysicalStream && this.closingConversationAgents.has(agent.name)) {
+            // to a successor (a guard or budget restart) leaves the fork to it, and
+            // so does one whose failure a provider hold keeps for its retry: the
+            // turn isn't over (pendingContinuationAgents).
+            if (frameReachedTerminal && ownsPhysicalStream && this.closingConversationAgents.has(agent.name)
+                && !this.pendingContinuationAgents().has(agent.name)) {
                 this.disposeConversationAgent(agent.name);
             }
         }
@@ -18036,10 +18609,16 @@ export class AgentFramework {
         if (this.surgeryHold) {
             throw new Error(`puppet refused: the store is under live ${this.surgeryHold.verb} for ${this.surgeryHold.agentName} — retry when it completes`);
         }
-        if (agent.state.status !== 'idle' || this.activeTurnTokens.has(agentName)) {
+        if (agent.state.status !== 'idle' || this.hasTurn(agentName)) {
             const shown = agent.state.status === 'idle' ? 'idle+turn-alive' : agent.state.status;
-            throw new Error(`puppet refused: agent ${agentName} is ${shown} (requires idle — ` +
-                `injecting a turn under an active stream corrupts wire ordering)`);
+            // A turn a provider hold keeps for its retry has no stream: the refusal
+            // names the hold, and how to go on sooner, as surgery's does.
+            const held = agent.state.status === 'idle' ? this.heldTurnRetry(agentName) : undefined;
+            throw new Error(held
+                ? `puppet refused: agent ${agentName} is idle+turn-alive (${held.says}; requires idle); ` +
+                    heldTurnWayOn(held.statedWait)
+                : `puppet refused: agent ${agentName} is ${shown} (requires idle — ` +
+                    `injecting a turn under an active stream corrupts wire ordering)`);
         }
         const onSurface = this.getToolsForAgent(agentName)
             .some((t) => t.name === toolName && agent.canUseTool(t.name));
@@ -18934,7 +19513,8 @@ export class AgentFramework {
         }
         if (refusal !== undefined)
             return refused(refusal);
-        const result = await this.dispatchScriptToolCall(agentName, toolName, input, context.origin, context.watch?.turnId);
+        const route = { toServer: false };
+        const result = await this.dispatchScriptToolCall(agentName, toolName, input, context.origin, context.watch?.turnId, route);
         // Deferred: applied to the result of the code_execution call watching
         // the script — ending the turn mid-script would cancel the stream while
         // the script still runs and wedge the tool round. A call a left script
@@ -18946,7 +19526,7 @@ export class AgentFramework {
             watching.endTurn = true;
         if (result.refused)
             return refused(result.error ?? `${toolName} was refused; nothing was done`);
-        const answer = await this.scriptResultAnswer(result, toolName);
+        const answer = await this.scriptResultAnswer(result, toolName, route.toServer);
         return SCRIPT_CALL_NO_RESULT.has(result) ? { ...answer, held: true } : answer;
     }
     /**
@@ -18954,14 +19534,20 @@ export class AgentFramework {
      * isError }`, one shape for every tool. `content` is
      * what the model would read: a structured result's blocks as the dispatch
      * gave them (the direct reading, with RFC-005's treatment of an MCPL peer's
-     * blocks), and otherwise one text block of the model's text, which for a
-     * failure is its error. `structuredContent` is the tool's own structured
+     * blocks there, bound to the server that sent them), a module's under
+     * history's reading of RFC-005 at every depth (shownToScript), and
+     * otherwise one text block of the model's text, which for a failure is its
+     * error. A module's is any result whose call the dispatch didn't send to
+     * a server (`toServer`, from the call's waiter). `structuredContent` is the
+     * tool's own structured
      * content where it sent one, `false`, `0` and `null` included, else null.
      * A result that can't be converted to JSON (a cyclic object, a BigInt),
      * which the dispatch's own check makes unlikely here, is a failure naming
-     * the tool and saying the call itself completed.
+     * the tool and saying the call itself completed. So is an MCPL peer's
+     * result whose blocks were too deep for the dispatch's treatment, which
+     * the dispatch marks (SCRIPT_RESULT_UNCONVERTIBLE).
      */
-    async scriptResultAnswer(result, toolName) {
+    async scriptResultAnswer(result, toolName, toServer) {
         const structured = Object.prototype.hasOwnProperty.call(result, 'structured');
         const isError = result.isError === true;
         // RFC-005 "eagerly lazy": a script receiving a result is the strongest
@@ -18978,7 +19564,10 @@ export class AgentFramework {
         // which isn't fetched.
         // Whenever the result's blocks reach the script: a structured failure's
         // included, as a module's error can carry content.
-        if ((!isError || structured) && Array.isArray(result.data) && this.resolveMcplTool(toolName) === null) {
+        // Not a server's result: a module's, whose blocks no dispatch has given
+        // RFC-005's treatment.
+        const fromModule = !toServer;
+        if ((!isError || structured) && Array.isArray(result.data) && fromModule) {
             const fetcher = this.getReferenceFetcher();
             for (const block of result.data) {
                 const c = classifyBlock(block);
@@ -19000,6 +19589,10 @@ export class AgentFramework {
                 brief: error,
             };
         };
+        // An MCPL peer's result whose blocks JSON couldn't hold, so that RFC-005's
+        // treatment couldn't be given them at dispatch.
+        if (SCRIPT_RESULT_UNCONVERTIBLE.has(result))
+            return failed(SCRIPT_RESULT_UNCONVERTIBLE.get(result));
         let content;
         let text;
         // A structured result's blocks, as #538 gives them: none when its content
@@ -19007,6 +19600,21 @@ export class AgentFramework {
         // no blocks reads as its error text.
         if (structured && (!isError || (Array.isArray(result.data) && result.data.length > 0))) {
             content = Array.isArray(result.data) ? result.data : [];
+            // A module's blocks, such as an MCPL peer's it got from ctx.callTool
+            // and returns whole, are read as history reads a module's data: what
+            // RFC-005 governs, at any depth, as the script lane shows it, and
+            // anything else as sent. What a script prints comes back to the model,
+            // so no uri the model's lanes withhold reaches it. What this gives is
+            // a stub, a notice or the value itself, so a module that returns
+            // blocks it already gave has them left as they are.
+            if (fromModule) {
+                try {
+                    content = JSON.parse(JSON.stringify(content, (_key, value) => shownToScript(value)));
+                }
+                catch (err) {
+                    return failed(err);
+                }
+            }
         }
         else {
             // As in history, a reference is its stub at any depth and inline data
@@ -19045,9 +19653,11 @@ export class AgentFramework {
      * RFC-007: with an `origin`, observers see the call as they see a model
      * call (register, dispatch with its refusal sites, open; the terminal at
      * the waiter intercept), under the inner tool's own name and class.
-     * `turnId` is the turn the call was made in (dispatchToolCall).
+     * `turnId` is the turn the call was made in (dispatchToolCall). `route` is
+     * the waiter's: the dispatch sets `toServer` when it sends the call to a
+     * server.
      */
-    dispatchScriptToolCall(agentName, toolName, args, origin, turnId) {
+    dispatchScriptToolCall(agentName, toolName, args, origin, turnId, route = { toServer: false }) {
         return new Promise((resolve) => {
             const callId = `pytc-${randomUUID()}`;
             // Host-side leak guard: the script's runner already gives the script a
@@ -19073,9 +19683,12 @@ export class AgentFramework {
                 }
             }, safetyMs);
             safety.unref?.();
-            this.scriptToolWaiters.set(callId, (result) => {
-                clearTimeout(safety);
-                resolve(result);
+            this.scriptToolWaiters.set(callId, {
+                resolve: (result) => {
+                    clearTimeout(safety);
+                    resolve(result);
+                },
+                route,
             });
             const call = { id: callId, name: toolName, input: args };
             if (origin)
@@ -19606,6 +20219,11 @@ export class AgentFramework {
         // Route MCPL tool calls to the appropriate server via prefix map
         const mcplMatch = this.resolveMcplTool(enrichedCall.name);
         if (mcplMatch && this.mcplServerRegistry) {
+            // A script's call: its waiter keeps that it went to a server, for the
+            // script lane's exit (scriptToolWaiters).
+            const scriptWaiter = this.scriptToolWaiters.get(enrichedCall.id);
+            if (scriptWaiter)
+                scriptWaiter.route.toServer = true;
             this.dispatchMcplToolCall(agentName, enrichedCall, mcplMatch[0], mcplMatch[1]);
             return;
         }
@@ -24205,8 +24823,8 @@ export class AgentFramework {
         });
     }
     /** An MCP tool call's trace: a result the server marked an error (or one
-     *  the reading couldn't complete) is tool:failed, as on the other tool
-     *  paths; anything else is tool:completed. */
+     *  the reading takes as one, such as malformed content) is tool:failed, as
+     *  on the other tool paths; anything else is tool:completed. */
     traceMcpToolOutcome(serverId, tool, callId, result, durationMs) {
         if (result.isError) {
             this.emitTrace({ type: 'tool:failed', module: `mcpl:${serverId}`, tool, callId, durationMs, error: result.error ?? 'tool returned an error' });
@@ -24615,15 +25233,44 @@ export class AgentFramework {
         // generated JSON) stands in for what the server sent. An MCPL peer's
         // content blocks are the exception: what a script prints comes back to
         // the model, so each gets the treatment RFC-005 gives it on every lane
-        // the model reads. A standard peer's blocks reach the script as sent.
+        // the model reads, here, where the server that sent them is known, and
+        // so does what RFC-005 governs at any depth within them, by the same
+        // peer reading, bound to that server (shownToScriptFromServer). A
+        // module's blocks get it at
+        // the script lane's exit (scriptResultAnswer). A standard peer's blocks
+        // reach the script as sent.
         const forScript = this.scriptToolWaiters?.has(call.id) ?? false;
         const reading = async (result, mcpl) => {
             if (!forScript || !Object.prototype.hasOwnProperty.call(result, 'structuredContent')) {
                 return this.mcpToolResult(result, call.id, mcpl, serverId, call.name);
             }
             const direct = AgentFramework.directToolResult(result, serverId, call.name);
-            if (mcpl)
-                return Array.isArray(direct.data) ? { ...direct, data: direct.data.map((block) => referenceBlockForScript(block, serverId)) } : direct;
+            if (mcpl) {
+                if (!Array.isArray(direct.data))
+                    return direct;
+                // Each block by the classifier, then what's nested in each, at any
+                // depth. The blocks came from the wire as JSON, so the round trip
+                // changes nothing else. But a value that parsed can still fail to
+                // go back: past some depth JSON.stringify overflows the stack where
+                // JSON.parse didn't (on Node 24.19 an array 5,000 deep does, on Bun
+                // 1.4.4 one 200,000 deep). That fails the script lane's treatment
+                // alone, and the peer answered: the result keeps the peer's outcome
+                // for the trace and the call's terminal, and the script lane's exit
+                // answers it as a result it can't convert, not as a failed dispatch
+                // (SCRIPT_RESULT_UNCONVERTIBLE). Its blocks are dropped, since they
+                // are untreated and the result travels on, to the waiter and to the
+                // listeners of its event's trace. Its structured content is kept, as
+                // every result keeps it, since RFC-005's treatment doesn't reach it.
+                const blocks = direct.data.map((block) => referenceBlockForScript(block, serverId));
+                try {
+                    return { ...direct, data: JSON.parse(JSON.stringify(blocks, (_key, value) => shownToScriptFromServer(value, serverId))) };
+                }
+                catch (err) {
+                    const unconvertible = { ...direct, data: [] };
+                    SCRIPT_RESULT_UNCONVERTIBLE.set(unconvertible, err);
+                    return unconvertible;
+                }
+            }
             // A standard peer's content that isn't a list of blocks is a malformed
             // result on the model's reading (normalizeStandardToolResult), so the
             // script reads it that way too, its structured content kept.
@@ -24821,7 +25468,8 @@ export class AgentFramework {
      * direct path (a module's callTool, a channel's tool call) doesn't come
      * here: it returns the server's result itself (directToolResult), for
      * either engine, as does a script's call whose result is structured, with
-     * an MCPL peer's blocks given RFC-005's treatment (referenceBlockForScript).
+     * an MCPL peer's blocks given RFC-005's treatment (referenceBlockForScript),
+     * and what's nested in them at any depth (shownToScriptFromServer).
      */
     async mcpToolResult(result, callId, mcplPeer, serverId, callName) {
         const hasStructured = Object.prototype.hasOwnProperty.call(result, 'structuredContent');