@animalabs/agent-framework 0.33.0 → 0.34.0

package/dist/src/framework.js

@@ -1,3 +1,5 @@
+import { isReasoningLoss } from './reasoning-loss.js';
+export { residentViewFilter, subconsciousViewFilter } from './context-options.js';
 import { ToolPresentation, presentationTools, isPresentationTool, renderCatalogue } from "./tool-presentation.js";
 import { presentAuthor } from './author-presentation.js';
 import { constants as bufferConstants } from 'node:buffer';
@@ -9,7 +11,8 @@ import { JsStore } from '@animalabs/chronicle';
 import { MembraneError } from '@animalabs/membrane';
 import { classifyFailure, retryDecision, MEMBRANE_RETRY_SETTINGS } from '@animalabs/membrane/retry';
 import { deadlineCut, isDeadlineExpiry, resolveInferenceBounds, wholeCallMs } from './inference-bounds.js';
-import { ContextManager, PassthroughStrategy, OverBudgetError, UncoveredDropError, stripUnpairedToolBlocks, continuesBody, MalformedContentError, malformedContentPlaces, CompressionWithdrawn } from '@animalabs/context-manager';
+import { boundFailureText, compileRefusalType, failureWords, FAILURE_TEXT_MAX_CHARS, houseReason, isMembraneError, PROVIDER_ERROR_CODE_MAX_CHARS } from './failure-text.js';
+import { ContextManager, PassthroughStrategy, stripUnpairedToolBlocks, continuesBody, MalformedContentError, malformedContentPlaces, CompressionWithdrawn } from '@animalabs/context-manager';
 // Not named imports from context-manager: 0.24.0 has neither, and a named
 // import of either would fail this package's load there before create()
 // could name the release it needs.
@@ -80,6 +83,7 @@ import { AgentPresentation, asCompiled, bearingOf, heldFromResidents, suppressed
 import { coverTest, covers, readMarkThrough } from './read-marks.js';
 import { contentAsStored, nameAsStored } from './text-as-stored.js';
 import { STORED_INJECTION_KEY, STORED_INJECTION_KIND, asStoredRow, hasRenderedContent, isOwnInjection, isStoredKind, storedInjectionMarkOf, unitHash } from './stored-injections.js';
+import { appendAll } from './append-all.js';
 /** An MCPL tool call refused because its server isn't in the registry: one
  *  closed for good, one removed, or one whose connect failed without
  *  reconnect, which this host doesn't bring back on its own. A server that's
@@ -916,10 +920,15 @@ const TURN_RETRY = Symbol('turn-retry');
  */
 const MERGED_BATCH = Symbol('merged-batch');
 const REARMED = Symbol('rearmed');
+const UNPROMPTED = Symbol('unprompted');
 const TURN_CARRY = Symbol('turn-carry');
+const BUDGET_WAIT = Symbol('budget-wait');
 function isRearmed(request) {
     return request !== undefined && request[REARMED] === true;
 }
+function isUnprompted(request) {
+    return request !== undefined && request[UNPROMPTED] === true;
+}
 function waitAlertsOnItsOwn(wait) {
     return wait.until === null || wait.until - wait.setAt > PROVIDER_WAIT_ALERT_MS;
 }
@@ -965,6 +974,9 @@ function asTurnRetry(trigger) {
 function continuesTurn(request) {
     return resumesLogicalTurn(request.reason) || isTurnRetry(request);
 }
+function budgetWaitOf(request) {
+    return request ? request[BUDGET_WAIT] : undefined;
+}
 function turnCarryOf(request) {
     return request && continuesTurn(request) ? request[TURN_CARRY] : undefined;
 }
@@ -1143,6 +1155,7 @@ const RETRY_CANCELLED_BY_STOP = 'a retry waiting while the framework was stoppin
 /** 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";
+const BUDGET_HELD_TURN_REMOVED = 'a turn that waited for compression was dropped: what it stood on was removed';
 function isTurnContinuation(reason) {
     return reason === 'context_budget_restart' || reason === 'tool_results_ready'
         || reason === 'tool_result_guard_retry';
@@ -1165,6 +1178,9 @@ const FRAMEWORK_WAKE_SOURCES = new Set(['framework', 'scheduler']);
 function hasOwnCauseForRun(r) {
     return !FRAMEWORK_WAKE_SOURCES.has(r.source) && r.suppressProse !== true;
 }
+function bringsOwnChannels(r) {
+    return hasOwnCauseForRun(r) && (r.wakeChannels?.length ?? 0) > 0;
+}
 /** Whether a wake carries an autoContinue continuation: its own wake, or a
  *  requeued turn trigger that kept the mark (InferenceRequest.autoContinueRun). */
 function carriesContinuation(r) {
@@ -1264,6 +1280,10 @@ function assertFrameworkSwitches(config) {
         assertBooleanSetting('watchdog.enabled', config.watchdog.enabled, 'true arms the liveness watchdog, which ends the process when the main thread misses its heartbeat for thresholdMs, ' +
             'and false or leaving it out doesn\'t');
     }
+    const unprompted = config.unpromptedChannel;
+    if (unprompted !== undefined && unprompted !== null && (typeof unprompted !== 'string' || unprompted.trim() === '')) {
+        throw new Error(`unpromptedChannel must name a channel, such as "discord:<guildId>:<channelId>", not ${typeof unprompted === 'string' ? 'a blank string' : kindOf(unprompted)}`);
+    }
     // The heartbeat: true or an object turns it on; false, null or leaving it
     // out leaves it off. Any other value (a "false" read from text, a 0) is
     // refused rather than read as on.
@@ -1627,8 +1647,8 @@ export class QuiesceBlockedError extends Error {
  */
 export class ProviderWaitNotSleptError extends Error {
     retryAfterMs;
-    constructor(message, retryAfterMs) {
-        super(message);
+    constructor(message, retryAfterMs, options) {
+        super(message, options);
         this.retryAfterMs = retryAfterMs;
         this.name = 'ProviderWaitNotSleptError';
     }
@@ -1779,7 +1799,7 @@ export class DefaultErrorPolicy {
     settings;
     constructor(settings = TURN_RETRY_SETTINGS) {
         this.settings = settings;
-        this.maxRetries = Math.max(0, ...Object.values(settings).map((s) => (s?.maxAttempts ?? 1) - 1));
+        this.maxRetries = Object.values(settings).reduce((max, s) => Math.max(max, (s?.maxAttempts ?? 1) - 1), 0);
     }
     onInferenceError(error, _agentName, attempt) {
         if (isDeadlineExpiry(error)) {
@@ -1885,6 +1905,10 @@ const TURN_RETRY_SETTINGS = {
     deadline: { maxAttempts: DEADLINE_TURN_TRIES, firstDelayMs: 1_000, multiplier: 1, maxDelayMs: 1_000, statedWaitCeilingMs: null },
 };
 const PROVIDER_ACCELERATION_JITTER_MS = 5_000;
+const BUDGET_HOLD_NOTE_NAMESPACE = 'framework:budget-hold';
+function describeWait(ms) {
+    return ms < 60_000 ? `${Math.max(1, Math.round(ms / 1000))} s` : `${Math.round(ms / 60_000)} min`;
+}
 /** Longest delay one setTimeout can represent (2^31-1 ms, about 24.8 days);
  *  a longer timer fires almost at once, so longer waits re-arm in steps. */
 const MAX_TIMER_DELAY_MS = 2_147_483_647;
@@ -1900,16 +1924,6 @@ const WAITING_TRACE_EVERY_MS = 60_000;
  *  waits in a row hold one turn longer than this (noteStatedWaitRun,
  *  endStatedWaitRun). */
 const PROVIDER_WAIT_ALERT_MS = 60 * 60_000;
-/**
- * A MembraneError, from this framework's copy of membrane or from another: the
- * host supplies the Membrane instance (config.membrane), so with two copies
- * installed its errors are instances of a class this framework's `instanceof`
- * doesn't match. Recognised by name as well, as context-manager's errors are;
- * its fields are the same, so callers still check each one's type.
- */
-function isMembraneError(error) {
-    return error instanceof MembraneError || (error instanceof Error && error.name === 'MembraneError');
-}
 /**
  * agent-framework#734. Membrane's own streams send a retryable failure as an
  * `error` event and send nothing after their terminal event. A stream of
@@ -2171,42 +2185,16 @@ const SCRIPT_TEXT_ANSWER_ENVELOPE_BYTES = Buffer.byteLength(JSON.stringify({ con
  * 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));
-/**
- * Longest failure text the inference-failure pipeline writes to one sink: the
- * reason in the exhaustion stderr line, a field of a logs/failures.log record,
- * an ops alert's message, the inference log's `error`, and a trace event's
- * `error` and `stack`. A failure's text is whatever its source put in
- * `Error.message`, and a provider can echo the entire rejected request there
- * (one OpenAI-compatible 400 echoed ~1.7 MB). The sinks with shorter bounds
- * name them below, and every cut goes through boundFailureText. This bound
- * doesn't depend on membrane bounding its own errors.
- */
-const FAILURE_TEXT_MAX_CHARS = 2_000;
-/** Longest failure reason written into an agent's own context (the
- *  `[inference-failed]` marker): enough for a provider's explanation, not a
- *  self-dump the agent then carries in every later request. */
+/** Longest failure reason in the `[inference-failed]` marker: the reason its
+ *  text gives, and the excerpt its metadata keeps. */
 const FAILURE_MARKER_REASON_MAX_CHARS = 600;
-/** Longest failure reason in the rewind marker, also the agent's own context:
- *  enough to identify the failure class without a wall of provider JSON. */
+/** Longest failure reason the rewind marker's metadata keeps as its category. */
 const REWIND_MARKER_REASON_MAX_CHARS = 160;
 /** Longest failure reason in an agent's status (`lastInference.lastError`) and
  *  in the compile-refused ops alert. */
 const FAILURE_SUMMARY_MAX_CHARS = 300;
 /** Longest alert message posted to the ops webhook. */
 const OPS_WEBHOOK_MESSAGE_MAX_CHARS = 500;
-/** Longest provider error code recorded verbatim; real codes are short tokens.
- *  A failure's name and type are bounded the same way. */
-const PROVIDER_ERROR_CODE_MAX_CHARS = 128;
-const isHighSurrogate = (text, index) => {
-    const code = text.charCodeAt(index);
-    return code >= 0xd800 && code <= 0xdbff;
-};
-const isLowSurrogate = (text, index) => {
-    const code = text.charCodeAt(index);
-    return code >= 0xdc00 && code <= 0xdfff;
-};
-/** Whether a cut before `index` would separate the halves of a surrogate pair. */
-const splitsPair = (text, index) => index > 0 && index < text.length && isHighSurrogate(text, index - 1) && isLowSurrogate(text, index);
 /**
  * Whether an MCPL server's child ended the way a server ends when it's asked
  * to: exit 0, death by a signal that asks a process to end (SIGTERM, SIGINT,
@@ -2231,28 +2219,6 @@ function closeWords(reason, code, signal) {
     const how = [reason ?? null, code != null ? `code ${code}` : null, signal ? `signal ${signal}` : null].filter((part) => part !== null);
     return how.length > 0 ? ` (${how.join(', ')})` : '';
 }
-/**
- * `text` when it fits within `max` characters; otherwise its head and tail
- * around a marker stating how many of how many characters were omitted, the
- * whole within `max`. A cut that would separate a surrogate pair moves toward
- * omission, so the result never holds half of a pair the text held whole, and
- * bounding bounded text returns it as is. Each sink cuts the whole text, so
- * its marker states the whole length.
- */
-function boundFailureText(text, max = FAILURE_TEXT_MAX_CHARS) {
-    if (text.length <= max)
-        return text;
-    const markerLength = ` …[${text.length} of ${text.length} characters omitted]… `.length;
-    const budget = Math.max(0, max - markerLength);
-    const tailLength = Math.floor(budget / 4);
-    let headEnd = budget - tailLength;
-    if (splitsPair(text, headEnd))
-        headEnd--;
-    let tailStart = text.length - tailLength;
-    if (splitsPair(text, tailStart))
-        tailStart++;
-    return `${text.slice(0, headEnd)} …[${tailStart - headEnd} of ${text.length} characters omitted]… ${text.slice(tailStart)}`;
-}
 export function opsWebhookText(message) {
     return boundFailureText(message, OPS_WEBHOOK_MESSAGE_MAX_CHARS);
 }
@@ -2326,6 +2292,30 @@ const UNDESCRIBED_FAILURE = `[${NOTICE_TAG.undescribedFailure}]`;
 function failureShown(text) {
     return text === UNDESCRIBED_FAILURE ? text : suppliedValue(text);
 }
+function failedEntry(prefix, err) {
+    return { error: `${prefix}${err.message}`, errorWords: `${prefix}${failureWords(err)}` };
+}
+function shownReasonOf(err) {
+    const own = houseReason(err);
+    return own === undefined ? {} : { shownReason: own };
+}
+function boundedCause(err) {
+    const cause = new Error(boundFailureText(String(err.message)));
+    cause.name = boundFailureText(String(err.name), PROVIDER_ERROR_CODE_MAX_CHARS);
+    cause.stack = boundFailureText(String(err.stack ?? `${cause.name}: ${cause.message}`));
+    if (isMembraneError(err)) {
+        const fields = err;
+        const code = boundProviderErrorCode(fields.providerErrorCode);
+        Object.assign(cause, {
+            ...(typeof fields.type === 'string' ? { type: boundFailureText(fields.type, PROVIDER_ERROR_CODE_MAX_CHARS) } : {}),
+            ...(typeof fields.retryable === 'boolean' ? { retryable: fields.retryable } : {}),
+            ...(typeof fields.httpStatus === 'number' ? { httpStatus: fields.httpStatus } : {}),
+            ...(code !== undefined ? { providerErrorCode: code } : {}),
+            ...(typeof fields.retryAfterMs === 'number' ? { retryAfterMs: fields.retryAfterMs } : {}),
+        });
+    }
+    return cause;
+}
 /**
  * A bounded string describing a failure, for logs that would otherwise print
  * the error object; it is one line unless one of its parts has newlines, as a
@@ -2648,6 +2638,14 @@ function mergeWakeLines(requests) {
     }
     return byEntry.size > 0 ? [...byEntry.values()] : undefined;
 }
+function wakeChannelsOf(requests) {
+    const channels = [];
+    for (const channel of requests.flatMap((r) => r?.wakeChannels ?? [])) {
+        if (!channels.some((c) => sameChannel(c, channel)))
+            channels.push(channel);
+    }
+    return channels.length > 0 ? channels : undefined;
+}
 /** A batched-wake line's identity: its event's stored entry. */
 function wakeLineKey(line) {
     const { eventType, serverId, channelId, messageId, eventId } = line.entry;
@@ -2805,6 +2803,9 @@ export class AgentFramework {
     providerAccelerationCooldowns = new Map();
     providerAccelerationRecoveries = new Map();
     providerAccelerationLastRecovery = new Map();
+    budgetHolds = new Map();
+    overBudgetDrainAfter = new Map();
+    budgetHoldRecheckMs = DEFAULT_MAINTENANCE_INTERVAL_MS;
     providerAccelerationDefaultCooldownMs = PROVIDER_ACCELERATION_DEFAULT_COOLDOWN_MS;
     providerAccelerationJitterMs = PROVIDER_ACCELERATION_JITTER_MS;
     inferenceBounds = resolveInferenceBounds(undefined);
@@ -3305,11 +3306,11 @@ export class AgentFramework {
     managerReleases = new WeakMap();
     releasedByCleanup = new WeakSet();
     resumesPending = new Map();
-    // context-manager 0.23.1: a strategy that keeps its context, as
-    // AutobiographicalStrategy does (hostContext, autobiographical.ts:2897),
+    // context-manager 0.25.1: a strategy that keeps its context, as
+    // AutobiographicalStrategy does (hostContext, autobiographical.ts:3156),
     // keeps its manager reachable while its work is pending, since the
     // context's tools and systemPrompt getters close over the manager
-    // (context-manager.ts:2343-2359). So such a released manager is collected
+    // (context-manager.ts:4602-4621). So such a released manager is collected
     // only once nothing of its work can still read the store, and stop()
     // closes, before an owned store, each one alive.
     openManagers = new Set();
@@ -3433,7 +3434,8 @@ export class AgentFramework {
     toolPatternKnownPrefixes = new Map();
     /** Maps serverId → McplServerConfig for prefix lookup. */
     mcplServerConfigs = new Map();
-    /** Modern-MCP (2026-07-28) servers, by id; read through modernServers().
+    /** Modern-MCP servers (2026-07-28, or a 2025 revision over HTTP), by id;
+     *  read through modernServers().
      *  They are kept apart from the MCPL registry on purpose: they have no
      *  grant, planes or server→host traffic, so the MCPL machinery (quiesce's
      *  plane pauses, policy) never sees them. They take part
@@ -3470,6 +3472,7 @@ export class AgentFramework {
      *  subsystem can be lazily initialized by connectMcplServer when the
      *  framework started with zero configured servers. */
     mcplInferenceRoutingConfig = null;
+    mcplUnpromptedChannel = null;
     /** The awareness ledger; null for a framework with neither storePath nor
      *  discordAwarenessOutboxPath, which refuses a marks choice. */
     discordAwarenessOutbox;
@@ -3580,12 +3583,15 @@ export class AgentFramework {
         assertAgentNamesUnique(config.agents);
         assertObservedAgentsConfigured(config.agents);
         // The presentation index (#291) needs a context-manager that keeps a
-        // window index per agent (presentRows): 0.25.0 on, since 0.23.x and
-        // 0.24.0 were published without one. It needs no store, so it is
-        // checked before one is opened.
-        if (typeof ContextManager.prototype.presentRows !== 'function') {
-            throw new Error('agent-framework needs @animalabs/context-manager with ContextManager.presentRows: a context-manager that keeps a window index per agent. ' +
-                'Install @animalabs/context-manager ^0.25.0, which this package declares (0.23.x and 0.24.0 have no window index)');
+        // window index per agent (presentRows), which 0.23.x and 0.24.x were
+        // published without, and a stream tells it of dropped thinking
+        // (noteThinkingDropped), which 0.25.0 was published without. It needs no
+        // store, so it is checked before one is opened.
+        const contextManagerProto = ContextManager.prototype;
+        if (typeof contextManagerProto.presentRows !== 'function' || typeof contextManagerProto.noteThinkingDropped !== 'function') {
+            throw new Error('agent-framework needs @animalabs/context-manager with ContextManager.presentRows and ContextManager.noteThinkingDropped: ' +
+                "a context-manager that keeps a window index per agent and can be told which stored replies' thinking the provider dropped. " +
+                'Install @animalabs/context-manager ^0.25.1, which this package declares (0.23.x and 0.24.x have no window index, and 0.25.0 has no noteThinkingDropped)');
         }
         // Create or use existing store
         let store;
@@ -3982,7 +3988,7 @@ export class AgentFramework {
                         : undefined);
                 },
                 requestInference: (agentName, reason, source, provenance, after) => {
-                    framework.pendingRequests.push({
+                    const request = {
                         agentName, reason, source, timestamp: Date.now(),
                         ...framework.readsRowFor(after, agentName),
                         // gate-requested wakes carry where/who (EventGate wakeProvenance)
@@ -4010,11 +4016,19 @@ export class AgentFramework {
                             const route = provenance?.routeChannelId !== undefined
                                 ? framework.channelNamed(provenance.routeChannelId, provenance.routeServerId)
                                 : undefined;
-                            return route && framework.mayTakeGateRoute(agentName, route)
-                                ? { channelId: route.channelId, channelServerId: route.serverId, addressed: true }
-                                : {};
+                            if (route && framework.mayTakeGateRoute(agentName, route)) {
+                                return { channelId: route.channelId, channelServerId: route.serverId, addressed: true };
+                            }
+                            const came = (provenance?.batchChannels ?? [])
+                                .map((c) => framework.channelNamed(c.channelId, c.serverId))
+                                .filter((c) => c !== undefined)
+                                .filter((c, i, all) => all.findIndex((d) => sameChannel(d, c)) === i);
+                            return came.length > 0 ? { wakeChannels: came } : {};
                         })(),
-                    });
+                    };
+                    if (source === 'self-wake' || source === 'sleep')
+                        request[UNPROMPTED] = true;
+                    framework.pendingRequests.push(request);
                 },
                 getAgentNames: () => framework.registry.gateRecipients(),
                 isHeld: (serverId, channelId) => !!(serverId && channelId && framework.tuneOutCoordinator?.holdFor(serverId, channelId)),
@@ -4119,6 +4133,7 @@ export class AgentFramework {
         // Stored for lazy MCPL initialization (connectMcplServer on a framework
         // that started with zero configured servers).
         framework.mcplInferenceRoutingConfig = config.inferenceRouting ?? null;
+        framework.mcplUnpromptedChannel = config.unpromptedChannel ?? null;
         // Client-side programmatic tool calling (code_execution). Made only when
         // enabled — everything downstream gates on the field. create() checked
         // the configuration (validateCodeExecutionConfig).
@@ -4679,6 +4694,9 @@ export class AgentFramework {
         });
         // A stopped host must never hang behind its own cooldown.
         step(() => this.cancelProviderAdmission());
+        for (const name of [...(this.budgetHolds?.keys() ?? [])]) {
+            step(() => this.dropBudgetHold(name, { kind: 'shutdown', why: 'the framework is stopping' }));
+        }
         // An open logical turn doesn't survive a stop.
         this.openLogical.clear();
         // Cancel the stream of every agent whose state holds one: streaming,
@@ -5063,8 +5081,11 @@ export class AgentFramework {
         // A wait recorded while this call was parked binds it too.
         this.refuseHeldProviderModel(agentName, model);
         gate.auxiliaryInFlight++;
+        let landed = false;
         try {
-            return await run();
+            const result = await run();
+            landed = true;
+            return result;
         }
         catch (error) {
             // Compression can be the first call to find a spent quota (idle agent,
@@ -5084,6 +5105,8 @@ export class AgentFramework {
             if (gate.auxiliaryInFlight === 0)
                 for (const resolve of gate.idleWaiters.splice(0))
                     resolve();
+            if (landed)
+                this.managerCallLanded(agentName);
         }
     }
     /**
@@ -5131,7 +5154,7 @@ export class AgentFramework {
                     ? `a turn whose retries ran out, sent again (${cooldown.rearm.number} of ${cooldown.rearm.of})`
                     : 'a turn held by a provider cooldown, when it ends' });
         }
-        wakes.push(...this.heartbeatWakesFor(agentName));
+        appendAll(wakes, this.heartbeatWakesFor(agentName));
         return wakes;
     }
     /**
@@ -5318,6 +5341,16 @@ export class AgentFramework {
     auxiliaryMembraneFor(agentName) {
         return this.membraneAdmitting((run, model) => this.withAuxiliaryAdmission(agentName, run, model));
     }
+    managerCallLanded(agentName) {
+        const hold = this.budgetHolds?.get(agentName);
+        if (!hold)
+            return;
+        hold.managerCalls++;
+        if (hold.checkQueued)
+            return;
+        const look = setTimeout(() => this.releaseBudgetHoldOnEvidence(agentName), 0);
+        look.unref?.();
+    }
     /**
      * The reply judge's calls. None waits: under the agent's holds a call is
      * refused without being made, and the agent's turn stops the judge. A call
@@ -5374,14 +5407,17 @@ export class AgentFramework {
             this.withdrawMaintenanceUnderSurgery();
             this.withdrawMaintenanceWhenStopping(agentName);
             this.refuseHeldProviderModel(agentName, model);
+            let result;
             try {
-                return await run();
+                result = await run();
             }
             catch (error) {
                 if (model !== undefined && error instanceof Error)
                     this.recordProviderWait(agentName, model, error);
                 throw error;
             }
+            this.managerCallLanded(agentName);
+            return result;
         });
     }
     ephemeralAuxiliaryMembraneFor(agentName, release) {
@@ -5512,13 +5548,28 @@ export class AgentFramework {
             held.push(request);
             return;
         }
+        // Read the kept request's carry before marking it.
+        const keptCarry = turnCarryOf(same);
         if (isTurnRetry(request))
             same[TURN_RETRY] = true;
+        const wait = budgetWaitOf(request);
+        if (wait && !budgetWaitOf(same))
+            same[BUDGET_WAIT] = wait;
         // 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])];
+        const carry = keptCarry ?? turnCarryOf(request);
+        if (carry)
+            same[TURN_CARRY] = carry;
+        else
+            delete same[TURN_CARRY];
+        if (!isRearmed(request))
+            delete same[REARMED];
+        const channels = wakeChannelsOf([same, request]);
+        if (channels)
+            same.wakeChannels = channels;
     }
     consultProviderHold(error, agentName) {
         if (!this.providerHoldHook)
@@ -5577,7 +5628,7 @@ 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 ? [asTurnRetry(trigger)] : [], true);
+                && this.holdForProviderWait(agent, wait, trigger ? [this.turnRetryOf(trigger, this.turnRouting.get(agent.name))] : [], true);
         }
         // As in holdForProviderWait: once stop() has closed admission, nothing is
         // held, and nothing started.
@@ -5591,7 +5642,7 @@ export class AgentFramework {
         // 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));
+            this.holdRequest(held, this.turnRetryOf(trigger, this.turnRouting.get(agent.name)));
         if (existing)
             clearTimeout(existing.timer);
         const timer = setTimeout(() => this.releaseProviderAccelerationCooldown(agent.name), Math.min(delayMs, MAX_TIMER_DELAY_MS));
@@ -5657,6 +5708,8 @@ export class AgentFramework {
         const request = { ...trigger, [REARMED]: true };
         delete request[TURN_RETRY];
         delete request[MERGED_BATCH];
+        delete request.wakeChannels;
+        Object.assign(request, this.wakeChannelsMark(routing));
         if (continuation) {
             request.reason = REARM_REASON;
             delete request.counterparty;
@@ -5711,7 +5764,7 @@ export class AgentFramework {
             return undefined;
         if (this.registry.homeChannel(agent.name) !== undefined) {
             const wait = this.recordProviderWait(agent.name, agent.model, error);
-            return error.retryable === true && wait !== undefined && this.holdForProviderWait(agent, wait, trigger ? [asTurnRetry(trigger)] : [], true)
+            return error.retryable === true && wait !== undefined && this.holdForProviderWait(agent, wait, trigger ? [this.turnRetryOf(trigger, this.turnRouting.get(agent.name))] : [], true)
                 ? 'held'
                 : undefined;
         }
@@ -5731,18 +5784,490 @@ export class AgentFramework {
         const cap = `${PROVIDER_ACCELERATION_MAX_COOLDOWN_MS / 1000} s`;
         if (Number.isNaN(stated)) {
             return {
-                error: `${error.message} (the provider's stated wait is not a number, and an ephemeral run sleeps only a ` +
+                error: `${failureWords(error)} (the provider's stated wait is not a number, and an ephemeral run sleeps only a ` +
                     `stated wait of ${cap} or less, so it ends now)`,
                 statedWaitMs: Number.NaN,
             };
         }
         const asked = Number.isFinite(stated) ? `${Math.ceil(stated / 1000)} s` : 'longer than can be represented';
         return {
-            error: `${error.message} (the provider asked to wait ${asked}; an ephemeral run doesn't sleep a stated wait ` +
+            error: `${failureWords(error)} (the provider asked to wait ${asked}; an ephemeral run doesn't sleep a stated wait ` +
                 `longer than ${cap}, so it ends now)`,
             statedWaitMs: stated,
         };
     }
+    holdForBudgetRefusal(agent, error, retry, checkpoint, routing, baseline, closeWindow) {
+        const { errorType } = this.classifyInferenceError(error);
+        if (errorType !== 'over_budget' && errorType !== 'context_refusal')
+            return false;
+        if (!this.budgetHolds || !this.running || this.providerAdmissionClosed)
+            return false;
+        if (this.ephemeralRuns.has(agent.name) || this.agents.get(agent.name) !== agent || this.budgetHolds.has(agent.name))
+            return false;
+        if (!this.compressionPending(agent))
+            return false;
+        if (checkpoint !== undefined) {
+            try {
+                this.dropTurnCheckpoint(agent.name, checkpoint);
+            }
+            catch (error) {
+                console.error(`[budget-hold] agent=${agent.name}: its refused start's checkpoint could not be dropped, so the refusal takes the error policy's path:`, error);
+                return false;
+            }
+        }
+        const turn = retry ?? { agentName: agent.name, reason: 'budget-hold-release', source: 'framework', timestamp: Date.now() };
+        const carried = budgetWaitOf(turn);
+        const startedAt = Date.now();
+        const standsOn = !continuesTurn(turn) && carried
+            ? (carried.row !== undefined ? [carried.row] : [])
+            : this.rowsTurnStandsOn(agent, turn, routing);
+        const wait = {
+            since: carried?.since ?? startedAt,
+            ...(!continuesTurn(turn) && standsOn[0] !== undefined ? { row: standsOn[0] } : {}),
+            ...(carried?.alerted ? { alerted: true } : {}),
+        };
+        turn[BUDGET_WAIT] = wait;
+        const figures = error;
+        const hold = {
+            startedAt,
+            wait,
+            turn,
+            standsOn,
+            wakes: [],
+            errorType,
+            reason: boundFailureText(String(error.message)),
+            budget: typeof figures.budget === 'number' ? figures.budget : undefined,
+            actual: typeof figures.actual === 'number' ? figures.actual : undefined,
+            managerCalls: 0,
+            progressAtHold: baseline ? baseline.progress : this.compressionProgressOf(agent),
+            settingsAtHold: baseline ? baseline.settings : agent.contextSettingsChanges(),
+        };
+        this.budgetHolds.set(agent.name, hold);
+        this.startBudgetHoldRecheck(agent, hold);
+        closeWindow();
+        const endGate = () => this.eventGate?.onInferenceEnded(agent.name);
+        this.emitTrace({
+            type: 'inference:held',
+            agentName: agent.name,
+            errorType,
+            error: hold.reason,
+            ...(hold.budget !== undefined ? { budget: hold.budget } : {}),
+            ...(hold.actual !== undefined ? { actual: hold.actual } : {}),
+            since: hold.startedAt,
+            heldRequests: 1,
+        });
+        if (this.budgetHolds.get(agent.name) !== hold) {
+            endGate();
+            return true;
+        }
+        if (!wait.alerted) {
+            wait.alerted = true;
+            this.opsAlert('context-refusal', agent.name, this.budgetHoldOpenText(hold), {
+                skipLog: true,
+                key: String(hold.wait.since),
+                data: {
+                    errorType,
+                    since: hold.wait.since,
+                    ...(hold.budget !== undefined ? { budget: hold.budget } : {}),
+                    ...(hold.actual !== undefined ? { actual: hold.actual } : {}),
+                },
+            });
+            if (this.budgetHolds.get(agent.name) !== hold) {
+                endGate();
+                return true;
+            }
+        }
+        endGate();
+        if (this.budgetHolds.get(agent.name) !== hold)
+            return true;
+        this.retractUnsentInjections(agent);
+        if (this.budgetHolds.get(agent.name) !== hold)
+            return true;
+        const readiness = this.contextReadiness(agent.getContextManager());
+        const compression = 'pending' in readiness && readiness.pending ? ` Compression: ${boundFailureText(readiness.pending)}` : '';
+        const again = carried ? `, as of a wait that began ${describeWait(startedAt - carried.since)} ago` : '';
+        console.error(`[budget-hold] agent=${agent.name} compile refused (${errorType}): ${hold.reason} \u2014 Held${again}: ` +
+            `the turn waits, idle, and runs once compression makes room.${compression}`);
+        this.driveBudgetHoldSoon(agent);
+        return true;
+    }
+    rowsTurnStandsOn(agent, turn, routing) {
+        if (!continuesTurn(turn)) {
+            const row = this.activeTurnTriggers.get(agent.name)?.readsRow;
+            return row !== undefined ? [row] : [];
+        }
+        const rows = routing.firstRow !== undefined ? [routing.firstRow] : [];
+        const from = routing.start?.sequence;
+        if (from === undefined)
+            return rows;
+        try {
+            const ownCalls = new Set();
+            for (const row of agent.getContextManager().getPresentedMessages()) {
+                if (!ownWindowRow(row, agent, ownCalls) || row.sequence <= from)
+                    continue;
+                if (storedInjectionMarkOf(row.metadata) !== undefined || clockStampOf(row.metadata) !== undefined)
+                    continue;
+                rows.push(String(row.id));
+            }
+        }
+        catch (error) {
+            console.error(`[budget-hold] agent=${agent.name}: could not read the rows its held turn stands on, so a surgery checks its first row alone:`, error);
+        }
+        return rows;
+    }
+    compressionPending(agent) {
+        try {
+            return !agent.getContextManager().isReady();
+        }
+        catch {
+            return false;
+        }
+    }
+    startBudgetHoldRecheck(agent, hold) {
+        clearInterval(hold.recheck);
+        hold.recheck = undefined;
+        if (this.maintenanceIntervalMs > 0)
+            return;
+        hold.recheck = setInterval(() => this.driveBudgetHold(agent), this.budgetHoldRecheckMs);
+        hold.recheck.unref?.();
+    }
+    driveBudgetHoldSoon(agent) {
+        const kick = setTimeout(() => this.driveBudgetHold(agent), 0);
+        kick.unref?.();
+    }
+    driveBudgetHold(agent) {
+        const hold = this.budgetHolds?.get(agent.name);
+        if (!hold || this.agents.get(agent.name) !== agent || hold.checkQueued)
+            return;
+        if (this.providerGateBlocked(agent.name))
+            return;
+        const kicked = this.kickOverBudgetDrain(agent.name, agent, () => {
+            hold.checkQueued = false;
+            if (this.budgetHolds.get(agent.name) !== hold)
+                return;
+            if (this.budgetHoldMoved(agent, hold))
+                this.releaseBudgetHold(agent.name);
+            else if (kicked === 'already draining')
+                this.driveBudgetHold(agent);
+        }, 'hold', hold.drainKicked);
+        if (kicked === 'kicking' || kicked === 'already draining')
+            hold.checkQueued = true;
+        if (kicked === 'kicking')
+            hold.drainKicked = true;
+    }
+    releaseBudgetHolds() {
+        for (const name of [...(this.budgetHolds?.keys() ?? [])])
+            this.releaseBudgetHold(name);
+    }
+    releaseBudgetHoldsOnEvidence() {
+        for (const name of [...(this.budgetHolds?.keys() ?? [])])
+            this.releaseBudgetHoldOnEvidence(name);
+    }
+    releaseBudgetHoldOnEvidence(agentName) {
+        const hold = this.budgetHolds?.get(agentName);
+        const agent = this.agents.get(agentName);
+        if (hold && agent && this.budgetHoldMoved(agent, hold))
+            this.releaseBudgetHold(agentName);
+    }
+    budgetHoldMoved(agent, hold) {
+        if (!this.compressionPending(agent) || agent.contextSettingsChanges() !== hold.settingsAtHold)
+            return true;
+        const progress = this.compressionProgressOf(agent);
+        if (progress !== undefined && hold.progressAtHold !== undefined)
+            return progress !== hold.progressAtHold;
+        if (progress !== undefined)
+            hold.progressAtHold = progress;
+        return hold.managerCalls !== 0;
+    }
+    compressionProgressOf(agent) {
+        const progress = this.contextProgress(agent.getContextManager());
+        if (!progress)
+            return undefined;
+        try {
+            const { chunksCompressed, summaryCounts } = progress;
+            if (chunksCompressed === undefined && summaryCounts === undefined)
+                return undefined;
+            return JSON.stringify([chunksCompressed, summaryCounts]);
+        }
+        catch (error) {
+            console.error(`[budget-hold] agent=${agent.name}: could not read its compression progress, so it reads as none:`, error);
+            return undefined;
+        }
+    }
+    closureWaits(agentName) {
+        const closure = (r) => r.agentName === agentName
+            && (mergedBatch(r) ?? [r]).some((m) => m.reason === 'conversation:closure');
+        return this.pendingRequests.some(closure)
+            || [...(this.passRequests ?? [])].some((pass) => (pass.get(agentName) ?? []).some(closure))
+            || (this.providerAccelerationCooldowns.get(agentName)?.heldRequests ?? []).some(closure)
+            || (this.budgetHolds?.get(agentName)?.wakes ?? []).some(closure);
+    }
+    releaseBudgetHold(agentName) {
+        const hold = this.budgetHolds?.get(agentName);
+        const agent = this.agents.get(agentName);
+        if (!hold || !agent || this.quiesced || this.surgeryHold)
+            return;
+        const requests = [hold.turn, ...hold.wakes];
+        hold.wakes = [];
+        this.budgetHolds.delete(agentName);
+        clearInterval(hold.recheck);
+        hold.recheck = undefined;
+        appendAll(this.pendingRequests, requests);
+        console.error(`[budget-hold] agent=${agentName} released after ${Date.now() - hold.startedAt}ms: ` +
+            `${requests.length} request(s) queued, and the start's own compile is the check`);
+        const note = this.storeBudgetHoldNote(agent, hold);
+        if (note !== undefined)
+            this.emitTrace({ type: 'message:added', messageId: note, source: `context-injection:${BUDGET_HOLD_NOTE_NAMESPACE}` });
+        this.finishBudgetHold(agentName, hold, 'released');
+    }
+    storeBudgetHoldNote(agent, hold) {
+        const size = hold.budget !== undefined && hold.actual !== undefined
+            ? ` (${hold.actual.toLocaleString('en-US')} tokens against ${hold.budget.toLocaleString('en-US')})`
+            : '';
+        const text = `[budget-hold] Your context didn't fit its budget${size} when a turn came to start. ` +
+            `That turn waited ${describeWait(Date.now() - hold.wait.since)}.`;
+        const row = asStoredRow({ namespace: BUDGET_HOLD_NOTE_NAMESPACE, position: 'afterUser', content: [{ type: 'text', text }] });
+        const mark = { agent: agent.name, namespace: row.namespace, contentHash: unitHash([row]), part: 0, parts: 1 };
+        try {
+            agent.markUnsentPoint();
+            return storeOwnRow(agent, row.participant, row.content, {
+                system: true, kind: STORED_INJECTION_KIND, [STORED_INJECTION_KEY]: mark,
+            }, undefined, !this.logicalTurnAlive(agent));
+        }
+        catch (error) {
+            console.error(`[budget-hold] agent=${agent.name}: the note for its released turn could not be stored:`, error);
+            return undefined;
+        }
+    }
+    finishBudgetHold(agentName, hold, outcome) {
+        if (this.budgetHolds?.get(agentName) === hold)
+            this.budgetHolds.delete(agentName);
+        clearInterval(hold.recheck);
+        hold.recheck = undefined;
+        const waitedMs = Date.now() - hold.startedAt;
+        console.error(`[budget-hold] agent=${agentName} hold ended (${outcome}) after ${waitedMs}ms`);
+        this.emitTrace({ type: 'inference:hold_ended', agentName, outcome, waitedMs });
+        if (outcome === 'released' || !hold.wait.alerted)
+            return;
+        const waitedFor = Date.now() - hold.wait.since;
+        const after = describeWait(waitedFor);
+        const words = outcome === 'removed'
+            ? `what the waiting turn was for was removed or taken out of its window after ${after}, so its waiting start doesn't run`
+            : `the waiting turn was stopped after ${after}, so its waiting start doesn't run`;
+        this.opsAlert('context-refusal-clear', agentName, words, {
+            skipLog: true,
+            key: String(hold.wait.since),
+            data: { outcome, waitedMs: waitedFor },
+        });
+    }
+    budgetHoldOpenText(hold) {
+        const head = `compile refused (${hold.errorType}): `;
+        const tail = ' \u2014 the turn waits while compression makes room, and runs once its context fits';
+        return head + boundFailureText(hold.reason, FAILURE_TEXT_MAX_CHARS - head.length - tail.length) + tail;
+    }
+    retractUnsentInjections(agent) {
+        if (!this.presents(agent))
+            return;
+        try {
+            const ids = agent.unsentInjectionRows();
+            if (ids.length === 0)
+                return;
+            agent.getContextManager().retractRows(ids, { undone: true });
+            this.emitTrace({ type: 'presentation:retracted', agentName: agent.name, messageIds: ids, reason: 'unsent-injection' });
+        }
+        catch (error) {
+            console.error(`[budget-hold] agent=${agent.name}: the injection rows its refused start stored could not leave its window:`, error);
+        }
+    }
+    endHeldTurn(agentName, turn, drop) {
+        this.endContinuedTurn(agentName, drop, !continuesTurn(turn));
+    }
+    dropBudgetHold(agentName, drop, wakes = 'gone') {
+        const hold = this.budgetHolds?.get(agentName);
+        if (!hold)
+            return false;
+        this.budgetHolds.delete(agentName);
+        clearInterval(hold.recheck);
+        hold.recheck = undefined;
+        if (wakes === 'back')
+            appendAll(this.pendingRequests, hold.wakes);
+        hold.wakes = [];
+        try {
+            this.endHeldTurn(agentName, hold.turn, drop);
+        }
+        finally {
+            this.finishBudgetHold(agentName, hold, 'stopped');
+        }
+        return true;
+    }
+    heldContinuation(agentName) {
+        const hold = this.budgetHolds?.get(agentName);
+        return hold !== undefined && continuesTurn(hold.turn);
+    }
+    dropHeldTurn(agentName, hold, why) {
+        this.endDetachedHold(agentName, this.detachBudgetHold(agentName, hold), why);
+    }
+    /** Take `hold` out of its agent's wait, with no trace yet. */
+    detachBudgetHold(agentName, hold) {
+        this.budgetHolds.delete(agentName);
+        clearInterval(hold.recheck);
+        hold.recheck = undefined;
+        return hold;
+    }
+    /** End a turn detachBudgetHold took out of its wait: its wakes back in the queue, then its end traced. */
+    endDetachedHold(agentName, hold, why) {
+        appendAll(this.pendingRequests, hold.wakes);
+        hold.wakes = [];
+        try {
+            this.endHeldTurn(agentName, hold.turn, { kind: 'dropped', why, reason: BUDGET_HELD_TURN_REMOVED });
+        }
+        finally {
+            this.finishBudgetHold(agentName, hold, 'removed');
+        }
+    }
+    rowGone(agent, row) {
+        try {
+            return agent.getContextManager().getMessage(row) === null;
+        }
+        catch (error) {
+            console.error(`[budget-hold] agent=${agent.name}: could not read whether row ${row} is still there, so what waits on it stays:`, error);
+            return false;
+        }
+    }
+    rowLeftWindow(agent, row) {
+        if (this.rowGone(agent, row))
+            return true;
+        if (!this.presents(agent))
+            return false;
+        try {
+            return agent.getContextManager().ordinalOf(row) === undefined;
+        }
+        catch (error) {
+            console.error(`[budget-hold] agent=${agent.name}: could not read whether row ${row} is still in its window, so what waits on it stays:`, error);
+            return false;
+        }
+    }
+    budgetWaitEnded(agent, trigger) {
+        const row = budgetWaitOf(trigger)?.row;
+        if (row === undefined || !this.rowLeftWindow(agent, row))
+            return false;
+        const batch = mergedBatch(trigger);
+        if (batch)
+            appendAll(this.pendingRequests, batch.filter((r) => budgetWaitOf(r) === undefined));
+        this.endContinuedTurn(agent.name, { kind: 'dropped', why: 'what its held turn stood on was removed', reason: BUDGET_HELD_TURN_REMOVED }, true);
+        return true;
+    }
+    checkBudgetHoldsAfterWindowChange(only, release = true) {
+        for (const [agentName, hold] of [...(this.budgetHolds?.entries() ?? [])]) {
+            const agent = this.agents.get(agentName);
+            if (!agent || (only !== undefined && agentName !== only) || this.budgetHolds?.get(agentName) !== hold)
+                continue;
+            const wakes = hold.wakes.filter((wake) => wake.readsRow === undefined || !this.rowGone(agent, wake.readsRow));
+            if (wakes.length < hold.wakes.length) {
+                console.error(`[budget-hold] agent=${agentName}: ${hold.wakes.length - wakes.length} held wake(s) dropped, their rows removed`);
+            }
+            hold.wakes = wakes;
+            if (hold.standsOn.some((row) => this.rowLeftWindow(agent, row))) {
+                this.dropHeldTurn(agentName, hold, 'a surgery or an undo removed what its held turn stood on');
+            }
+            else if (release) {
+                this.releaseBudgetHold(agentName);
+            }
+        }
+    }
+    kickOverBudgetDrain(agentName, agent, after, by = 'breaker', quiet = false) {
+        // Like a maintenance pass: none starts once stop() has begun, it starts
+        // no tick while a surgery holds the store or once its agent has been
+        // disposed, and a surgery, a switchBranch or stop() waits for the tick
+        // in flight. It joins the drains they wait for before the breaker's alert is
+        // raised and before its body runs, so the alert's listeners find it:
+        // one that begins stop() or a surgery waits for it, and its body then
+        // ticks none and says why. So does a stop() made from inside its first
+        // tick, before that tick's first await.
+        if (this.providerAdmissionClosed)
+            return 'not kicked: the framework is stopping';
+        if (this.surgeryHold)
+            return 'not kicked: a surgery holds the store';
+        if (after) {
+            const waiting = this.overBudgetDrainAfter.get(agentName);
+            if (waiting)
+                waiting.push(after);
+            else
+                this.overBudgetDrainAfter.set(agentName, [after]);
+        }
+        if (this.overBudgetDrainInFlight.has(agentName))
+            return 'already draining';
+        this.overBudgetDrainInFlight.add(agentName);
+        const tag = by === 'hold' ? '[budget-hold]' : '[inference-failed]';
+        const label = by === 'hold' ? 'budget hold' : 'OverBudget breaker';
+        const drain = Promise.resolve().then(async () => {
+            let ticks = 0;
+            let record;
+            try {
+                const cm = agent.getContextManager();
+                if (by === 'hold') {
+                    const readiness = this.contextReadiness(cm);
+                    const progress = this.contextProgress(cm);
+                    record = {
+                        agentName, startedAt: Date.now(), ticks: 0, readyBefore: false,
+                        ...('pending' in readiness && readiness.pending ? { pendingBefore: readiness.pending } : {}),
+                        ...(progress ? { progressBefore: progress } : {}),
+                    };
+                }
+                const holding = () => this.budgetHolds.has(agentName);
+                while ((by === 'hold' ? holding() : ticks < 8) && !this.providerAdmissionClosed && !this.surgeryHold && this.agents.get(agentName) === agent) {
+                    const calls = by === 'hold' ? this.budgetHolds.get(agentName)?.managerCalls : undefined;
+                    await cm.tick();
+                    ticks++;
+                    if (by === 'breaker')
+                        continue;
+                    const held = this.budgetHolds.get(agentName);
+                    if (held && this.budgetHoldMoved(agent, held)) {
+                        this.releaseBudgetHold(agentName);
+                        if (this.quiesced)
+                            break;
+                    }
+                    else if (held?.managerCalls === calls || this.compressionProgressOf(agent) !== undefined) {
+                        break;
+                    }
+                }
+                if (by === 'hold' && ticks > 0)
+                    this.maintenanceFailureReported.delete(agentName);
+                const stopped = by === 'breaker' && ticks >= 8 ? ''
+                    : this.agents.get(agentName) !== agent ? ', stopped as the agent was disposed'
+                        : this.providerAdmissionClosed ? ', stopped as the framework stops'
+                            : this.surgeryHold ? ', stopped while a surgery holds the store'
+                                : '';
+                if (!quiet || stopped)
+                    console.error(`${tag} drain kicked for ${agentName} (${label}, ${ticks} ticks${stopped})`);
+            }
+            catch (err) {
+                if (err instanceof MaintenanceWithdrawnError) {
+                    console.error(`${tag} drain kicked for ${agentName} (${label}, ${ticks} ticks, stopped: ${err.message})`);
+                }
+                else if (record) {
+                    record.ticks = ticks;
+                    record.finishedAt = Date.now();
+                    this.reportMaintenanceFailure(agentName, record, err instanceof Error ? String(err.message) : failureDescription(err));
+                }
+                else {
+                    console.error(`${tag} drain kick failed for ${agentName} after ${ticks} ticks: ${describeFailureWithFrames(err)}`);
+                }
+            }
+            finally {
+                this.overBudgetDrainInFlight.delete(agentName);
+            }
+            const waiting = this.overBudgetDrainAfter?.get(agentName);
+            if (waiting) {
+                this.overBudgetDrainAfter.delete(agentName);
+                for (const run of waiting)
+                    run();
+            }
+        });
+        this.overBudgetDrains.add(drain);
+        void drain.finally(() => { this.overBudgetDrains.delete(drain); });
+        return 'kicking';
+    }
     /** When a hold's timer next fires: at its deadline, stepped past what one
      *  timer can hold. A hold with no deadline (a wait held until released, or
      *  the stand-in for unreadable records) asks again as often as unreadable
@@ -5803,7 +6328,7 @@ export class AgentFramework {
         }
         const requests = cooldown.heldRequests.length > 0 ? cooldown.heldRequests : [{ agentName,
                 reason: 'provider-acceleration-retry', source: 'framework', timestamp: Date.now() }];
-        this.pendingRequests.push(...requests);
+        appendAll(this.pendingRequests, requests);
         console.error(cooldown.rearm
             ? `[inference-rearm] agent=${agentName} turn queued again (${cooldown.rearm.number} of ${cooldown.rearm.of})`
             : `[provider-cooldown] agent=${agentName} released after ${Date.now() - cooldown.startedAt}ms — ` +
@@ -5959,7 +6484,7 @@ export class AgentFramework {
         // (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);
+            appendAll(this.pendingRequests, requests);
             return true;
         }
         const existing = this.providerAccelerationCooldowns.get(agent.name);
@@ -6152,6 +6677,7 @@ export class AgentFramework {
         void pass.finally(() => {
             if (this.maintenancePass === pass)
                 this.maintenancePass = null;
+            this.releaseBudgetHoldsOnEvidence();
         });
         begin(this.runQueuedMaintenance().catch((error) => {
             // The alert cuts its own copies from the whole message, so the
@@ -6658,6 +7184,9 @@ export class AgentFramework {
             this.dropContinuations(agentName, { kind: 'caller', reason, why: 'a stop ended the turn' });
             return true;
         }
+        if (!result && this.budgetHolds?.has(agentName)) {
+            return this.dropBudgetHold(agentName, { kind: 'caller', reason, why: 'a stop ended the turn' }, 'back');
+        }
         return !!result;
     }
     /**
@@ -6762,6 +7291,7 @@ export class AgentFramework {
             log({
                 success: false,
                 error: `Stream cancelled (${reason})`,
+                errorWords: `Stream cancelled (${reason})`,
                 request: compiledRequest ?? { note: 'streaming request aborted' },
                 durationMs,
             });
@@ -6829,6 +7359,7 @@ export class AgentFramework {
             log({
                 success: false,
                 error: `Stream aborted: ${kind}`,
+                errorWords: `Stream aborted: ${kind}`,
                 request: compiledRequest ?? { note: `streaming request aborted by ${kind}` },
                 durationMs,
             });
@@ -7477,7 +8008,7 @@ export class AgentFramework {
         const extKeys = [];
         for (const ext of extensions.values()) {
             Object.assign(extProperties, ext.properties);
-            extKeys.push(...ext.keys);
+            appendAll(extKeys, ext.keys);
         }
         const settingsProp = baseSchema.properties.settings;
         return {
@@ -7842,7 +8373,8 @@ export class AgentFramework {
                 ...this.pendingRequests,
                 ...[...this.passRequests].flatMap((pass) => [...pass.values()].flat()),
                 ...[...this.providerAccelerationCooldowns.values()].flatMap((c) => c.heldRequests),
-            ].flatMap((r) => mergedBatch(r) ?? [r]).filter((r) => !passesQuiesce(r)).length,
+            ].flatMap((r) => mergedBatch(r) ?? [r]).filter((r) => !passesQuiesce(r)).length
+                + [...(this.budgetHolds?.values() ?? [])].reduce((n, h) => n + 1 + h.wakes.flatMap((r) => mergedBatch(r) ?? [r]).filter((r) => !passesQuiesce(r)).length, 0),
             backgroundScripts: this.codeExecution?.scripts.leftRunning() ?? 0,
             // Deprecated (#291): no queue is kept. What a live surgery's hold
             // keeps in memory, to land at its release, and what waits in memory
@@ -8207,6 +8739,7 @@ export class AgentFramework {
             console.error(this.queue?.isClosed
                 ? `[host-mode] resumed — ${releasedRequests} parked wake(s) won't run because the framework is stopping`
                 : `[host-mode] resumed — ${releasedRequests} parked wake(s) released`);
+            this.releaseBudgetHolds();
         }
         return this.getHostModeStatus();
     }
@@ -9648,10 +10181,12 @@ export class AgentFramework {
                     store: this.store,
                     namespace,
                     isolate: true,
+                    viewFilter: (message) => !isReasoningLoss(message.metadata),
                     strategy: config.strategy ?? new PassthroughStrategy(),
                     membrane: this.ephemeralAuxiliaryMembraneFor(config.name, release),
                     debugLogContext: !!process.env.DEBUG_CONTEXT,
                 });
+                this.storeSees.set(contextManager, (metadata) => !isReasoningLoss(metadata));
                 ownSlot = { namespace };
             }
             // Either manager is the run's to release (main's manager release), the derived one included.
@@ -10035,7 +10570,8 @@ export class AgentFramework {
      * The returned manager uses a passthrough strategy, so nothing is
      * folded: its compile is the agent's window as the agent's view shows it
      * (the rows the window holds, through its view filter), and in legacy
-     * mode, where the window is the record, the record so. getAllMessages()
+     * mode, where the window is the record, the record so. These compiled
+     * views omit legacy reasoning-loss notices. getAllMessages()
      * lists the record. An ended agent's context is the real one — treat it as
      * read-only unless you mean to change what a later resume starts from.
      */
@@ -10154,9 +10690,9 @@ export class AgentFramework {
      * and what it observes (context-options.ts): a resident's, on the
      * residents' slot, or for an isolated agent that watches that slot, the
      * residents' view when its edge leaves held traffic out, and the
-     * subconscious's when it shows it. Undefined for an isolated agent that
+     * subconscious's when it shows it. For an isolated agent that
      * watches no residents' slot on its branch (a worker, a conversation
-     * fork), whose context was opened with no filter.
+     * fork), whose view excludes only legacy reasoning-loss notices.
      */
     liveViewFilterOf(record) {
         if (record.ownSlot?.namespace === null)
@@ -10166,7 +10702,7 @@ export class AgentFramework {
             return slot !== undefined && slot.branch === undefined && sameSlot(slot, RESIDENTS_SLOT);
         });
         if (residents.length === 0)
-            return undefined;
+            return (message) => !isReasoningLoss(message.metadata);
         return residents.some((edge) => edge.includeHeld === true) ? subconsciousViewFilter(record.name) : residentViewFilter(record.name);
     }
     /**
@@ -10192,7 +10728,7 @@ export class AgentFramework {
      * (deriveSharedContext): what the agent its chain of derivations started
      * from sees (liveViewFilterOf), and the stored injections of each agent in
      * the chain, which carry that agent's name and would otherwise read as
-     * another's. Undefined when the owner's context has no filter.
+     * another's. Legacy notices remain excluded even for an own injection.
      */
     derivedViewFilterOf(record) {
         const owner = this.viewOwnerOf(record);
@@ -10211,7 +10747,8 @@ export class AgentFramework {
         }
         if (names.length === 0)
             return ownerSees;
-        return (message) => ownerSees(message) || names.some((name) => isOwnInjection(message.metadata, name));
+        return (message) => !isReasoningLoss(message.metadata)
+            && (ownerSees(message) || names.some((name) => isOwnInjection(message.metadata, name)));
     }
     /** Open a derived agent's context on a branch of its own (see deriveAgent). */
     async deriveSharedContext(config, inherit, release) {
@@ -10243,13 +10780,11 @@ export class AgentFramework {
         // reads through it, and is recorded beside the manager (storeSees), so
         // main's checks of whether an agent sees a row (agentSees: a tool
         // boundary's injection, an arrival, a reader of an unread message) ask
-        // what its compile shows. A source with no view recorded has no filter
-        // (an isolated run's): it sees every row, so its fork keeps none, and
-        // sees its own.
+        // what its compile shows. The global legacy-notice exclusion applies
+        // even when the source has no additional view recorded.
         const sourceSees = this.storeSees.get(source);
-        const sees = sourceSees
-            ? (metadata) => sourceSees(metadata) || isOwnInjection(metadata, config.name)
-            : undefined;
+        const sees = (metadata) => !isReasoningLoss(metadata)
+            && (!sourceSees || sourceSees(metadata) || isOwnInjection(metadata, config.name));
         const contextManager = await source.derive({
             branch: ownBranch,
             strategy: config.strategy ?? new PassthroughStrategy(),
@@ -10259,11 +10794,10 @@ export class AgentFramework {
             solve: inherit.solve ?? 'reuse',
             inherit: { refusals: inherit.refusals === true },
             ...(inherit.atSequence !== undefined ? { atSequence: inherit.atSequence } : {}),
-            ...(sees ? { viewFilter: (message) => sees(message.metadata) } : {}),
+            viewFilter: (message) => sees(message.metadata),
             debugLogContext: !!process.env.DEBUG_CONTEXT,
         });
-        if (sees)
-            this.storeSees.set(contextManager, sees);
+        this.storeSees.set(contextManager, sees);
         const derivation = contextManager.getDerivation?.();
         return {
             contextManager,
@@ -10781,6 +11315,7 @@ export class AgentFramework {
         this.closingConversationAgents.delete(name);
         // A continuation of its turn still on its way goes with it.
         this.dropContinuations(name, { kind: 'dropped', why });
+        this.dropBudgetHold(name, { kind: 'dropped', why });
         // A batch its guard still holds is settled as `aborted`: the stream's
         // own finally does neither once the agent has gone.
         if (agent.toolResultGuard.hasPending) {
@@ -11484,9 +12019,10 @@ export class AgentFramework {
         if (outcome.stopReason === 'exhausted') {
             // The caller may log or relay the message, which can echo the whole request.
             const message = boundFailureText(outcome.error ?? 'Unknown error');
+            const options = outcome.cause !== undefined ? { cause: boundedCause(outcome.cause) } : undefined;
             run.settle.reject(outcome.statedWaitMs === undefined
-                ? new Error(message)
-                : new ProviderWaitNotSleptError(message, outcome.statedWaitMs));
+                ? new Error(message, options)
+                : new ProviderWaitNotSleptError(message, outcome.statedWaitMs, options));
             return;
         }
         run.settle.resolve({
@@ -11504,7 +12040,19 @@ export class AgentFramework {
      * Rejects with ProviderWaitNotSleptError when the run ends rather than sleep
      * a retryable failure's stated wait longer than the framework's ten-minute
      * cap, or one it can't represent, and with a plain Error for any other
-     * ending, a stated wait its error policy declines among them.
+     * ending, a stated wait its error policy declines among them. A failed
+     * turn's rejection never carries a provider's message: a provider's failure
+     * is told by membrane's type and the HTTP status, a safety failure only as
+     * a request that couldn't be completed, a progress bound's cut, a stream's
+     * abort and context-manager's refusal of a compile in their own words, and
+     * any other failure as the turn failing. Where an error ended the turn, the
+     * rejection's `cause` is a bounded copy of it: a plain `Error` with its
+     * `name`, its message and stack cut to 2,000 characters, and, from a
+     * MembraneError, its `type`, `retryable`, `httpStatus`, `providerErrorCode`
+     * and `retryAfterMs`, which a host reads by name. It carries no `rawError`
+     * or `rawRequest`, and `instanceof MembraneError` doesn't hold on it. Its
+     * message and stack are the failure's own, a provider's words included, for
+     * classifying the failure and for logs, and aren't for showing to an agent.
      *
      * The caller provides a pre-created agent + contextManager (from createEphemeralAgent).
      * The task message should already be in the context manager.
@@ -12518,7 +13066,7 @@ export class AgentFramework {
                 const turnMembers = all.slice(turn.from, turn.to + 1);
                 if (turnMembers.some((m) => hasBlock(m, 'tool_use'))) {
                     from = turn.from;
-                    removedIds.push(...turnMembers.map((m) => m.id).reverse());
+                    appendAll(removedIds, turnMembers.map((m) => m.id).reverse());
                     heads.unshift(all[turn.from].id);
                 }
             }
@@ -12557,16 +13105,9 @@ export class AgentFramework {
         const cm = agent.getContextManager();
         const ep = this.rewindEpisode.get(agent.name);
         const count = (ep?.count ?? 0) + 1;
-        const why = cause === 'refusal'
-            ? `the model refused on them (content filter: ${failureShown(category)}). Their content is ` +
-                `not reproduced here (so this note can't re-trigger the filter); the ` +
-                `originals remain in the raw record`
-            : `the model API kept refusing the requests that carried them (${failureShown(category)}), ` +
-                `so that the conversation could go on. Their content is not reproduced ` +
-                `here (so this note can't trigger the same refusal); the originals remain ` +
-                `in the raw record`;
         const text = `[${NOTICE_TAG.refusalRewind}] The ${count} most recent turn(s) were set aside because ` +
-            `${why}. You are clear to continue — if you ` +
+            `the requests that carried them couldn't be completed. Their content isn't shown here, ` +
+            `and the originals remain in the raw record. You are clear to continue — if you ` +
             `were mid-task, take a different approach; otherwise carry on with whatever ` +
             `is now in front of you, or briefly acknowledge the gap and ask what's next.`;
         const blocks = [{ type: 'text', text }];
@@ -12614,9 +13155,9 @@ export class AgentFramework {
             : '';
         const content = success
             ? `🔧 Unstuck **${agentName}** — shed ${n} turn(s); the model responded.${list}`
-            : `⚠️ Couldn't unstick **${agentName}** — still refusing after ${n} rewind(s)` +
-                `${category ? ` (category=${category})` : ''}.${list}`;
-        console.error(`[unstick] agent=${agentName} ${success ? 'succeeded' : 'gave up'} after ${n} rewind(s)`);
+            : `⚠️ Couldn't unstick **${agentName}** — its requests still couldn't be completed after ${n} rewind(s).${list}`;
+        console.error(`[unstick] agent=${agentName} ${success ? 'succeeded' : 'gave up'} after ${n} rewind(s)` +
+            `${category ? ` category=${logValue(category)}` : ''}`);
         if (s.channelId)
             void this.postToChannel(s.serverId, s.channelId, content);
     }
@@ -13227,6 +13768,7 @@ export class AgentFramework {
                         requestId: entry.requestId,
                         success: entry.success,
                         error: entry.error,
+                        errorWords: entry.errorWords,
                         durationMs: entry.durationMs,
                         tokenUsage: entry.tokenUsage,
                         stopReason: entry.stopReason,
@@ -13543,7 +14085,7 @@ export class AgentFramework {
         let failures = [];
         try {
             this.subconsciousAnchor?.branchMoved(this.tuneOutCoordinator?.activeEpochIds());
-            this.tuneOutCoordinator?.branchMoved();
+            this.tuneOutCoordinator?.branchMoved(sameBranch);
             if (!sameBranch)
                 this.redoStacks.clear();
             failures = await this.reinitializeManagers(except);
@@ -13652,6 +14194,22 @@ export class AgentFramework {
      * recorded with its error.
      */
     undoOnWindow(agent, requester) {
+        // A turn under way that waits for compression stands on what the undo
+        // takes out. It leaves its wait first, so the undo finds the agent idle,
+        // and it ends once the undo has kept its record, so a listener of its
+        // end finds the undo done.
+        const held = this.budgetHolds?.get(agent.name);
+        const taken = held && continuesTurn(held.turn) && !this.hasTurn(agent.name) && !this.turnAlive(agent)
+            ? this.detachBudgetHold(agent.name, held) : undefined;
+        try {
+            return this.undoTurnOnWindow(agent, requester);
+        }
+        finally {
+            if (taken)
+                this.endDetachedHold(agent.name, taken, 'an undo took out what its held turn stood on');
+        }
+    }
+    undoTurnOnWindow(agent, requester) {
         const agentName = agent.name;
         // A turn alive (its start, its stream, its tools, a continuation or a
         // provider hold's retry on its way) holds the window: its next rows
@@ -13695,6 +14253,7 @@ export class AgentFramework {
             }
             this.emitTrace({ type: 'window:undone', agentName, retracted: 0 });
             record(window);
+            this.checkBudgetHoldsAfterWindowChange(agentName);
             return { undone: true, turnIndex: checkpoint.turnIndex, fromBranch: branch, toBranch: branch, window };
         }
         const entry = {
@@ -13727,6 +14286,7 @@ export class AgentFramework {
             const reason = error instanceof Error ? error.message : String(error);
             this.emitTrace({ type: 'window:undone', agentName, retracted: left });
             record({ retracted: left, represented: 0 }, reason);
+            this.checkBudgetHoldsAfterWindowChange(agentName, false);
             throw new OperatorActionError('failed', `Undo of ${agentName}'s turn ${checkpoint.turnIndex} was cut short: ${left} of the ${tail.length} rows it takes out of the window left it ` +
                 `(${reason}). redo() puts them back in their order, or another undo finishes it`, { cause: error });
         }
@@ -13747,12 +14307,14 @@ export class AgentFramework {
             const reason = error instanceof Error ? error.message : String(error);
             this.emitTrace({ type: 'window:undone', agentName, retracted: tail.length });
             record(window, reason);
+            this.checkBudgetHoldsAfterWindowChange(agentName, false);
             const rows = tail.length === 1 ? '1 row' : `${tail.length} rows`;
             throw new OperatorActionError('failed', `Undo of ${agentName}'s turn ${checkpoint.turnIndex} took its ${rows} out of the window, and saving its checkpoints ` +
                 `failed (${reason}). redo() puts ${tail.length === 1 ? 'it' : 'them'} back, or another undo finishes it`, { cause: error });
         }
         this.emitTrace({ type: 'window:undone', agentName, retracted: tail.length });
         record(window);
+        this.checkBudgetHoldsAfterWindowChange(agentName);
         return { undone: true, turnIndex: checkpoint.turnIndex, fromBranch: branch, toBranch: branch, window };
     }
     /**
@@ -13949,7 +14511,7 @@ export class AgentFramework {
         this.retakeMarks(agent, cm, entry, back, below);
         const ordinals = back.map((id) => cm.ordinalOf(id)).filter((ordinal) => ordinal !== undefined);
         const boundary = {
-            indexLengthBefore: ordinals.length > 0 ? Math.min(...ordinals) : cm.indexLength(),
+            indexLengthBefore: ordinals.length > 0 ? ordinals.reduce((min, ordinal) => Math.min(min, ordinal), Infinity) : cm.indexLength(),
             windowBranch: cm.currentBranch().name,
         };
         const checkpoints = this.getTurnCheckpoints(agentName);
@@ -14235,6 +14797,7 @@ export class AgentFramework {
             this.releaseSurgeryHeldWrites();
             for (const name of reserved.keys())
                 this.presentAtEndOf(this.agents.get(name));
+            this.checkBudgetHoldsAfterWindowChange();
         };
     }
     async reinitializeManagers(except) {
@@ -14294,7 +14857,7 @@ export class AgentFramework {
             }
             console.error(`[surgery] agent=${agentName}: its context manager is re-initialized, so the ${writes.length} write(s) kept in ` +
                 "memory for it while it refused its work go to the move's release, ahead of the writes its hold keeps");
-            recovered.push(...writes);
+            appendAll(recovered, writes);
         }
         if (recovered.length === 0)
             return;
@@ -14302,7 +14865,9 @@ export class AgentFramework {
         // two agents whose slot one record holds (residents) land there in the
         // order they came.
         recovered.sort((x, y) => x.heldOrder - y.heldOrder);
-        this.surgeryHeldWrites.unshift(...recovered);
+        const later = this.surgeryHeldWrites.splice(0);
+        appendAll(this.surgeryHeldWrites, recovered);
+        appendAll(this.surgeryHeldWrites, later);
         if (!this.surgeryHold)
             this.releaseSurgeryHeldWrites();
     }
@@ -14365,7 +14930,7 @@ export class AgentFramework {
             return found;
         };
         for (const [agentName, writes] of this.heldForRecovery ?? []) {
-            entry(agentName).recovery.push(...writes.filter((write) => !told.has(write)));
+            appendAll(entry(agentName).recovery, writes.filter((write) => !told.has(write)));
         }
         for (const write of this.surgeryHeldWrites ?? []) {
             if (told.has(write))
@@ -15677,10 +16242,19 @@ export class AgentFramework {
         const checkpoints = this.getTurnCheckpoints(agentName);
         checkpoints.push(checkpoint);
         // Trim to max depth
-        if (checkpoints.length > MAX_TURN_CHECKPOINTS) {
-            checkpoints.splice(0, checkpoints.length - MAX_TURN_CHECKPOINTS);
-        }
+        const evicted = checkpoints.length > MAX_TURN_CHECKPOINTS
+            ? checkpoints.splice(0, checkpoints.length - MAX_TURN_CHECKPOINTS)
+            : [];
         this.saveTurnCheckpoints(agentName, checkpoints);
+        return { turnIndex, evicted };
+    }
+    dropTurnCheckpoint(agentName, recorded) {
+        const checkpoints = this.getTurnCheckpoints(agentName);
+        if (checkpoints.at(-1)?.turnIndex !== recorded.turnIndex)
+            return;
+        checkpoints.pop();
+        this.saveTurnCheckpoints(agentName, recorded.evicted.concat(checkpoints));
+        this.turnCounters.set(agentName, recorded.turnIndex);
     }
     /**
      * Checkpoints live in one Tree state (TURN_CHECKPOINTS_TREE_ID) keyed by agent
@@ -16560,7 +17134,7 @@ export class AgentFramework {
                     // reads the time it's written (clock-rows.ts).
                     const clock = injects ? this.storeDueClock(agent, 'tool-boundary') : undefined;
                     if (presentsWindow) {
-                        heard.push(...this.presentation.presentAtBoundary(agent, [replyId, resultsId, clock?.id], { injects }).heard);
+                        appendAll(heard, this.presentation.presentAtBoundary(agent, [replyId, resultsId, clock?.id], { injects }).heard);
                     }
                     // The clock's store and the boundary's presentations run their
                     // listeners synchronously too, and one may have stopped the turn,
@@ -16849,6 +17423,7 @@ export class AgentFramework {
                             timestamp: Date.now(),
                             suppressProse: this.activeTurnTriggers.get(agent.name)?.suppressProse,
                             silentHeartbeat: this.activeTurnTriggers.get(agent.name)?.silentHeartbeat,
+                            ...this.wakeChannelsMark(this.turnRouting.get(agent.name)),
                         }, currentState.stream ? this.streamCarries.get(currentState.stream)?.() : undefined);
                         this.pendingRequests.push(continuation);
                         // Context budget exceeded: break the stream, let compile() compress.
@@ -16986,6 +17561,7 @@ export class AgentFramework {
                             timestamp: Date.now(),
                             suppressProse: this.activeTurnTriggers.get(agent.name)?.suppressProse,
                             silentHeartbeat: this.activeTurnTriggers.get(agent.name)?.silentHeartbeat,
+                            ...this.wakeChannelsMark(this.turnRouting.get(agent.name)),
                         });
                     }
                 }
@@ -17759,6 +18335,7 @@ export class AgentFramework {
                 store: this.store,
                 namespace: `conversations/${name}`,
                 isolate: true,
+                viewFilter: (message) => !isReasoningLoss(message.metadata),
                 // Strategy instances are stateful — never share the template's.
                 strategy: router.strategyFactory?.() ?? new PassthroughStrategy(),
                 // Provider cooldown ownership belongs to the persistent resident only;
@@ -17769,6 +18346,7 @@ export class AgentFramework {
             });
             release.manager = contextManager;
             this.trackManager(contextManager);
+            this.storeSees.set(contextManager, (metadata) => !isReasoningLoss(metadata));
             // Seed with the template's compiled context, renaming the template
             // participant so the fork reads its inheritance as its own history.
             // Guard: only seed a genuinely fresh namespace. Generation counters are
@@ -18027,6 +18605,7 @@ export class AgentFramework {
             this.thinkingLossIncidents.forget(agentName);
             // A continuation of its turn still on its way goes with it.
             this.dropContinuations(agentName, { kind: 'dropped', why: 'its agent was disposed' });
+            this.dropBudgetHold(agentName, { kind: 'dropped', why: 'its agent was disposed' });
             this.turnRouting.delete(agentName);
             this.proseSpeechChains.delete(agentName);
             this.openLogical.delete(agentName);
@@ -18125,8 +18704,8 @@ export class AgentFramework {
         }
         // Fallback reaper: a closing fork whose closure inference never ran
         // (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
+        // registered forever. No turn, no active stream, no pending request, no
+        // closure wake waiting and no budget hold = done. A turn holds its token from dequeue, through its hooks and
         // 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
@@ -18134,7 +18713,9 @@ export class AgentFramework {
         for (const agentName of [...this.closingConversationAgents]) {
             if (!this.hasTurn(agentName) &&
                 !this.activeStreams.has(agentName) &&
-                !this.pendingRequests.some((r) => r.agentName === agentName)) {
+                !this.pendingRequests.some((r) => r.agentName === agentName) &&
+                !this.closureWaits(agentName) &&
+                !this.budgetHolds?.has(agentName)) {
                 this.disposeConversationAgent(agentName, 'idle-ttl');
             }
         }
@@ -19054,7 +19635,7 @@ export class AgentFramework {
                 eventType: 'mcpl:push-event',
                 ...(occ.tags ? { tags: occ.tags } : {}),
             },
-        }, { suppressible, ...remembered });
+        }, { suppressible, ...remembered, folds: true });
         // Its batch's row, written later, reads this decision, since a rule's
         // script answers once per event. (A copy of the occurrence, as a wake to
         // read a row has, was decided before it was copied.)
@@ -19131,6 +19712,8 @@ export class AgentFramework {
             unrecord(r);
         for (const cooldown of this.providerAccelerationCooldowns.values())
             cooldown.heldRequests.forEach(unrecord);
+        for (const hold of this.budgetHolds?.values() ?? [])
+            hold.wakes.forEach(unrecord);
         for (const r of this.parkedContinuations ?? [])
             unrecord(r);
         for (const pass of this.passRequests ?? [])
@@ -19144,13 +19727,15 @@ export class AgentFramework {
             if (held > 0 && cooldown.heldRequests.length === 0)
                 cooldown.emptiedBy = 'withdrawal';
         }
+        for (const hold of this.budgetHolds?.values() ?? [])
+            hold.wakes = hold.wakes.filter((r) => !withdrawn(r));
         for (const pass of this.passRequests ?? []) {
             for (const requests of pass.values()) {
                 if (!requests.some((r) => emptied.has(r)))
                     continue;
                 const left = requests.filter((r) => !emptied.has(r));
                 requests.length = 0;
-                requests.push(...left);
+                appendAll(requests, left);
             }
         }
         for (const start of emptied) {
@@ -19695,7 +20280,7 @@ export class AgentFramework {
             const agent = this.agents.get(agentName);
             if (!agent) {
                 // Agent not found — request is orphaned. Emit warning and drop.
-                const oldest = Math.min(...requests.map(r => r.timestamp));
+                const oldest = requests.reduce((min, r) => Math.min(min, r.timestamp), Infinity);
                 this.emitTrace({
                     type: 'inference:request_dropped',
                     agentName,
@@ -19710,6 +20295,12 @@ export class AgentFramework {
                 }
                 continue;
             }
+            const budgetHold = this.budgetHolds?.get(agentName);
+            if (budgetHold) {
+                for (const req of requests)
+                    this.holdRequest(budgetHold.wakes, req);
+                continue;
+            }
             const providerCooldown = this.providerAccelerationCooldowns?.get(agentName);
             if (providerCooldown) {
                 // A provider wait binds its own model; with a different primary model
@@ -19746,7 +20337,24 @@ export class AgentFramework {
             // 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]);
+                requests = requests.flatMap((r) => {
+                    const batch = mergedBatch(r);
+                    if (!batch?.length)
+                        return [r];
+                    const wait = budgetWaitOf(r);
+                    const waitMarked = wait !== undefined && !batch.some((m) => budgetWaitOf(m) !== undefined);
+                    if (waitMarked && !batch.some((m) => this.sameInferenceRequest(m, r))) {
+                        const { [MERGED_BATCH]: _batch, ...folded } = r;
+                        return [...batch, folded];
+                    }
+                    const own = r.wakeChannels?.filter((c) => !batch.some((m) => m.wakeChannels?.some((x) => sameChannel(x, c))));
+                    const channels = own?.length ? wakeChannelsOf([batch[0], { wakeChannels: own }]) : undefined;
+                    const members = channels ? [{ ...batch[0], wakeChannels: channels }, ...batch.slice(1)] : batch;
+                    if (!waitMarked)
+                        return members;
+                    const at = members.findIndex((m) => this.sameInferenceRequest(m, r));
+                    return members.map((m, i) => (i === at ? { ...m, [BUDGET_WAIT]: wait } : m));
+                });
             }
             // A provider's stated wait on this agent's primary model, including one
             // recorded before a restart, holds the turn until it passes. An
@@ -19815,7 +20423,7 @@ export class AgentFramework {
                     // A heartbeat's wake keeps its own key, so a later channel-less wake
                     // can't absorb it: resumed together, they make a heartbeat's batch
                     // (heartbeatTurn), as they would have without the quiesce.
-                    const key = `${request.reason}|${request.addressed ? 'a' : 'n'}|${isHeartbeatWake(request) ? 'h' : ''}|${request.coalescingSubject ?? ''}|${request.readsRow ?? ''}`;
+                    const key = `${request.reason}|${request.addressed ? 'a' : 'n'}|${isHeartbeatWake(request) ? 'h' : ''}|${isUnprompted(request) ? 'u' : ''}|${request.coalescingSubject ?? ''}|${request.readsRow ?? ''}|${budgetWaitOf(request) ? 'waited' : ''}`;
                     const prev = newestByKey.get(key);
                     const kept = !prev || request.timestamp >= prev.timestamp ? request : prev;
                     // The wake it absorbs hands on its lines (WakeLine): each event's
@@ -19823,16 +20431,20 @@ export class AgentFramework {
                     const lines = prev ? mergeWakeLines([prev, request]) : undefined;
                     if (lines)
                         kept.wakeLines = lines;
+                    const pair = prev ? [prev, request] : undefined;
+                    const channels = pair ? wakeChannelsOf(pair) : undefined;
+                    if (channels)
+                        kept.wakeChannels = channels;
                     newestByKey.set(key, kept);
                 }
-                this.pendingRequests.push(...newestByKey.values());
+                appendAll(this.pendingRequests, [...newestByKey.values()]);
                 if (passThrough.length === 0)
                     continue;
                 // The continuation continues its held turn; its parked siblings must
                 // NOT be consumed by that turn — they were re-parked above, so narrow
                 // the batch to the continuation(s) alone before the trigger selection.
                 requests.length = 0;
-                requests.push(...passThrough);
+                appendAll(requests, passThrough);
             }
             // A batch that carries a continuation which resumes its logical turn
             // (resumesLogicalTurn: a budget restart, a tool-result guard's retry)
@@ -19849,10 +20461,10 @@ export class AgentFramework {
             if (requests.some((r) => resumesLogicalTurn(r.reason))) {
                 const siblings = requests.filter((r) => !isTurnContinuation(r.reason));
                 if (siblings.length > 0) {
-                    this.pendingRequests.push(...siblings);
+                    appendAll(this.pendingRequests, siblings);
                     const continuations = requests.filter((r) => isTurnContinuation(r.reason));
                     requests.length = 0;
-                    requests.push(...continuations);
+                    appendAll(requests, continuations);
                 }
             }
             // Turn-alive includes a continuation of the agent's turn still on its
@@ -19874,7 +20486,7 @@ export class AgentFramework {
                 // Re-queue requests, but warn if they've been pending too long.
                 // Suppressed while quiesced: a drain-phase busy requeue is expected,
                 // not a wedge tell.
-                const oldest = Math.min(...requests.map(r => r.timestamp));
+                const oldest = requests.reduce((min, r) => Math.min(min, r.timestamp), Infinity);
                 if (!this.quiesced &&
                     now - oldest > STALE_REQUEST_MS &&
                     (this.staleWarnAt.get(agentName) ?? 0) < now - 60_000) {
@@ -19902,7 +20514,7 @@ export class AgentFramework {
                     console.error(`[inference-stale] agent=${agentName} busy (${shownStatus}) — ` +
                         `${requests.length} request(s) waiting ${Math.round((now - oldest) / 1000)}s`);
                 }
-                this.pendingRequests.push(...requests);
+                appendAll(this.pendingRequests, requests);
                 continue;
             }
             // A wake whose sole cause was a stored row (readsRow): one not
@@ -19930,7 +20542,7 @@ export class AgentFramework {
             if (read.length > 0) {
                 const left = requests.filter((r) => !read.includes(r));
                 requests.length = 0;
-                requests.push(...left);
+                appendAll(requests, left);
                 console.error(`[wake] ${agentName}: dropped ${read.length} wake(s) for writes an answered request carried, and that it spoke after in the wake's channel where it carries one not marked ambient, or that were removed` +
                     (requests.length === 0 ? '; no turn starts' : ''));
                 if (requests.length === 0) {
@@ -20104,6 +20716,7 @@ export class AgentFramework {
                 // channel is that message's, never one server's id with another's.
                 channelId: channelReq?.channelId,
                 channelServerId: channelReq?.channelServerId,
+                wakeChannels: wakeChannelsOf(requests.some(bringsOwnChannels) ? requests.filter(hasOwnCauseForRun) : requests),
                 // Only the mark this batch decided, never one requests[0] carried.
                 autoContinueRun: continuationMark,
                 addressed: addressedReq !== undefined,
@@ -20128,10 +20741,19 @@ export class AgentFramework {
                 start[TURN_CARRY] = carry;
             else
                 delete start[TURN_CARRY];
+            const wait = requests.map(budgetWaitOf).find((w) => w !== undefined);
+            if (wait)
+                start[BUDGET_WAIT] = wait;
+            else
+                delete start[BUDGET_WAIT];
             if (requests.every(isRearmed))
                 start[REARMED] = true;
             else
                 delete start[REARMED];
+            if (requests.every(isUnprompted))
+                start[UNPROMPTED] = true;
+            else
+                delete start[UNPROMPTED];
             // A start merged from more than one request, any of them not the
             // turn's, records the batch it was merged from (MERGED_BATCH): until
             // it takes its token it stands for them all.
@@ -20160,7 +20782,7 @@ export class AgentFramework {
      */
     publishInputWithTurnLocus(input, agentName, callingTurn) {
         const given = input?.channelId;
-        if (typeof given === 'string')
+        if (given !== undefined && given !== null)
             return input;
         // A locked turn's default is its lock, or none: never what the registry
         // resolves now, which reads the agent's latest routing (a silent start's).
@@ -20442,7 +21064,7 @@ export class AgentFramework {
         }
         if (held.length === 0)
             return held;
-        logical.drafts.push(...held);
+        appendAll(logical.drafts, held);
         console.error(`[drafts] ${agent.name}: held ${held.length} segment(s) as ${held.map((d) => d.id).join(', ')} (${reason})`);
         this.emitTrace({
             type: 'prose:drafts-held',
@@ -21143,7 +21765,12 @@ export class AgentFramework {
             this.holdHeartbeatProse(agent, [text], round);
             return null;
         }
-        return this.channelRegistry.routeSpeech(agent.name, text, locus);
+        return this.channelRegistry.routeSpeech(agent.name, text, locus, this.cameFrom(round.routing, locus));
+    }
+    cameFrom(routing, locus) {
+        return locus === null && !routing.noChannel && routing.wakeChannels
+            ? { cameFrom: routing.wakeChannels.map((c) => ({ channel: c, shown: this.channelShown(c) })) }
+            : undefined;
     }
     /**
      * Hold a locked turn's plain speech as drafts ('no-destination'): the agent
@@ -21165,6 +21792,17 @@ export class AgentFramework {
         // A locked turn's locus is its lock, not a channel the heartbeat answered.
         return routing.heartbeat && (!routing.locus || routing.locked) ? { heartbeatTurn: true } : {};
     }
+    unpromptedTurnMark(routing) {
+        return routing.unprompted && !routing.locus ? { [UNPROMPTED]: true } : {};
+    }
+    wakeChannelsMark(routing) {
+        return routing && !routing.noChannel && routing.wakeChannels ? { wakeChannels: routing.wakeChannels } : {};
+    }
+    turnRetryOf(trigger, routing) {
+        const retry = asTurnRetry(trigger);
+        delete retry.wakeChannels;
+        return Object.assign(retry, this.wakeChannelsMark(routing));
+    }
     /** Hold a heartbeat turn's plain speech as drafts ('no-destination'), named by `round`'s notice. */
     holdHeartbeatProse(agent, texts, round) {
         console.error(`[prose] ${agent.name}: heartbeat turn — ${texts.length} plain-speech segment(s) held as drafts (no destination)`);
@@ -21805,7 +22443,7 @@ export class AgentFramework {
      * and no undo or redo is made.
      */
     logicalTurnAlive(agent) {
-        return this.hasTurn(agent.name) || this.turnAlive(agent);
+        return this.hasTurn(agent.name) || this.turnAlive(agent) || this.heldContinuation(agent.name);
     }
     /** Whether `agent` has a turn alive: starting, streaming or waiting on its tools. */
     turnAlive(agent) {
@@ -22548,7 +23186,7 @@ export class AgentFramework {
     }
     agentSees(agent, metadata) {
         const sees = this.storeSees.get(agent.getContextManager());
-        return !sees || sees(metadata);
+        return !isReasoningLoss(metadata) && (!sees || sees(metadata));
     }
     /**
      * Record `view`, the filter `contextManager` was opened with
@@ -23169,6 +23807,8 @@ export class AgentFramework {
             source: 'framework',
             timestamp: Date.now(),
             ...this.heartbeatTurnMark(routing),
+            ...this.unpromptedTurnMark(routing),
+            ...this.wakeChannelsMark(routing),
         });
     }
     /**
@@ -23260,6 +23900,8 @@ export class AgentFramework {
             ...channel,
             autoContinueRun: { stop, ...(opts.heldAfterSend ? { heldAfterSend: true } : {}) },
             ...this.heartbeatTurnMark(routing),
+            ...this.unpromptedTurnMark(routing),
+            ...this.wakeChannelsMark(routing),
         });
     }
     /** How an autoContinue agent stops a run, as its `[continue]` row says it,
@@ -23686,7 +24328,7 @@ export class AgentFramework {
         }
         const target = sticky ?? locus;
         try {
-            const outcome = await this.channelRegistry.routeSpeech(agent.name, envelope, target);
+            const outcome = await this.channelRegistry.routeSpeech(agent.name, envelope, target, this.cameFrom(routing, target));
             this.recordProseDelivery(routing, outcome);
             if (outcome?.delivered) {
                 routing.liveSpeech = true;
@@ -24041,6 +24683,8 @@ export class AgentFramework {
                 source: 'framework',
                 timestamp: Date.now(),
                 ...this.heartbeatTurnMark(round.routing),
+                ...this.unpromptedTurnMark(round.routing),
+                ...this.wakeChannelsMark(round.routing),
             });
         }
     }
@@ -24174,7 +24818,7 @@ export class AgentFramework {
                     const batch = trigger && mergedBatch(trigger);
                     if (this.quiesced && batch) {
                         this.releasePrimaryProviderGate(agent.name);
-                        this.pendingRequests.push(...batch);
+                        appendAll(this.pendingRequests, batch);
                         console.error(`[provider-admission] ${agent.name}: host quiesced while parked — the merged start goes back as its ${batch.length} requests`);
                         return;
                     }
@@ -24273,8 +24917,9 @@ export class AgentFramework {
             // one's routing, and an ephemeral run fails with the error rather than
             // waiting out its watchdog. A silent start has no part in an open turn.
             if (!trigger?.suppressProse) {
+                const err = error instanceof Error ? error : new Error(String(error));
                 this.settleAgent(agent.name, {
-                    stopReason: 'exhausted', speech: '', error: error instanceof Error ? error.message : String(error),
+                    stopReason: 'exhausted', speech: '', error: failureWords(err), cause: err,
                 }, this.openLogical.get(agent.name));
             }
             this.endStatedWaitRun(agent.name);
@@ -24301,7 +24946,7 @@ export class AgentFramework {
                 this.activeTurnTokens.delete(agent.name);
                 this.activeTurnTriggers.delete(agent.name);
             }
-            if (!tokenHandedOff && ownsProviderGate)
+            if (!tokenHandedOff && ownsProviderGate && !checkWindow.gateReleased)
                 this.releasePrimaryProviderGate(agent.name);
             // A start that ends before its stream exists is its turn's end: what
             // arrived during it enters its window, as at a stream's teardown,
@@ -24336,7 +24981,7 @@ export class AgentFramework {
                 else {
                     dropped = true;
                     if (putsBack)
-                        back.push(...mergedWakes(r));
+                        appendAll(back, mergedWakes(r));
                 }
             }
             return left;
@@ -24356,7 +25001,7 @@ export class AgentFramework {
             this.releasePrimaryProviderGate(agentName);
             dropped = true;
             if (putsBack)
-                back.push(...mergedWakes(parked));
+                appendAll(back, mergedWakes(parked));
         }
         for (const pass of this.passRequests) {
             const requests = pass.get(agentName);
@@ -24364,9 +25009,9 @@ export class AgentFramework {
                 continue;
             const left = take(requests);
             requests.length = 0;
-            requests.push(...left);
+            appendAll(requests, left);
         }
-        this.pendingRequests.push(...back);
+        appendAll(this.pendingRequests, back);
         if (!dropped || !drop)
             return;
         // A primary a provider hold left pending for what it released won't run
@@ -24388,17 +25033,18 @@ export class AgentFramework {
      * ends on its own and settles nothing. What was stored for the agent
      * meanwhile is presented now (presentAtEndOf), or at that frame's end.
      */
-    endContinuedTurn(agentName, drop) {
-        console.error(`[turn-continuation] ${agentName}: its turn ends without its continuation: ${drop.why}`);
+    endContinuedTurn(agentName, drop, opensTurn = false) {
+        const ends = opensTurn ? 'its waiting start ends' : 'its turn ends without its continuation';
+        console.error(`[turn-continuation] ${agentName}: ${ends}: ${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);
+            this.endStoppedStart(agent, drop.kind === 'caller' ? { kind: 'caller', reason: drop.reason } : { kind: drop.kind }, routing, startedAt, undefined, opensTurn);
         }
         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.abortDroppedTurn(agentName, owner ?? -1, drop.kind === 'dropped' ? (drop.reason ?? CONTINUATION_DROPPED) : drop.kind === 'caller' ? (drop.reason ?? 'user') : drop.kind, startedAt);
             this.channelRegistry?.stopTyping();
             if (agent) {
                 agent.toolResultGuard.recovering = false;
@@ -24418,7 +25064,7 @@ export class AgentFramework {
             // A registered ephemeral run's caller waits on the run's settle, which
             // no frame gives once its continuation is gone: the turn's end is the
             // run's, with the drop's reason.
-            this.settleAgent(agentName, { stopReason: 'exhausted', speech: '', error: `${agentName}'s turn ended without its continuation: ${drop.why}` }, undefined);
+            this.settleAgent(agentName, { stopReason: 'exhausted', speech: '', error: `${agentName}'s ${opensTurn ? 'waiting start ended' : 'turn ended without its continuation'}: ${drop.why}` }, undefined);
         }
         // The turn's end; a frame that still holds its token presents at its
         // own end instead.
@@ -24639,6 +25285,8 @@ export class AgentFramework {
     /** This start's window (checkAhead), which its checks read for an
      *  operator's abandon. */
     checkWindow) {
+        if (attempt === 0 && this.budgetWaitEnded(agent, trigger))
+            return false;
         const resumesTurn = resumesLogicalTurn(trigger?.reason);
         let carry = turnCarryOf(trigger);
         const turnProseRouting = trigger?.suppressProse ? 'disabled' : this.proseRoutingOf(agent);
@@ -24801,8 +25449,10 @@ export class AgentFramework {
             trigger = own;
         }
         // Record turn checkpoint before inference (only on first attempt, not retries)
+        let checkpoint;
+        let compileBaseline;
         if (attempt === 0 && trigger?.reason !== 'tool_result_guard_retry') {
-            this.recordTurnCheckpoint(agent.name);
+            checkpoint = this.recordTurnCheckpoint(agent.name);
             this.redoStacks.delete(agent.name); // new work invalidates redo
         }
         // This start's routing: its logical turn's (TurnRouting), which holds
@@ -24845,6 +25495,10 @@ export class AgentFramework {
                 routing.roundsRan = true;
             if (continued?.unflushedRounds)
                 routing.unflushedRounds = continued.unflushedRounds;
+            if (continued?.start)
+                routing.start = continued.start;
+            if (continued?.firstRow !== undefined)
+                routing.firstRow = continued.firstRow;
             opensTurn = true;
         }
         else {
@@ -24860,8 +25514,11 @@ export class AgentFramework {
         }
         if (opensTurn) {
             const head = agent.branchHead();
-            if (head)
+            if (head && !routing.start)
                 routing.start = head;
+            const firstRow = this.activeTurnTriggers.get(agent.name)?.readsRow;
+            if (firstRow !== undefined)
+                routing.firstRow = firstRow;
             // A silent start, and an agent whose configuration turns the pin off
             // (turnInputsPin: false), pin nothing, and a pin of the name left from
             // before goes.
@@ -24903,12 +25560,16 @@ export class AgentFramework {
         // a running turn without ending it, so the notice that writes the history
         // no longer holds are still on disk goes in before this start's compile.
         this.noticeHeadMoves(agent);
+        const wakeChannels = wakeChannelsOf([routing, trigger]);
+        if (wakeChannels)
+            routing.wakeChannels = wakeChannels;
         if (opensTurn) {
             // The turn's trigger channel (item-3 redux): the channel of a
             // channel/DM-triggered turn, with its server, and none for a
             // no-trigger turn, which doesn't inherit a previous turn's channel: a
             // heartbeat's takes no locus at all (TurnRouting.heartbeat), and any
-            // other falls back to the global default. A wake whose channel,
+            // other falls back to the global default, with the configured
+            // unprompted channel in it where the turn takes it. A wake whose channel,
             // given without its server, names no one registered channel (a host's
             // id that two servers' channels answer to, or that none does) has none
             // either, and takes no fallback: it was for a channel, and the latest
@@ -24931,9 +25592,14 @@ export class AgentFramework {
                 routing.heartbeat = true;
             else
                 delete routing.heartbeat;
+            if (isUnprompted(trigger))
+                routing.unprompted = true;
+            else
+                delete routing.unprompted;
             // Resolve the turn's outbound locus now: the home channel for forks,
             // else the trigger channel, else the global default, which an
-            // ephemeral run never takes (takesGlobalFallback). Ambient mid-turn
+            // ephemeral run never takes (takesGlobalFallback), with the configured
+            // unprompted channel in it where the turn takes it. Ambient mid-turn
             // injections must not redirect the agent's plain prose (ambient
             // chatter and reactions hijacked it before, 2026-07-21); only an
             // addressed message, a follow-up in a channel the turn engaged
@@ -25019,7 +25685,9 @@ export class AgentFramework {
                         ? 'at your budget restart'
                         : isTurnContinuation(trigger?.reason ?? '')
                             ? 'before this re-inference on your tool results'
-                            : 'while your turn waited on a provider hold';
+                            : budgetWaitOf(trigger)
+                                ? 'while your turn waited'
+                                : 'while your turn waited on a provider hold';
                 this.noticeAddressedArrivals(agent, routing, arrivals, when);
             }
         }
@@ -25165,13 +25833,16 @@ export class AgentFramework {
             if (carry && this.heardSince(agent, routing, carry.read))
                 carry = undefined;
             const streamCarry = { silence: carry?.silence ?? null, sends: carry?.sends ?? null, read: lastHeardAt };
-            const { stream, request: compiledRequest, takeKvSubmission, drainKvSubmissionIds, continuePrompt, placeDrops, thinkingRecordedAfter, thinkingBranch, noteRequestSent, carriedBodies, } = await agent.startStreamWithInjections(tools, injections, undefined, compressionTools, {
+            compileBaseline = { progress: this.compressionProgressOf(agent), settings: agent.contextSettingsChanges() };
+            const { stream, request: compiledRequest, takeKvSubmission, drainKvSubmissionIds, continuePrompt, placeDrops, thinkingRecordedAfter, thinkingBranch, noteRequestSent, noteThinkingDropped, carriedBodies, } = await agent.startStreamWithInjections(tools, injections, undefined, compressionTools, {
                 silentHeartbeat: trigger?.silentHeartbeat,
                 // This turn's retries are the framework's (errorPolicy below), not
                 // membrane's inside each attempt.
                 membraneRetries: false,
                 inferenceBounds: this.inferenceBounds,
             });
+            if (trigger)
+                delete trigger[BUDGET_WAIT];
             // Each later round this stream sends is noted as it goes (noteRoundSent).
             if (noteRequestSent)
                 this.streamRequestNotes.set(stream, { note: noteRequestSent, rounds: [], stopped: false });
@@ -25226,7 +25897,7 @@ export class AgentFramework {
             if (this.registry.homeChannel(agent.name) !== undefined) {
                 const wait = this.providerWaits?.active(agent.name, agent.model);
                 // The turn has begun (inference:started), so the hold keeps its retry.
-                if (wait && this.holdForProviderWait(agent, wait, trigger ? [asTurnRetry(withTurnCarry(trigger, carry))] : [], false, () => {
+                if (wait && this.holdForProviderWait(agent, wait, trigger ? [this.turnRetryOf(withTurnCarry(trigger, carry), routing)] : [], 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
@@ -25279,6 +25950,7 @@ export class AgentFramework {
                     place: placeDrops,
                     ...(thinkingRecordedAfter !== undefined ? { recordedAfter: thinkingRecordedAfter } : {}),
                     ...(thinkingBranch !== undefined ? { branch: thinkingBranch } : {}),
+                    ...(noteThinkingDropped ? { noteDropped: noteThinkingDropped } : {}),
                 }
                 : undefined, streamCarry);
             this.activeStreams.set(agent.name, handle);
@@ -25326,6 +25998,19 @@ export class AgentFramework {
             }
             const retry = trigger && withTurnCarry(trigger, carry);
             const asTransient = this.takeAsTransient(agent.name, err, trigger);
+            if (this.holdForBudgetRefusal(agent, err, retry, checkpoint, routing, compileBaseline, () => {
+                if (this.checkAhead.get(agent) === checkWindow)
+                    this.checkAhead.delete(agent);
+                if (this.activeTurnTokens.get(agent.name) === turnToken) {
+                    this.activeTurnTokens.delete(agent.name);
+                    this.activeTurnTriggers.delete(agent.name);
+                }
+                if (ownsProviderGate && !checkWindow.gateReleased) {
+                    checkWindow.gateReleased = true;
+                    this.releasePrimaryProviderGate(agent.name);
+                }
+            }))
+                return false;
             if (ownsProviderGate && this.holdProviderAcceleration(agent, err, retry)) {
                 // Capacity scheduling is not poisoned history. The cooldown timer owns
                 // one later fresh compile; no immediate retry or exhaustion marker.
@@ -25388,7 +26073,7 @@ export class AgentFramework {
                 // drop), not a window nothing will collect.
                 if (this.checkAhead.get(agent) === checkWindow)
                     this.checkAhead.delete(agent);
-                await this.startAgentStream(agent, retry && asTurnRetry(retry), attempt + 1);
+                await this.startAgentStream(agent, retry && this.turnRetryOf(retry, routing), attempt + 1);
             }
             else {
                 this.noteFailedTurnEnd(agent, routing);
@@ -25406,7 +26091,8 @@ export class AgentFramework {
                 this.settleAgent(agent.name, {
                     stopReason: 'exhausted',
                     speech: '',
-                    ...(statedWait === 'fail' ? this.statedWaitNotSlept(err) : { error: err.message }),
+                    ...(statedWait === 'fail' ? this.statedWaitNotSlept(err) : { error: failureWords(err) }),
+                    cause: err,
                 }, routing);
                 if (isRearmed(trigger) && asTransient)
                     this.exhaustingRearms.add(agent.name);
@@ -25414,6 +26100,7 @@ export class AgentFramework {
                     type: 'inference:exhausted',
                     agentName: agent.name,
                     error: err.message,
+                    ...shownReasonOf(err),
                     // Drives the poison-history breaker (shedMayHelp: an
                     // `invalid_request` at HTTP 400, 413 or 422 or with no status, or a
                     // `context_length` at 413, suggests the provider refused the
@@ -26376,7 +27063,7 @@ export class AgentFramework {
                                 this.noteRefusal(agent.name, category, tokenUsage);
                                 countUsage(abandoned);
                                 logStream({
-                                    success: false, error: 'Tool output withheld by the guard',
+                                    success: false, error: 'Tool output withheld by the guard', errorWords: 'Tool output withheld by the guard',
                                     request: compiledRequest ?? {}, response, durationMs, tokenUsage, stopReason: 'refusal',
                                 });
                                 console.error(`[tool-result-guard] agent=${agent.name} withheld ${withheld.length} result(s); retrying inference`);
@@ -26436,10 +27123,12 @@ export class AgentFramework {
                                 // a postscript to a message already delivered.
                                 // Restart inference inside this logical turn. No tool is
                                 // executed again and no settle/checkpoint/locus reset occurs.
-                                await this.startAgentStream(agent, withTurnCarry({
+                                const retried = {
                                     ...trigger, agentName: agent.name, reason: 'tool_result_guard_retry',
                                     source: trigger?.source ?? 'framework', timestamp: Date.now(),
-                                }, { silence, sends: turnSends, read: carry.read }), attempt);
+                                };
+                                delete retried.wakeChannels;
+                                await this.startAgentStream(agent, withTurnCarry({ ...retried, ...this.wakeChannelsMark(streamRouting) }, { silence, sends: turnSends, read: carry.read }), attempt);
                                 return;
                             }
                             const lastResult = response.content.reduce((last, block, index) => block.type === 'tool_result' ? index : last, -1);
@@ -26821,6 +27510,7 @@ export class AgentFramework {
                                     reason: forced ? 'unstick-retry' : 'refusal-rewind-retry',
                                     source: 'framework',
                                     timestamp: Date.now(),
+                                    ...this.wakeChannelsMark(streamRouting),
                                 });
                                 handledByRewind = true;
                             };
@@ -27193,7 +27883,7 @@ export class AgentFramework {
                         });
                         logStream({
                             success: false,
-                            error: err.message,
+                            ...failedEntry('', err),
                             request: compiledRequest ?? { note: 'streaming request failed' },
                             durationMs,
                         });
@@ -27261,7 +27951,7 @@ export class AgentFramework {
                                     return;
                                 }
                                 // Marked as its turn's retry, as at the start's failure.
-                                await this.startAgentStream(agent, retry && asTurnRetry(retry), attempt + 1);
+                                await this.startAgentStream(agent, retry && this.turnRetryOf(retry, streamRouting), attempt + 1);
                             }
                             else {
                                 // The turn ends here, and its inference:failed doesn't say so,
@@ -27286,7 +27976,8 @@ export class AgentFramework {
                             this.settleAgent(agent.name, {
                                 stopReason: 'exhausted',
                                 speech: '',
-                                ...(statedWait === 'fail' ? this.statedWaitNotSlept(err) : { error: err.message }),
+                                ...(statedWait === 'fail' ? this.statedWaitNotSlept(err) : { error: failureWords(err) }),
+                                cause: err,
                             }, this.agents.get(agent.name) === agent && agent.streamId === myStreamId ? streamRouting : undefined, streamRouting);
                             if (isRearmed(trigger) && asTransient)
                                 this.exhaustingRearms.add(agent.name);
@@ -27294,6 +27985,7 @@ export class AgentFramework {
                                 type: 'inference:exhausted',
                                 agentName: agent.name,
                                 error: err.message,
+                                ...shownReasonOf(err),
                                 // Drives the poison-history breaker. `retryable` is kept for
                                 // observability, but the breaker gates on
                                 // shedMayHelp(errorType, httpStatus): only an `invalid_request`
@@ -27382,6 +28074,7 @@ export class AgentFramework {
                                     type: 'inference:exhausted',
                                     agentName: agent.name,
                                     error: terminal,
+                                    shownReason: terminal,
                                 });
                                 this.rearmExhaustedTurn(agent, new Error(terminal), trigger, ownsProviderGate, streamRouting, false);
                                 // Postmortem 2026-05-28 P2 #7: persist the abort to the
@@ -27391,6 +28084,7 @@ export class AgentFramework {
                                 logStream({
                                     success: false,
                                     error: terminal,
+                                    errorWords: terminal,
                                     request: compiledRequest ?? { note: 'streaming request aborted' },
                                     durationMs,
                                 });
@@ -27475,10 +28169,13 @@ export class AgentFramework {
                         // carries what the stream appended, so once a call has dropped
                         // blocks, none of the stream's later calls is given either. A
                         // compile whose first call dropped blocks gives no sample, and the
-                        // calibration keeps its value. If the provider drops an earlier
-                        // model's blocks after a model switch (`model_binding_mismatch`),
-                        // they drop on every call until they leave the context, and the
-                        // calibration takes up the new model's tokenizer only after that.
+                        // calibration keeps its value. Without `binds`, if the provider
+                        // drops an earlier model's blocks after a model switch
+                        // (`model_binding_mismatch`), they drop on every call until they
+                        // leave the context, and the calibration takes up the new model's
+                        // tokenizer only after that. With `binds`, the switch changes the
+                        // request's identity, so the compile leaves the replies' thinking
+                        // out itself, and a drop that does come is noted below.
                         const thinkingReport = event.round?.thinking;
                         const thinkingDropped = (thinkingReport?.dropped.length ?? 0) > 0;
                         if (thinkingDropped)
@@ -27486,6 +28183,18 @@ export class AgentFramework {
                         // Against the branch's binding record, when the context manager keeps one: a drop it can't account
                         // for tells the operators (noteThinkingLoss), and a call with no report shows no such drop.
                         const placedDrops = thinkingDrops && thinkingReport ? thinkingDrops.place(thinkingReport.dropped) : [];
+                        // The stored replies' bodies among them, as placed, go to the record, so the next compile sends them
+                        // without their thinking and the provider drops none of them again.
+                        const droppedBodies = placedDrops.flatMap((drop) => drop.kind === 'reply' ? drop.bodies.map((body) => body.messageId) : []);
+                        if (droppedBodies.length > 0 && thinkingDrops?.noteDropped) {
+                            try {
+                                thinkingDrops.noteDropped(droppedBodies);
+                            }
+                            catch (error) {
+                                console.error(`[thinking-binding] ${agent.name}: couldn't note the stored replies whose thinking the provider dropped, ` +
+                                    'so the next compile still sends them with it:', error);
+                            }
+                        }
                         if (thinkingDrops?.recordedAfter !== undefined) {
                             this.noteThinkingLoss(agent.name, placedDrops, thinkingDrops.recordedAfter);
                         }
@@ -27628,7 +28337,7 @@ export class AgentFramework {
                 // ends here (endFailureAtStop).
                 this.endFailureAtStop(agent.name, myTurnToken ?? -1, startTime, streamRouting);
                 logStream({ success: false,
-                    error: `Provider acceleration cooldown: ${err.message}`,
+                    ...failedEntry('Provider acceleration cooldown: ', err),
                     request: compiledRequest ?? { note: 'streaming request rate-limited' }, durationMs });
                 this.abandonAgentScripts(agent.name, 'provider acceleration cooldown', streamRouting);
                 lifecyclePhase = 'failed';
@@ -27645,7 +28354,7 @@ export class AgentFramework {
             if (statedWait === 'held') {
                 this.endFailureAtStop(agent.name, myTurnToken ?? -1, startTime, streamRouting);
                 logStream({ success: false,
-                    error: `Provider wait: ${err.message}`,
+                    ...failedEntry('Provider wait: ', err),
                     request: compiledRequest ?? { note: 'streaming request rate-limited' }, durationMs });
                 this.abandonAgentScripts(agent.name, 'provider wait', streamRouting);
                 lifecyclePhase = 'failed';
@@ -27658,7 +28367,8 @@ export class AgentFramework {
             this.settleAgent(agent.name, {
                 stopReason: 'exhausted',
                 speech: '',
-                ...(statedWait === 'fail' ? this.statedWaitNotSlept(err) : { error: err.message }),
+                ...(statedWait === 'fail' ? this.statedWaitNotSlept(err) : { error: failureWords(err) }),
+                cause: err,
             }, streamRouting);
             if (isRearmed(trigger) && asTransient)
                 this.exhaustingRearms.add(agent.name);
@@ -27666,6 +28376,7 @@ export class AgentFramework {
                 type: 'inference:exhausted',
                 agentName: agent.name,
                 error: err.message,
+                ...shownReasonOf(err),
                 ...this.classifyInferenceError(err),
             });
             this.rearmExhaustedTurn(agent, err, trigger, ownsProviderGate, streamRouting, asTransient);
@@ -27674,7 +28385,7 @@ export class AgentFramework {
             // Persist to inference log for forensic attribution.
             logStream({
                 success: false,
-                error: `Stream threw: ${err.message}`,
+                ...failedEntry('Stream threw: ', err),
                 request: compiledRequest ?? { note: 'streaming request threw' },
                 durationMs,
             });
@@ -27700,13 +28411,15 @@ export class AgentFramework {
                 if (countedUsage && !usageLogged) {
                     const replaced = this.agents.get(agent.name) !== agent;
                     const superseded = generationLost || agent.streamId !== myStreamId;
+                    const ended = replaced
+                        ? 'Stream abandoned: its agent was disposed or replaced'
+                        : superseded
+                            ? 'Stream superseded: a newer stream of the agent took over'
+                            : 'Stream ended without a final response';
                     logStream({
                         success: false,
-                        error: replaced
-                            ? 'Stream abandoned: its agent was disposed or replaced'
-                            : superseded
-                                ? 'Stream superseded: a newer stream of the agent took over'
-                                : 'Stream ended without a final response',
+                        error: ended,
+                        errorWords: ended,
                         request: compiledRequest ?? { note: 'streaming request' },
                         durationMs: Date.now() - startTime,
                         tokenUsage: tokenUsageOf(countedUsage),
@@ -27857,7 +28570,7 @@ export class AgentFramework {
             // 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.pendingContinuationAgents().has(agent.name) && !this.closureWaits(agent.name)) {
                 this.disposeConversationAgent(agent.name, 'idle-ttl');
             }
         }
@@ -27950,7 +28663,7 @@ 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.hasTurn(agentName)) {
+        if (agent.state.status !== 'idle' || this.hasTurn(agentName) || this.heldContinuation(agentName)) {
             const shown = agent.state.status === 'idle' ? 'idle+turn-alive' : agent.state.status;
             // 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.
@@ -27958,8 +28671,11 @@ export class AgentFramework {
             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)`);
+                : agent.state.status === 'idle' && !this.hasTurn(agentName)
+                    ? `puppet refused: agent ${agentName} is idle+turn-alive (its turn waits for compression to make room; ` +
+                        'requires idle); abortInference() ends that turn'
+                    : `puppet refused: agent ${agentName} is ${shown} (requires idle — ` +
+                        `injecting a turn under an active stream corrupts wire ordering)`);
         }
         const onSurface = this.availableToolsForPresentation(agentName).some((t) => t.name === toolName);
         if (!onSurface) {
@@ -29742,6 +30458,8 @@ export class AgentFramework {
         // produced it is already stored separately as a blob.
         if (typeof entryToStore.error === 'string')
             entryToStore.error = boundFailureText(entryToStore.error);
+        if (typeof entryToStore.errorWords === 'string')
+            entryToStore.errorWords = boundFailureText(entryToStore.errorWords);
         // Blob threshold: 10KB - typical context-heavy requests exceed this
         const BLOB_THRESHOLD = 10000;
         // Both branches persist the JSON view, never the live object: a compiled
@@ -29959,20 +30677,22 @@ export class AgentFramework {
     }
     /**
      * Why this host refuses a skip_reply call, as the model will read it, or
-     * undefined when it doesn't (skipReplyWakeRefusal): without an EventGate,
-     * any wake_in_seconds; with one, a wake_in_seconds that isn't a number of
-     * seconds. Only when the channel registry handles skip_reply. The dispatch
-     * that refuses the call reads it here, and so does the turn's bookkeeping of
-     * a refused round (roundCallOf), for the model's calls and a script's calls
-     * that reach the host while a call of the round watches it: the silence
-     * before it, which comes back after its round, and in XML mode which round's
-     * prose stays private. A skip_reply round's own prose stays private by the
-     * tool's name, refused or not.
+     * undefined when it doesn't: a reason that isn't a string
+     * (ChannelRegistry.nonStringRefusal), or (skipReplyWakeRefusal) without an
+     * EventGate, any wake_in_seconds, and with one, a wake_in_seconds that isn't
+     * a number of seconds. Only when the channel registry handles skip_reply.
+     * The dispatch that refuses the call reads it here, and so does the turn's
+     * bookkeeping of a refused round (roundCallOf), for the model's calls and a
+     * script's calls that reach the host while a call of the round watches it:
+     * the silence before it, which comes back after its round, and in XML mode
+     * which round's prose stays private. A skip_reply round's own prose stays
+     * private by the tool's name, refused or not.
      */
     skipReplyRefusal(call) {
         if (call.name !== 'skip_reply' || !this.channelRegistry)
             return undefined;
-        return skipReplyWakeRefusal(readSkipReplyWake(call.input), !!this.eventGate);
+        return this.channelRegistry.nonStringRefusal('skip_reply', call.input)?.error
+            ?? skipReplyWakeRefusal(readSkipReplyWake(call.input), !!this.eventGate);
     }
     refusesSelfWake(call) {
         return this.skipReplyRefusal(call) !== undefined;
@@ -29981,8 +30701,8 @@ export class AgentFramework {
      * A call as its round's routing counts it, made directly, or by a script
      * and reaching the host while a run or wait call of the round watches it
      * (ScriptRound). A skip_reply refused, because the agent's allowedTools
-     * doesn't name it, because its arguments are refused (markedInputRefusal)
-     * or because this host can't set the wake it asks for, is
+     * doesn't name it, because its arguments are refused (markedInputRefusal),
+     * or because this host refuses its arguments (skipReplyRefusal), is
      * marked refused: it keeps its own round private and silences nothing after
      * it. A refusal withholds the call's effect, not the model's choice to keep
      * its words private. Any other call the list refuses posted nothing, so it
@@ -30239,7 +30959,7 @@ export class AgentFramework {
                     const error = this.skipReplyRefusal(enrichedCall);
                     if (error !== undefined) {
                         const wakeValue = enrichedCall.input?.wake_in_seconds;
-                        console.error(`[self-wake] agent=${agentName} wake_in_seconds=${logValue(wakeValue)} skip_reply refused: ${logDetail(this.eventGate ? "wake_in_seconds isn't a number of seconds" : 'No EventGate configured (FrameworkConfig.gate is unset)')}`);
+                        console.error(`[self-wake] agent=${agentName} wake_in_seconds=${logValue(wakeValue)} skip_reply refused: ${logDetail(error)}`);
                         const result = this.refusedResult(agentName, enrichedCall.id, error);
                         this.emitTrace({ type: 'tool:failed', module: 'channels', tool: enrichedCall.name, callId: enrichedCall.id, error });
                         this.pushEvent({ type: 'tool-result', callId: enrichedCall.id, toolName: enrichedCall.name, agentName, moduleName: 'channels', result });
@@ -31803,6 +32523,7 @@ export class AgentFramework {
             this.noteInferenceExhausted(event.agentName ?? 'unknown', event.error ?? 'unknown error', event.retryable, event.errorType, {
                 httpStatus: event.httpStatus,
                 providerErrorCode: event.providerErrorCode,
+                shownReason: event.shownReason,
             });
         }
         else if (event.type === 'inference:completed') {
@@ -31868,6 +32589,8 @@ export class AgentFramework {
             bounded.error = boundFailureText(bounded.error);
         if (typeof bounded.stack === 'string')
             bounded.stack = boundFailureText(bounded.stack);
+        if (typeof bounded.shownReason === 'string')
+            bounded.shownReason = boundFailureText(bounded.shownReason);
         if (this.earlyTraces) {
             if (this.earlyTraces.length < 1000)
                 this.earlyTraces.push(traceEvent);
@@ -31967,6 +32690,20 @@ export class AgentFramework {
                     };
                 })(),
                 lastInference: this.lastInferenceAt.get(name) ?? null,
+                budgetHold: (() => {
+                    const hold = this.budgetHolds?.get(name);
+                    if (!hold)
+                        return null;
+                    const readiness = this.contextReadiness(agent.getContextManager());
+                    return {
+                        since: hold.startedAt,
+                        pending: 'pending' in readiness && readiness.pending ? boundFailureText(readiness.pending) : null,
+                        heldRequests: 1 + hold.wakes.flatMap((r) => mergedBatch(r) ?? [r]).filter((r) => !passesQuiesce(r)).length,
+                        errorType: hold.errorType,
+                        ...(hold.budget !== undefined ? { budget: hold.budget } : {}),
+                        ...(hold.actual !== undefined ? { actual: hold.actual } : {}),
+                    };
+                })(),
                 refusalStats: this.refusalStats.get(name) ?? null,
                 ...this.upcomingWakesHealth(name),
             })),
@@ -31990,7 +32727,8 @@ export class AgentFramework {
     }
     /**
      * Ops alert — the one escalation path for "a human should hear about this":
-     * (1) durable failures.log record (unless the caller already wrote one),
+     * (1) durable failures.log record (unless the caller already wrote one, or
+     *     the alert keeps none, as a budget hold's open and clear don't),
      * (2) an `ops:alert` trace so authorized observers get it on the wire,
      * (3) if CONNECTOME_OPS_WEBHOOK is set, a Discord post throttled to one per
      *     (agent, kind) per cooldown window — a persistent failure re-posts
@@ -32024,7 +32762,7 @@ export class AgentFramework {
             notes.stopped = true;
             return;
         }
-        notes.rounds.push(...rows);
+        appendAll(notes.rounds, rows);
         this.noteStreamRows(agent, notes);
     }
     /**
@@ -32233,17 +32971,8 @@ export class AgentFramework {
                 ...(providerErrorCode !== undefined ? { providerErrorCode } : {}),
             };
         }
-        if (err instanceof OverBudgetError || err.name === 'OverBudgetError') {
-            return { errorType: 'over_budget' };
-        }
-        // context-manager's fatal coverage invariant (fix/coverage-invariant-fatal,
-        // 2026-07-26): a compile REFUSES rather than shipping a context with
-        // silently-dropped messages. Recovery is identical to over_budget — kick
-        // the compression drain so summaries cover the un-represented span.
-        if (err instanceof UncoveredDropError || err.name === 'UncoveredDropError') {
-            return { errorType: 'context_refusal' };
-        }
-        return {};
+        const refusal = compileRefusalType(err);
+        return refusal !== undefined ? { errorType: refusal } : {};
     }
     /**
      * Public entry to the ops-alert pipeline (failures.log + ops:alert trace +
@@ -32266,10 +32995,12 @@ export class AgentFramework {
         // sink below gets an excerpt cut from the whole reason at its own bound
         // (boundFailureText, so its marker states the whole length): the stderr
         // line, failures.log and the hard-down alert FAILURE_TEXT_MAX_CHARS, the
-        // [inference-failed] marker FAILURE_MARKER_REASON_MAX_CHARS, the status's
-        // lastError and the compile-refused alert FAILURE_SUMMARY_MAX_CHARS, and
-        // the rewind marker REWIND_MARKER_REASON_MAX_CHARS. The classification
-        // travels as structured fields beside the text.
+        // [inference-failed] marker's metadata FAILURE_MARKER_REASON_MAX_CHARS, the
+        // status's lastError and the compile-refused alert FAILURE_SUMMARY_MAX_CHARS,
+        // and the rewind marker's metadata REWIND_MARKER_REASON_MAX_CHARS. The
+        // classification travels as structured fields beside the text. The
+        // [inference-failed] marker's text quotes only `shownReason`, which holds
+        // no provider's text, and the rewind marker's quotes no reason.
         //
         // A reason that isn't a string (the stream paths always pass a message)
         // is described rather than allowed to throw before anything is recorded.
@@ -32311,9 +33042,12 @@ export class AgentFramework {
         const agent = this.agents.get(agentName);
         if (agent && !(rearmed && !ended) && process.env.SUPPRESS_INFERENCE_FAILED_MARKER !== '1') {
             const timedOut = errorType === 'timeout';
-            const causeParts = [errorType, httpStatus !== undefined ? `HTTP ${httpStatus}` : undefined]
+            const causeParts = errorType === 'safety' ? [] : [errorType, httpStatus !== undefined ? `HTTP ${httpStatus}` : undefined]
                 .filter((part) => part !== undefined);
             const cause = timedOut && causeParts.length === 1 ? '' : causeParts.join(', ');
+            const shownText = typeof detail?.shownReason === 'string'
+                ? failureShown(boundFailureText(detail.shownReason, FAILURE_MARKER_REASON_MAX_CHARS)) : undefined;
+            const shown = shownText !== undefined ? ` Reason: ${shownText}${/[.!?]$/.test(shownText) ? '' : '.'}` : '';
             try {
                 storeOwnRow(agent, 'user', [{
                         type: 'text',
@@ -32324,11 +33058,11 @@ export class AgentFramework {
                                 `${ended.roundsRan ? ' Its earlier rounds ran, and their tool calls ran as their results show.' : ''}` +
                                 `${ended.callsCutOff ? ` ${CALLS_CUT_OFF}` : ''}` +
                                 `${ended.liveSpeech ? ` ${LIVE_SPEECH_UNRECEIPTED}` : ''}` +
-                                `${ended.speechRouting ? ` ${SPEECH_STILL_ROUTING}` : ''} Reason: `
+                                `${ended.speechRouting ? ` ${SPEECH_STILL_ROUTING}` : ''}`
                             : `[${NOTICE_TAG.inferenceFailed}] Your previous turn did not complete: ` +
                                 `the model call ${timedOut ? 'timed out' : 'failed'}${cause ? ` (${suppliedValue(cause)})` : ''} ` +
-                                `and produced no response, so nothing was sent.${madeAgain ? ` ${MADE_AGAIN}` : ''} Reason: `) +
-                            `${failureShown(markerReason)}. ${timedOut ? TIMEOUT_ADVICE : FAILURE_ADVICE}`,
+                                `and produced no response, so nothing was sent.${madeAgain ? ` ${MADE_AGAIN}` : ''}`) +
+                            `${shown} ${timedOut ? TIMEOUT_ADVICE : FAILURE_ADVICE}`,
                     }], { system: true, kind: 'inference-failed', reason: markerReason, consecutive: streak, ...classification, ...cutAt(markerReason) });
             }
             catch (err) {
@@ -32369,49 +33103,7 @@ export class AgentFramework {
         // runUntilIdle() has no maintenance timer, so a drain is its recovery.
         const drainState = !overBudget ? undefined
             : !agent ? 'unavailable (no agent handle)'
-                : this.providerAdmissionClosed ? 'not kicked: the framework is stopping'
-                    : this.surgeryHold ? 'not kicked: a surgery holds the store'
-                        : this.overBudgetDrainInFlight.has(agentName) ? 'already draining'
-                            : 'kicking';
-        if (agent && drainState === 'kicking') {
-            this.overBudgetDrainInFlight.add(agentName);
-            // Like a maintenance pass: none starts once stop() has begun, it starts
-            // no tick while a surgery holds the store or once its agent has been
-            // disposed, and a surgery, a switchBranch or stop() waits for the tick
-            // in flight. It joins the drains they wait for before the alert is
-            // raised and before its body runs, so the alert's listeners find it:
-            // one that begins stop() or a surgery waits for it, and its body then
-            // ticks none and says why. So does a stop() made from inside its first
-            // tick, before that tick's first await.
-            const drain = Promise.resolve().then(async () => {
-                let ticks = 0;
-                try {
-                    const cm = agent.getContextManager();
-                    while (ticks < 8 && !this.providerAdmissionClosed && !this.surgeryHold && this.agents.get(agentName) === agent) {
-                        await cm.tick();
-                        ticks++;
-                    }
-                    const stopped = ticks >= 8 ? ''
-                        : this.agents.get(agentName) !== agent ? ', stopped as the agent was disposed'
-                            : this.providerAdmissionClosed ? ', stopped as the framework stops'
-                                : ', stopped while a surgery holds the store';
-                    console.error(`[inference-failed] drain kicked for ${agentName} (OverBudget breaker, ${ticks} ticks${stopped})`);
-                }
-                catch (err) {
-                    if (err instanceof MaintenanceWithdrawnError) {
-                        console.error(`[inference-failed] drain kicked for ${agentName} (OverBudget breaker, ${ticks} ticks, stopped: ${err.message})`);
-                    }
-                    else {
-                        console.error(`[inference-failed] drain kick failed for ${agentName} after ${ticks} ticks: ${describeFailureWithFrames(err)}`);
-                    }
-                }
-                finally {
-                    this.overBudgetDrainInFlight.delete(agentName);
-                }
-            });
-            this.overBudgetDrains.add(drain);
-            void drain.finally(() => { this.overBudgetDrains.delete(drain); });
-        }
+                : this.kickOverBudgetDrain(agentName, agent);
         if (overBudget) {
             this.opsAlert('context-refusal', agentName, `compile refused (${errorType ?? 'unclassified'}): ${boundFailureText(wholeReason, FAILURE_SUMMARY_MAX_CHARS)} — ` +
                 `drain breaker ${drainState}; ` +
@@ -32485,6 +33177,7 @@ export class AgentFramework {
             reason: 'inference-failure-rewind-retry',
             source: 'framework',
             timestamp: Date.now(),
+            ...this.wakeChannelsMark(this.turnRouting?.get(agent.name)),
         });
     }
     // ==========================================================================
@@ -32667,7 +33360,8 @@ export class AgentFramework {
             // a later start of the turn is told where its unprefixed speech lands
             // unless a hybrid `>>>` destination takes it. Empty for a no-trigger
             // turn until its locus is resolved, so that resolution takes the
-            // global fallback (none for an ephemeral run), and the turn then keeps
+            // global fallback, the configured unprompted channel among it (none
+            // for an ephemeral run), and the turn then keeps
             // that channel; null for a heartbeat's turn, which takes none
             // (TurnRouting.heartbeat).
             // A turn with no channel of its own (a heartbeat's, or a wake for a
@@ -32687,7 +33381,9 @@ export class AgentFramework {
             // message's channel is nobody's choice for it (#551). By name, so a
             // speech dispatch that comes after the run's release still counts.
             takesGlobalFallback: (conversationId) => this.usedEphemeralAgentNames.get(conversationId) !== 'run',
+            takesUnpromptedChannel: (conversationId) => this.openLogical.get(conversationId)?.unprompted === true,
             eventGatePresent: this.eventGate !== null,
+            unpromptedChannel: this.mcplUnpromptedChannel ?? undefined,
             // A channel tool reads the connect and restart marks a tool call's
             // "connecting" text reads (mcplConnectInFlight, mcplServerAbsentText).
             // This host is connecting to a server while a connect or restart of
@@ -32708,7 +33404,7 @@ export class AgentFramework {
             // or wasn't confirmed to. addMessage() alone does not request
             // inference, so this never wakes her (matching the
             // `discord-send-failed-skip` gate intent: context yes, wake no).
-            onRouteFailure: ({ conversationId, channelId, serverId, reason, textLen, outcome, detail }) => {
+            onRouteFailure: ({ conversationId, channelId, serverId, reason, textLen, outcome, detail, byDesign }) => {
                 try {
                     // The marker is `system: true`, so it is never conversational and
                     // never influences routing. The channel is named by its label when
@@ -32738,7 +33434,7 @@ export class AgentFramework {
                             // have been posted (in part or whole). Never claim it wasn't.
                             ? `[${NOTICE_TAG.discordSendFailed}] Delivery of your previous reply (${textLen} chars) to ${where} was not confirmed (${suppliedValue(reason)}). It may or may not have been posted, so sending it again could post it twice. It is saved in your archive.`
                             : `[${NOTICE_TAG.discordSendFailed}] Your previous reply (${textLen} chars) could not be delivered to ${where} (${suppliedValue(reason)}). Nothing was posted; it is saved in your archive.`)
-                        : `[${NOTICE_TAG.sendUndeliverable}] Your previous reply (${textLen} chars) had no channel to go to — ${suppliedValue(reason)}. This is a routing/configuration situation, not a channel failure. This route delivered it nowhere; if another surface showed it (a reply thread, the console), that copy stands. It is saved in your archive.`;
+                        : `[${NOTICE_TAG.sendUndeliverable}] Your previous reply (${textLen} chars) had no channel to go to — ${suppliedValue(reason)}. This is a ${byDesign ? 'routing' : 'routing/configuration'} situation, not a channel failure. This route delivered it nowhere; if another surface showed it (a reply thread, the console), that copy stands. It is saved in your archive.`;
                     // A registered speaker's notice is addressed to it (noticeTargetFor).
                     this.addMessage('user', [{ type: 'text', text: text + (detail !== undefined ? ` Connector detail: ${suppliedValue(detail)}` : '') }], metadata, { forAgent: conversationId });
                 }
@@ -35846,7 +36542,7 @@ export class AgentFramework {
                     .filter(([, owner]) => owner === serverId)
                     .map(([name]) => name);
                 const known = new Set(names);
-                tools.push(...(this.mcplTools ?? []).filter((tool) => known.has(tool.name)));
+                appendAll(tools, (this.mcplTools ?? []).filter((tool) => known.has(tool.name)));
                 for (const name of names) {
                     toolServers.set(name, serverId);
                     const featureSet = this.mcplToolFeatureSets?.get(name);
@@ -35859,7 +36555,7 @@ export class AgentFramework {
                 kept.set(serverId, names.length);
             }
             else if (listedServers.has(serverId)) {
-                tools.push(...staged.tools);
+                appendAll(tools, staged.tools);
                 for (const [name, featureSet] of staged.featureSets)
                     toolFeatureSets.set(name, featureSet);
                 for (const [name, classes] of staged.classes)
@@ -35876,7 +36572,7 @@ export class AgentFramework {
                 console.error(`[mcpl] server "${serverId}": tools/list failed (${error}); ${count > 0 ? `keeping its ${count} known tool(s)` : 'none of its tools are offered'}`);
             }
         }
-        tools.push(...(over.size > 0 ? modernTools.filter((tool) => toolServers.has(tool.name)) : modernTools));
+        appendAll(tools, over.size > 0 ? modernTools.filter((tool) => toolServers.has(tool.name)) : modernTools);
         this.mcplToolsRefreshPublished = generation;
         this.mcplTools = tools;
         this.mcplPublishedConnections = publishedConnections;
@@ -36810,6 +37506,11 @@ export class AgentFramework {
                 return;
             }
             if (call.name === 'channel_publish' || call.name === 'channel_close') {
+                const refusal = this.channelRegistry?.nonStringRefusal(call.name, call.input);
+                if (refusal) {
+                    reject(refusal.error);
+                    return;
+                }
                 const input = (call.input ?? {});
                 // An empty serverId is read as none given, as the channel tools and
                 // channelNamed read it.
@@ -37342,7 +38043,7 @@ export class AgentFramework {
                 .filter(([field]) => !(field.startsWith('behavior.') && typeof input.behavior === 'object')));
             const policy = this.eventGate.addPolicy(rawPolicy, {
                 ...(position ? { position } : {}),
-                onIgnoredFields: (notes) => { ignored.push(...notes); },
+                onIgnoredFields: (notes) => { appendAll(ignored, notes); },
                 fieldNames,
             });
             const after = this.eventGate.probeTable();
@@ -37667,8 +38368,9 @@ export class AgentFramework {
     /**
      * Whether `agent`'s view leaves suppressed rows out, asked of the view
      * itself (storeSees): every resident's, the subconscious's and a view
-     * derived from one does; an isolated agent's own store has no view filter,
-     * so a row stamped there would render.
+     * derived from one does. An isolated agent's own view excludes legacy
+     * reasoning-loss notices, not suppressed rows, so a suppressed row stamped
+     * there would render.
      */
     viewHidesSuppressed(agent) {
         if (!agent)
@@ -37732,6 +38434,7 @@ export class AgentFramework {
             tags: Array.isArray(e.gateMetadata.tags) ? e.gateMetadata.tags : undefined,
             ...(e.targetAgents !== undefined ? { recipients: e.targetAgents.filter((name) => this.agents.has(name)) } : {}),
             ...(asked ? { suppressionAsked: true } : {}),
+            ...(opts.folds ? { folds: true } : {}),
         });
         const decision = admit(env, {
             untargetedRecipients: () => this.registry.untargetedRecipients(),
@@ -38085,7 +38788,7 @@ export class AgentFramework {
             }
             else {
                 const locus = callingTurn.locus ?? null;
-                registry.routeSpeech(agentName, announcement(locus), locus).then(noted).catch((err) => {
+                registry.routeSpeech(agentName, announcement(locus), locus, this.cameFrom(callingTurn, locus)).then(noted).catch((err) => {
                     console.error('[sleep] announce failed:', err instanceof Error ? err.message : err);
                 });
             }