@animalabs/agent-framework 0.28.0 → 0.29.0

package/dist/src/framework.js

@@ -32,20 +32,23 @@ import { checkToolPattern, describeUnmatchedPattern } from './mcpl/tool-pattern-
 import { BUILTIN_TOOL_CLASSES, normalizeClassTable, parseDeclaredClasses, resolveToolClass } from './mcpl/tool-classes.js';
 import { PushHandler } from './mcpl/push-handler.js';
 import { readSkipReplyWake, skipReplyWakeRefusal } from './mcpl/skip-reply-wake.js';
-import { convertBlock } from './mcpl/convert-block.js';
+import { convertBlocks } from './mcpl/convert-block.js';
 import { PushCoalescer, CoalesceError, PUSH_COALESCING_SUPPORT, validateCoalesceMember, validateCoalescedContent, coalescingSubjectKey, } from './mcpl/push-coalescer.js';
 import { isSilentHeartbeatMarker, isVisiblyEmptyContent, NON_STRING_TEXT_PLACEHOLDER } from './mcpl/visible-content.js';
 import { isProseTargetToken, parseProsePrefix, parseHybridProsePrefix } from './mcpl/prose-grammar.js';
 import { detectKnownToolWrapperProse } from './tool-wrapper-prose-guard.js';
 import { InferenceRouter } from './mcpl/inference-router.js';
-import { ChannelRegistry, TUNE_OUT_REPLACED, connectorText, desiredStateInLog, destinationKey, journalToolDescription, NON_HOLDER_CHANNEL_DESCRIPTIONS, qualifiedChannelName, sameChannel } from './mcpl/channel-registry.js';
+import { ChannelRegistry, TUNE_OUT_REPLACED, connectorText, desiredStateInLog, destinationKey, journalToolDescription, NON_HOLDER_CHANNEL_DESCRIPTIONS, NO_CHANNEL_EXAMPLE, NO_PERSON_EXAMPLE, qualifiedChannelName, sameChannel } from './mcpl/channel-registry.js';
 import { KEEP_IDLE_MS, KEEP_NEWEST, ProseDraftStore, draftState, uncertainAttempt } from './prose-drafts.js';
 import { ConversationRouter, CONVERSATION_ROUTING_DEPRECATION_NOTICE } from './mcpl/conversation-router.js';
 import { INBOUND_SOURCE_KEY, sourceBodyDigest } from './mcpl/inbound-source.js';
+import { markNoticeOpenings, nameToTypeBack, quotedValue, showsAsItself, suppliedValue } from './supplied-text.js';
+import { NOTICE_TAG } from './notice-tags.js';
 import { safeSlice } from './safe-slice.js';
 import { SEND_TOOLS, bareToolName } from './send-tools.js';
 import { boundedErrorMessage, errorMessage } from './error-message.js';
 import { ProviderWaits, EVERY_MODEL, isReleaseModel, withoutControls } from './provider-waits.js';
+import { Refusal, errnoCode, errnoWayOn, systemWords } from './modules/workspace/answers.js';
 import { goesNative, nonErrorResultText, nonErrorResultTextOrThrow, isContentArray, resultClaimsOrThrow, scriptViewClaims, shownToScript, shownToScriptFromServer, toolResultDataToHistoryString, truncateForHistory, DEFAULT_TOOL_RESULT_INLINE_MAX_CHARS, } from './tool-result-history.js';
 import { TOOL_IMAGE_REF_RE, ToolImageLedger, cutStoredToolResultToFit, formatKeptImageSlots, parseImagePlaceholders, sha256Hex, storedImageSlots, toolResultCutAt, toolResultShare, } from './tool-image-ledger.js';
 import { randomUUID, createHash } from 'node:crypto';
@@ -278,6 +281,11 @@ const HOST_METADATA_KEYS = [
  * marker too. A marker that wakes the agent can still set that turn's speech
  * channel (agent-framework#189); a `chat:system` notice can't (systemNotice).
  */
+const isOwnScheduleWrite = (metadata) => {
+    const m = metadata;
+    return m?.serverId === 'heartbeat' || m?.source === 'gate:self-wake'
+        || (Array.isArray(m?.tags) && m.tags.includes('script:wake'));
+};
 const isConversationalInjection = (metadata) => {
     if (!metadata)
         return true;
@@ -517,18 +525,30 @@ const ambientMark = (tags) => Array.isArray(tags) && tags.includes('chat:ambient
  *  something anyone said there, so it never picks where the turn's plain
  *  speech goes. */
 const systemNoticeMark = (tags) => isSystemNotice(tags) ? { systemNotice: true } : {};
+/**
+ * A wake from the heartbeat: a tick or a reminder, from the framework's own
+ * heartbeat or from an MCPL server whose id is `heartbeat` (heartbeat-mcpl),
+ * which carries no channel. A silent tick isn't one here: its turn keeps
+ * every plain word private already (suppressProse). Its turn's plain speech
+ * has no destination (TurnRouting.heartbeat).
+ */
+function isHeartbeatWake(trigger) {
+    if (trigger === undefined || trigger.channelId || trigger.suppressProse === true)
+        return false;
+    return trigger.heartbeatTurn ?? trigger.source === 'heartbeat';
+}
 // parseProsePrefix lives in ./mcpl/prose-grammar.ts. The outgoing stream
 // (Spec 14.3) needs no grammar of its own: it carries what delivery
 // published.
 /** One-time primer appended when an agent's proseRouting mode changes. */
 function proseModePrimer(mode, helpAvailable) {
     if (mode === 'locus') {
-        return '[prose-routing] Mode change: your plain text auto-routes to the ' +
+        return `[${NOTICE_TAG.proseRouting}] Mode change: your plain text auto-routes to the ` +
             'conversational locus again, unless its server declared that channel inbound-only. ' +
             '`>>` destination prefixes are no longer needed.';
     }
     if (mode === 'hybrid') {
-        return '[prose-routing] Hybrid routing enabled: unprefixed text still lands in the ' +
+        return `[${NOTICE_TAG.proseRouting}] Hybrid routing enabled: unprefixed text still lands in the ` +
             'current conversational locus, unless its server declared that channel inbound-only. ' +
             'A leading `>>>destination` envelope instead routes ' +
             'that prose to one uniquely resolved authorized Discord or Eidoverse channel. The ' +
@@ -544,7 +564,7 @@ function proseModePrimer(mode, helpAvailable) {
     // content — the safest role there is). Nothing is injected into the system
     // prompt: those bytes belong to the recipe, and the deepest KV prefix must
     // not vary with framework code.
-    return ('[prose-routing] Output mode changed: plain text is delivered only with a ' +
+    return (`[${NOTICE_TAG.proseRouting}] Output mode changed: plain text is delivered only with a ` +
         'destination prefix line, e.g. ">>#channel-name your text".' +
         (helpAvailable ? ' The prose_help tool shows the full syntax.' : ''));
 }
@@ -579,27 +599,28 @@ const PROSE_HELP_TOOL = {
     description: 'Show the plain-text output routing syntax (destination prefixes, resend token, skip).',
     inputSchema: { type: 'object', properties: {} },
 };
-/** "1 registered utility", "2 registered utilities". */
-const registeredUtilities = (n) => `${n} registered ${n === 1 ? 'utility' : 'utilities'}`;
-/** The single slot behind which every rarely-used capability lives. Only
- *  advertised when at least one module contributes utilities — with none
- *  registered the surface is byte-identical to before this existed. */
-const UTILS_TOOL = {
-    name: 'utils',
-    description: 'Rarely-used utilities, behind one slot instead of each costing a tool. ' +
-        '"list" names the utilities you can use, with one-liners; "describe" returns one utility\'s full ' +
-        'input schema; "run" invokes it (args are validated against that schema — a ' +
-        'miss bounces back with the schema and the specific error).',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            action: { type: 'string', enum: ['list', 'describe', 'run'], description: 'What to do.' },
-            name: { type: 'string', description: 'Utility name from list (required for describe/run).' },
-            args: { type: 'object', description: "Arguments for run, per the utility's schema." },
-        },
-        required: ['action'],
-    },
-};
+/** What a call of the removed `utils` tool is answered: where its utilities went. */
+const UTILS_REMOVED = `utils was removed: module utilities are in the host's built-in toolset now. ` +
+    `${META_TOOL_NAMES.look} {toolset:"${BUILTIN_TOOLSET}"} lists them, ${META_TOOL_NAMES.open} {toolset:"${BUILTIN_TOOLSET}"} opens it, ` +
+    `and ${META_TOOL_NAMES.act} {tool, args} calls one. Nothing was run.`;
+/**
+ * The framework's own tools that belong to the host's built-in toolset
+ * ("settings", host-presentation.ts) rather than the tool list: the ones an
+ * agent reaches for rarely. Modules place theirs with Module.toolPlacement,
+ * and every module utility is there too.
+ */
+export const BUILTIN_TOOLSET_TOOLS = new Set([
+    'agent_settings',
+    'wake_add_rule',
+    'wake_remove_rule',
+    'gate_status',
+    'event_tags',
+    'set_tool_visibility',
+    'set_tool_description',
+    'heartbeat--heartbeat_status',
+    'heartbeat--heartbeat_trigger',
+    'workspace--status',
+]);
 const readExtensionSettings = (ext, agentName) => {
     const values = ext.get(agentName);
     return Object.fromEntries(Object.entries(values).map(([key, value]) => [key, value === undefined ? 'undefined' : JSON.stringify(value)]));
@@ -614,6 +635,19 @@ const settingNumber = (name, value) => {
         return n;
     throw new Error(`${name} must be a number, not ${shownValue(value)}`);
 };
+const DEFAULT_TURN_REARM_MS = [2 * 60_000, 8 * 60_000, 32 * 60_000];
+const turnRearmDelays = (value) => {
+    if (value === undefined)
+        return DEFAULT_TURN_REARM_MS;
+    if (value === false)
+        return [];
+    if (!Array.isArray(value) || value.length === 0
+        || ![...value].every((ms) => typeof ms === 'number' && Number.isFinite(ms) && ms > 0)) {
+        throw new Error('FrameworkConfig.exhaustedTurnRearmMs must be false, or a list of one or more delays in ms, ' +
+            `each a number above 0, not ${shownValue(value)}`);
+    }
+    return [...value];
+};
 const settingBoolean = (name, value) => {
     if (typeof value === 'boolean')
         return value;
@@ -621,22 +655,17 @@ const settingBoolean = (name, value) => {
         return value === 'true';
     throw new Error(`${name} must be true or false, not ${shownValue(value)}`);
 };
-/** First sentence (or line) of a description — what `utils list` shows. */
-const utilityOneLiner = (description) => {
-    const line = description.split('\n')[0];
-    const dot = line.indexOf('. ');
-    return safeSlice(dot >= 0 ? line.slice(0, dot + 1) : line, 0, 160);
-};
 import { CheckpointManager } from './mcpl/checkpoint-manager.js';
 import { isToolAllowed } from './mcpl/tool-policy.js';
-import { asCalled, cutOffRefusal, markedInputRefusal, toolArgsProblems } from './tool-args.js';
+import { asCalled, cutOffRefusal, markedInputRefusal } from './tool-args.js';
 import { cutOffRound } from './cut-off-round.js';
-import { EventGate, checkToolInput, formatShadowWarning, shownValue, wakeLineText } from './gate/event-gate.js';
+import { EventGate, MCPL_GATE_EVENT_TYPES, checkToolInput, formatShadowWarning, shownValue, wakeLineText } from './gate/event-gate.js';
 import { ReplyJudge } from './gate/reply-judge.js';
 import { HEARTBEAT_CHANGING_TOOLS, Heartbeat, isHeartbeatMcplServer } from './heartbeat/heartbeat.js';
 import { EPHEMERAL_USAGE_NAME, UsageTracker, persistedUsageProblem } from './usage/usage-tracker.js';
 import { McplProtocolVersionError, McplRequestError, McplUnreapedLaunchError, stderrTailOf, toolsetDeclarationsOf, withStderr } from './mcpl/server-connection.js';
 import { ToolsetHub, TOOLSETS_MODULE, META_TOOL_NAMES } from './mcpl/toolset-host.js';
+import { HostPresentation, BUILTIN_TOOLSET } from './host-presentation.js';
 import { isEmptyChange } from './mcpl/tool-presence.js';
 import { ToolsetsModule, resolveAct, withLookHint } from './mcpl/toolsets-module.js';
 import { ModernMcpConnection } from './mcpl/modern-connection.js';
@@ -797,7 +826,29 @@ const TURN_RETRY = Symbol('turn-retry');
  * record. A symbol, as TURN_RETRY is, so spreads and rests copy it.
  */
 const MERGED_BATCH = Symbol('merged-batch');
+const REARMED = Symbol('rearmed');
 const TURN_CARRY = Symbol('turn-carry');
+function isRearmed(request) {
+    return request !== undefined && request[REARMED] === true;
+}
+function waitAlertsOnItsOwn(wait) {
+    return wait.until === null || wait.until - wait.setAt > PROVIDER_WAIT_ALERT_MS;
+}
+// membrane 0.8.0 marks a deadline it reports as run out with this registered
+// symbol (on a sent request, or the Anthropic SDK's timeout, which covers its
+// connect timeout too), and doesn't export its reader.
+const MEMBRANE_DEADLINE_EXPIRY = Symbol.for('membrane.deadlineExpiry');
+function isTransientFailure(error) {
+    if (!isMembraneError(error) || error.retryable !== true)
+        return false;
+    if (error[MEMBRANE_DEADLINE_EXPIRY] === true)
+        return false;
+    return error.type === 'server' || error.type === 'network' || error.type === 'timeout' || error.type === 'rate_limit';
+}
+function gotPartway(routing) {
+    return routing.roundsRan === true || (routing.unflushedRounds ?? 0) > 0;
+}
+const REARM_REASON = 'exhausted-turn-rearm';
 function mergedBatch(request) {
     return request[MERGED_BATCH];
 }
@@ -953,7 +1004,7 @@ function ephemeralRunStopped(name, observed) {
 }
 const CALLS_CUT_OFF = "A round's tool calls were started, but its stream ended before their results came back, so that round isn't in your context; those calls may have taken effect.";
 const SPEECH_STILL_ROUTING = 'Some of its plain speech was still being routed when it ended, so it may yet be posted; check the channel before sending it again.';
-const LIVE_SPEECH_UNRECEIPTED = 'Plain speech its rounds routed live was handed on for delivery as written, and no [delivered] line was written for it.';
+const LIVE_SPEECH_UNRECEIPTED = `Plain speech its rounds routed live was handed on for delivery as written, and no [${NOTICE_TAG.delivered}] line was written for it.`;
 /** The reason on the inference:aborted that ends a turn whose retry stop()
  *  cancelled, whichever frame was waiting to retry: beginAgentTurn's, when
  *  the stream couldn't start, or driveStream's, when it failed once started;
@@ -1475,7 +1526,9 @@ const WAITING_TRACE_EVERY_MS = 60_000;
 /** A stated wait recorded to hold a model longer than this, or until
  *  released, raises an ops alert. It is honoured in full either way: a hold
  *  that long is a quota-scale event or a provider's mistake, and a person
- *  decides which (release-provider-wait). Shorter waits are pacing. */
+ *  decides which (release-provider-wait). Shorter waits are pacing, until
+ *  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
@@ -1816,9 +1869,13 @@ function failureDescription(error) {
         return `${head}: ${String(error.message)}`;
     }
     catch {
-        return '[failure could not be described]';
+        return UNDESCRIBED_FAILURE;
     }
 }
+const UNDESCRIBED_FAILURE = `[${NOTICE_TAG.undescribedFailure}]`;
+function failureShown(text) {
+    return text === UNDESCRIBED_FAILURE ? text : suppliedValue(text);
+}
 /**
  * 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
@@ -2090,6 +2147,17 @@ const JUDGE_PARAMETER = {
     },
     required: ['debounceMs'],
 };
+/** Whether a server's configuration resolves to the MCPL (legacy) family,
+ *  the one that can negotiate RFC-014 tool hints. A configuration that names
+ *  no usable transport is refused elsewhere; here it has no hints. */
+function isLegacyFamily(config) {
+    try {
+        return resolveServerBinding(config).family === 'legacy';
+    }
+    catch {
+        return false;
+    }
+}
 export class AgentFramework {
     toolPresentations = new Map();
     presentationPreviews = new WeakMap();
@@ -2332,8 +2400,6 @@ export class AgentFramework {
      *  by the object, not the run's record (ephemeralRuns), which its cleanup
      *  drops before a cancelled stream may count its last usage. */
     ephemeralAgents = new WeakSet();
-    /** Warn only once per Agent instance after utilities are registered. */
-    emptyUtilityPermissionWarnings = new WeakSet();
     /** Physical ephemeral frames deliberately disposed by their run watchdog/caller.
      * The name is single-generation, so these frames still own their terminal
      * typing/outgoing close even after runEphemeralToCompletion deregisters them. */
@@ -2342,6 +2408,10 @@ export class AgentFramework {
      *  completes (inference:completed), not when a call answers mid-turn.
      *  Drives hard-down escalation — see noteInferenceExhausted. */
     consecutiveInferenceFailures = new Map();
+    turnRearmMs = DEFAULT_TURN_REARM_MS;
+    turnRearms = new Map();
+    exhaustingRearms = new Set();
+    statedWaitRuns = new Map();
     /** N consecutive failed inferences ⇒ the agent is treated as hard-down and
      *  escalated loudly to stderr. */
     inferenceFailureEscalationThreshold = 3;
@@ -2586,15 +2656,16 @@ export class AgentFramework {
     releasesAfterResume = new Map();
     managerReleases = new WeakMap();
     releasedByCleanup = new WeakSet();
-    // context-manager 0.23.0: a strategy that keeps its context, as
-    // AutobiographicalStrategy does (hostContext, autobiographical.ts:2849),
+    // context-manager 0.23.1: a strategy that keeps its context, as
+    // AutobiographicalStrategy does (hostContext, autobiographical.ts:2897),
     // keeps its manager reachable while its work is pending, since the
     // context's tools and systemPrompt getters close over the manager
-    // (context-manager.ts:2321-2337). So such a released manager is collected
+    // (context-manager.ts:2343-2359). 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();
     openManagerRefs = new WeakMap();
+    storeSees = new WeakMap();
     collectedManagers = new FinalizationRegistry((ref) => this.openManagers.delete(ref));
     /** The coalescing commit in flight, if any (see commitCoalescingDurable). */
     coalescingCommit = null;
@@ -2732,10 +2803,15 @@ export class AgentFramework {
     /** Host capabilities advertised during the MCP handshake — stored so servers
      *  can be connected at runtime (connectMcplServer) after initialization. */
     mcplHostCapabilities = null;
-    /** MCPL RFC-014: every toolHints server's tool presence, for the
+    /** MCPL RFC-014: every hinted server's tool presence, for the
      *  `toolsets` module's meta-tools and reminders. Made when the first
-     *  server configured with `toolHints: true` is set up; null until then. */
+     *  server with tool hints (any not configured `toolHints: false`) is set
+     *  up; null until then. */
     toolsetHub = null;
+    /** The host's own toolsets: the built-in "settings" and MCPL server tabs. */
+    hostPresentation = null;
+    /** MCPL servers kept disconnected as closed tabs, with the configuration an open connects them with. */
+    closedTabConfigMap;
     /** Inference routing policy from FrameworkConfig — stored so the MCPL
      *  subsystem can be lazily initialized by connectMcplServer when the
      *  framework started with zero configured servers. */
@@ -2996,6 +3072,7 @@ export class AgentFramework {
         }
         const framework = building.framework = new AgentFramework(store, ownsStore, config.membrane, config.inferencePolicy ?? new DefaultInferencePolicy(), config.errorPolicy ?? new DefaultErrorPolicy(), config.syncIntervalMs ?? DEFAULT_SYNC_INTERVAL_MS, config.maintenanceIntervalMs ?? DEFAULT_MAINTENANCE_INTERVAL_MS, processLoggingPersist, resolveTimeZone(config.timeZone), discordAwarenessOutbox, config.discordAwarenessEmoji ?? DEFAULT_DISCORD_AWARENESS_EMOJI, normalizeDiscordAwarenessDeadline(config.discordAwarenessDeadlineMs), new OperatorLog(operatorLogPath));
         framework.providerHoldHook = config.providerHold;
+        framework.turnRearmMs = turnRearmDelays(config.exhaustedTurnRearmMs);
         // Before any delivery.
         await framework.reconcileDiscordAwarenessAtStartup();
         // Restore persisted usage data (if any) from prior session. The names it
@@ -3025,9 +3102,6 @@ export class AgentFramework {
         for (const module of config.modules) {
             await framework.addModule(module);
         }
-        for (const agent of framework.agents.values()) {
-            framework.warnEmptyUtilityPermissions(agent);
-        }
         for (const [agentName, presentation] of framework.toolPresentations) {
             const workspace = framework.getWorkspaceModule();
             if (!workspace)
@@ -3090,6 +3164,8 @@ export class AgentFramework {
                 upcomingWakes: (agentName) => framework.upcomingWakesFor(agentName),
             });
             framework.judgeWired = judge !== undefined;
+            const configuredServerIds = new Set((config.mcplServers ?? []).map((server) => server.id));
+            const heartbeatOn = config.heartbeat !== undefined && config.heartbeat !== null && config.heartbeat !== false;
             framework.eventGate = new EventGate({
                 configPath,
                 initialConfig: config.gate.config,
@@ -3149,11 +3225,22 @@ export class AgentFramework {
                 // debounce can fire).
                 // A batched wake's summary names each channel as the agent names it
                 // back, with its server where another server shares its id.
-                channelShown: (channel) => framework.channelRegistry?.nameShown(channel) ?? channel.channelId,
+                channelShown: (channel) => framework.channelRegistry?.nameShown(channel) ?? suppliedValue(channel.channelId),
                 // A batched wake for one message still newest in the window hands its
                 // `[Gate: …]` line to the wake, for a fresh start of the wake's turn
                 // to decide (placeWakeLines).
                 isNewestEntry: (entry) => framework.isNewestContextEntry(entry),
+                // What a source can send, for the rule-order notes: an MCPL server's
+                // events reach the gate as its pushes and channel messages only (a
+                // module's events carry a source of the module's own, such as "cli"
+                // or "mcpl:<id>"), and the heartbeat's ticks as pushes.
+                eventTypesFrom: (source) => {
+                    if (configuredServerIds.has(source) || framework.mcplServerConfigs.has(source))
+                        return MCPL_GATE_EVENT_TYPES;
+                    if (source === 'heartbeat' && heartbeatOn)
+                        return ['mcpl:push-event'];
+                    return undefined;
+                },
                 resolveRouteChannel: (info) => {
                     if (info.eventType === 'mcpl:channel-incoming')
                         return info.channelId || undefined;
@@ -3281,16 +3368,19 @@ export class AgentFramework {
                 });
             }
         }
+        // The host's own toolsets (host-presentation.ts): the built-in "settings"
+        // and each MCPL server's tab, per agent, kept beside the store.
+        framework.hostPresentation = framework.makeHostPresentation(config.storePath);
         // Initialize MCPL subsystems if configured
         if (config.mcplServers && config.mcplServers.length > 0) {
             // Check every server's config before any is brought up: its boolean
             // settings, and its tool prefix, which mustn't collide with a module
             // name or another server's prefix.
             const moduleNames = new Set(config.modules.map(m => m.name));
-            // RFC-014: a server configured with toolHints brings the toolsets
-            // module, whose name no prefix may take either.
-            if (config.mcplServers.some((serverConfig) => serverConfig.toolHints === true))
-                moduleNames.add(TOOLSETS_MODULE);
+            // The name `toolsets` is the framework's from creation: its toolsets
+            // module (or a module given here that holds the name) takes it, so no
+            // prefix may.
+            moduleNames.add(TOOLSETS_MODULE);
             const prefixesSeen = new Map(); // prefix → serverId
             for (const serverConfig of config.mcplServers) {
                 assertServerConfigBooleans(serverConfig);
@@ -3309,9 +3399,28 @@ export class AgentFramework {
                 }
                 prefixesSeen.set(prefix, serverConfig.id);
             }
-            if (config.mcplServers.some((serverConfig) => serverConfig.toolHints === true))
+            framework.reserveToolsetsName(config.modules, config.mcplServers);
+            if (framework.toolsetsNameHeldAtStart === null)
                 await framework.ensureToolsetsModule();
-            await framework.initializeMcpl(config.mcplServers, config.inferenceRouting);
+            // A server kept as a closed tab (by its configured presentation, or as
+            // an agent last left it) isn't connected until an agent opens it.
+            let closed = framework.hostPresentation.startClosed(config.mcplServers);
+            if (framework.toolsetsNameHeldAtStart !== null && closed.size > 0) {
+                // No agent could open a closed tab: the meta-tools aren't the framework's.
+                console.error(`[toolsets] ${[...closed].join(', ')} ${closed.size === 1 ? 'is' : 'are'} connected at startup though kept as a closed tab: ` +
+                    `the name "${TOOLSETS_MODULE}" is ${framework.toolsetsNameHeldAtStart}, so no agent could open ${closed.size === 1 ? 'it' : 'them'}`);
+                closed = new Set();
+            }
+            for (const serverConfig of config.mcplServers) {
+                if (closed.has(serverConfig.id))
+                    framework.closedTabConfigs().set(serverConfig.id, serverConfig);
+            }
+            await framework.initializeMcpl(config.mcplServers.filter((c) => !closed.has(c.id)), config.inferenceRouting);
+        }
+        else if (!config.modules.some((m) => m.name === TOOLSETS_MODULE)) {
+            // The meta-tools are every agent's: the built-in toolset needs them,
+            // MCPL or none.
+            await framework.ensureToolsetsModule();
         }
         // Tune-out coordinator (issue #77): needs both the subconscious resident
         // and the MCPL channel subsystem; created after both exist.
@@ -4172,7 +4281,7 @@ export class AgentFramework {
      *  only its own model, which auxiliary admission checks per call. */
     cooldownBlocksAuxiliary(agentName) {
         const cooldown = this.providerAccelerationCooldowns.get(agentName);
-        return cooldown !== undefined && cooldown.waitModel === undefined;
+        return cooldown !== undefined && cooldown.waitModel === undefined && cooldown.rearm === undefined;
     }
     acquirePrimaryProviderGate(agentName) {
         const gate = this.providerGate(agentName);
@@ -4298,23 +4407,50 @@ export class AgentFramework {
         }
         const cooldown = this.providerAccelerationCooldowns.get(agentName);
         if (cooldown && cooldown.heldRequests.length > 0 && Number.isFinite(cooldown.until)) {
-            wakes.push({ at: cooldown.until, certain: true, what: 'a turn held by a provider cooldown, when it ends' });
-        }
-        // The heartbeat's ticks and reminders, which the agent's rules decide as
-        // they decide a heartbeat push: one the rules would hold back is listed
-        // as only a "maybe".
-        if (this.heartbeat && this.heartbeatTargets().includes(agentName)) {
-            const probe = (kind) => !this.eventGate
-                || this.eventGate.probe(this.heartbeatGateEvent({ kind, eventId: 'probe', text: 'probe' })).trigger;
-            const tickWakes = probe('heartbeat');
-            const reminderWakes = probe('reminder');
-            for (const w of this.heartbeat.upcomingWakes()) {
-                const isReminder = w.what.startsWith('its reminder');
-                wakes.push((isReminder ? reminderWakes : tickWakes) ? w : { ...w, certain: false });
-            }
+            wakes.push({ at: cooldown.until, certain: true, what: cooldown.rearm
+                    ? `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));
         return wakes;
     }
+    /**
+     * The heartbeat's ticks and reminders for `agentName`, soonest first, which
+     * the agent's rules decide as they decide a heartbeat push: one the rules
+     * would hold back is only a "maybe" (`certain` false). Each is probed as
+     * the event its delivery is judged by (deliverHeartbeat): a silent tick as
+     * silent, with the text it will bring, so a rule on the content or the
+     * silent flag decides the probe as it will decide the wake. None for an
+     * agent the heartbeat doesn't wake. `whose` words them for the judge ("its
+     * heartbeat") or for the agent ("your heartbeat").
+     */
+    heartbeatWakesFor(agentName, whose = 'its') {
+        if (!this.heartbeat || !this.heartbeatTargets().includes(agentName))
+            return [];
+        const wakes = (w) => !this.eventGate
+            || this.eventGate.probe(this.heartbeatGateEvent({ kind: w.kind, eventId: 'probe', text: w.text, silent: w.silent })).trigger;
+        return this.heartbeat.scheduledWakes(whose).map((w) => (wakes(w) ? w : { ...w, certain: false }));
+    }
+    /**
+     * The heartbeat's wake due before a self-wake due at `selfWakeAt` (ms), for
+     * the skip_reply that armed it: the soonest of its ticks and reminders that
+     * the agent's rules, as they stand, let wake it. The confirmation says when
+     * it's due, not that it will wake the agent (skipReplyNote), so a probe
+     * that can't foresee the gate at the wake's time (a gate.js, a rate limit's
+     * tokens then) leaves it true. A failure here costs only that line: the
+     * self-wake is armed already, and the confirmation goes out without it.
+     */
+    heartbeatWakeBefore(agentName, selfWakeAt) {
+        try {
+            const now = Date.now();
+            const first = this.heartbeatWakesFor(agentName, 'your').find((w) => w.certain && w.at < selfWakeAt);
+            return first ? { inSeconds: Math.max(1, Math.round((first.at - now) / 1000)), what: first.what } : undefined;
+        }
+        catch (err) {
+            console.error(`[self-wake] agent=${agentName}: the heartbeat's wakes couldn't be read for skip_reply's note: ${logDetail(err instanceof Error ? err.message : String(err))}`);
+            return undefined;
+        }
+    }
     /** The agents the heartbeat wakes: the residents, not conversation forks,
      *  ephemeral runs or the subconscious, which keep windows of their own. */
     heartbeatTargets() {
@@ -4723,8 +4859,63 @@ export class AgentFramework {
         console.error(`[provider-cooldown] agent=${agent.name} ` +
             `${hostHold ? `host hold (${hostHold.reason})` : 'organization acceleration 429'} — ` +
             `holding primary/auxiliary for ${delayMs}ms; ${held.length} request(s) retained`);
+        if (wait && trigger && (wait.until === null || wait.until > now))
+            this.noteStatedWaitRun(agent.name, wait, now);
         return true;
     }
+    rearmExhaustedTurn(agent, error, trigger, ownsProviderGate, routing) {
+        if (!ownsProviderGate || trigger === undefined || this.providerAdmissionClosed || this.turnRearmMs.length === 0)
+            return;
+        const done = this.turnRearms.get(agent.name) ?? 0;
+        const notSent = (why) => console.error(`[inference-rearm] agent=${agent.name} turn not re-armed: ${why}`);
+        if (!isTransientFailure(error)) {
+            if (done > 0)
+                notSent(`its failure isn't transient (${isMembraneError(error) ? error.type : boundFailureText(error.message, FAILURE_SUMMARY_MAX_CHARS)})`);
+            return;
+        }
+        const continuation = isTurnContinuation(trigger.reason);
+        const speaking = routing?.locus ?? routing?.triggerChannel;
+        if (!speaking && routing?.noChannel && !trigger.channelId) {
+            notSent('it would have to guess a channel');
+            return;
+        }
+        if (done >= this.turnRearmMs.length) {
+            notSent(`its ${this.turnRearmMs.length} re-arms are spent until a turn completes or a message is said to it`);
+            return;
+        }
+        const delayMs = this.turnRearmMs[done];
+        const rearm = { number: done + 1, of: this.turnRearmMs.length };
+        this.turnRearms.set(agent.name, rearm.number);
+        const request = { ...trigger, [REARMED]: true };
+        delete request[TURN_RETRY];
+        delete request[MERGED_BATCH];
+        if (continuation) {
+            request.reason = REARM_REASON;
+            delete request.counterparty;
+        }
+        if (speaking) {
+            request.channelId = speaking.channelId;
+            request.channelServerId = speaking.serverId;
+            request.addressed = true;
+        }
+        const existing = this.providerAccelerationCooldowns.get(agent.name);
+        if (existing) {
+            this.holdRequest(existing.heldRequests, request);
+        }
+        else {
+            const now = Date.now();
+            const timer = setTimeout(() => this.releaseProviderAccelerationCooldown(agent.name), this.providerHoldTimerMs(delayMs));
+            timer.unref?.();
+            this.providerAccelerationCooldowns.set(agent.name, {
+                startedAt: now, until: now + delayMs, timer, heldRequests: [request], failures: 0, rearm,
+                reason: `its turn's retries ran out (${boundFailureText(error.message, FAILURE_SUMMARY_MAX_CHARS)}), ` +
+                    `so it is sent again (${rearm.number} of ${rearm.of})`,
+            });
+        }
+        console.error(`[inference-rearm] agent=${agent.name} turn sent again ` +
+            (existing ? 'when the provider hold already on the agent ends' : `in ${delayMs}ms`) +
+            ` (${rearm.number} of ${rearm.of})`);
+    }
     /**
      * A provider's stated wait on a turn that doesn't own provider admission:
      * a conversation agent's or an ephemeral run's. Left to the error policy,
@@ -4842,8 +5033,10 @@ 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);
-        console.error(`[provider-cooldown] agent=${agentName} released after ${Date.now() - cooldown.startedAt}ms — ` +
-            `fresh compile queued with ${requests.length} retained request(s)`);
+        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 — ` +
+                `fresh compile queued with ${requests.length} retained request(s)`);
     }
     /**
      * Wait an error policy's retry delay, all of it: the delay can be a
@@ -4921,13 +5114,47 @@ export class AgentFramework {
                 : `until ${new Date(wait.until).toISOString()}`;
             const stated = `${error.type}${error.httpStatus !== undefined ? ` HTTP ${error.httpStatus}` : ''}, retry-after ${String(error.retryAfterMs)}ms`;
             console.error(`[provider-wait] agent=${agentName} model=${model} holds ${until}: ${stated}`);
-            if (remaining > PROVIDER_WAIT_ALERT_MS) {
+            if (waitAlertsOnItsOwn(wait)) {
                 this.opsAlert('provider-wait', agentName, `provider wait on ${model} holds ${until} (${stated}: ${reason}); ` +
                     'if the provider did not mean that, release it with release-provider-wait', { data: { model, until: wait.until === null ? null : new Date(wait.until).toISOString() } });
             }
         }
         return wait;
     }
+    noteStatedWaitRun(agentName, wait, now) {
+        let run = this.statedWaitRuns.get(agentName);
+        if (!run) {
+            run = { since: now, holds: 0, alerted: false, model: wait.model, reason: wait.reason, heldUntil: now };
+            this.statedWaitRuns.set(agentName, run);
+        }
+        run.holds++;
+        run.model = wait.model;
+        run.reason = wait.reason;
+        if (wait.until !== null)
+            run.heldUntil = Math.max(run.heldUntil, wait.until);
+        if (waitAlertsOnItsOwn(wait))
+            run.alerted = true;
+        if (now - run.since > PROVIDER_WAIT_ALERT_MS)
+            this.alertStatedWaitRun(agentName, run, now);
+    }
+    alertStatedWaitRun(agentName, run, now) {
+        if (run.alerted)
+            return;
+        run.alerted = true;
+        const since = new Date(run.since).toISOString();
+        this.opsAlert('provider-wait', agentName, `a turn's ${run.holds} stated waits in a row on ${run.model} span ${Math.round((now - run.since) / 60_000)} min ` +
+            `since ${since}: ${run.reason}; a provider stating waits that long in a row points to the account's rate limit ` +
+            "or quota, or this host's load", { data: { model: run.model, since, holds: run.holds } });
+    }
+    endStatedWaitRun(agentName) {
+        const run = this.statedWaitRuns?.get(agentName);
+        if (!run)
+            return;
+        this.statedWaitRuns.delete(agentName);
+        const end = Math.min(Date.now(), run.heldUntil);
+        if (end - run.since > PROVIDER_WAIT_ALERT_MS)
+            this.alertStatedWaitRun(agentName, run, end);
+    }
     /**
      * Hold this agent's primary turns for a provider wait on its model. The
      * requests are kept and released together, into one fresh compile, when
@@ -4961,8 +5188,11 @@ export class AgentFramework {
             this.holdRequest(held, request);
         // An acceleration or host hold already parks the whole agent; its release
         // re-checks this wait at admission.
-        if (existing && existing.waitModel === undefined)
+        if (existing && existing.waitModel === undefined) {
+            if (failed)
+                this.noteStatedWaitRun(agent.name, wait, now);
             return true;
+        }
         if (existing)
             clearTimeout(existing.timer);
         const timer = setTimeout(() => this.releaseProviderAccelerationCooldown(agent.name), this.providerHoldTimerMs(until - now));
@@ -4976,6 +5206,8 @@ export class AgentFramework {
             console.error(`[provider-wait] agent=${agent.name} model=${wait.model} holding primary turns ` +
                 `${wait.until === null ? 'until released' : `until ${new Date(wait.until).toISOString()}`}; ${held.length} request(s) retained`);
         }
+        if (failed)
+            this.noteStatedWaitRun(agent.name, wait, now);
         return true;
     }
     /**
@@ -5029,6 +5261,9 @@ export class AgentFramework {
         if (model === EVERY_MODEL)
             model = undefined;
         const released = this.providerWaits?.release(agentName, model, by) ?? [];
+        const run = this.statedWaitRuns?.get(agentName);
+        if (run && released.some(({ wait }) => wait.model === run.model))
+            run.heldUntil = Math.min(run.heldUntil, Date.now());
         for (const { wait, release } of released) {
             console.error(`[provider-wait] agent=${agentName} model=${wait.model} released by ${by} (${release})`);
         }
@@ -5108,6 +5343,8 @@ export class AgentFramework {
             clearTimeout(cooldown.timer);
         this.providerAccelerationCooldowns.clear();
         this.providerAccelerationRecoveries.clear();
+        this.turnRearms?.clear();
+        this.exhaustingRearms?.clear();
         for (const gate of this.providerGates.values()) {
             gate.primaryDepth = 0;
             gate.primaryPending = false;
@@ -5513,6 +5750,12 @@ export class AgentFramework {
         if (claimedBy) {
             throw new Error(`Module "${module.name}" collides with the toolPrefix "${module.name}" the restart of "${claimedBy.restarting}" holds`);
         }
+        // A closed tab keeps its prefix for the connect its next open makes.
+        for (const [id, config] of this.closedTabConfigs()) {
+            if ((config.toolPrefix ?? `mcpl--${id}`) === module.name) {
+                throw new Error(`Module "${module.name}" collides with MCPL server "${id}"'s toolPrefix "${module.name}" (a closed tab)`);
+            }
+        }
         this.resetCompletedStop('addModule()');
         await this.moduleRegistry.addModule(module);
         // The workspace judges whether an agent's history holds a message as the
@@ -5675,12 +5918,12 @@ export class AgentFramework {
             agent.getContextManager().addMessage('user', [{
                     type: 'text',
                     text: (before === 'sending'
-                        ? `[turn-interrupted] Your previous turn was stopped before it sent anything — ` +
+                        ? `[${NOTICE_TAG.turnInterrupted}] Your previous turn was stopped before it sent anything — ` +
                             `a deliberate stop, not a failure.`
                         : before === 'finishing'
-                            ? `[turn-interrupted] Your previous turn was stopped before it finished — ` +
+                            ? `[${NOTICE_TAG.turnInterrupted}] Your previous turn was stopped before it finished — ` +
                                 `a deliberate stop, not a failure.`
-                            : `[turn-interrupted] Your previous turn was cancelled mid-stream — ` +
+                            : `[${NOTICE_TAG.turnInterrupted}] Your previous turn was cancelled mid-stream — ` +
                                 `a deliberate stop, not a failure. Whatever you were still ` +
                                 `producing when it stopped was cut off there.`) + handedOn,
                 }], { system: true, kind: 'turn-interrupted', reason });
@@ -5818,8 +6061,10 @@ export class AgentFramework {
             : [];
         return [
             ...moduleTools,
-            // Utilities collapse into one slot; absent entirely when none exist.
-            ...(this.moduleRegistry.getAllUtilities().length > 0 ? [UTILS_TOOL] : []),
+            // Utilities: callable tools, presented in the built-in toolset
+            // (placedInBuiltin), never in the tool list. One named like a tool of
+            // its module is that tool's: the tool takes the name.
+            ...this.moduleRegistry.getAllUtilities().filter((u) => !moduleTools.some((t) => t.name === u.name)),
             ...this.mcplTools,
             ...channelTools,
             ...gateTools,
@@ -5888,6 +6133,8 @@ export class AgentFramework {
     setMcplServerConfig(config) {
         this.mcplServerConfigs.set(config.id, config);
         referenceRegistry.setServerAddress(config.id, serverAddressOf(config), this);
+        // The gate's rule-order notes read which sources are servers.
+        this.eventGate?.sourcesChanged();
     }
     /** Register every RFC-005 reference in an MCPL peer's tool-result content
      *  against its server, then fetch by `mode`:
@@ -6175,7 +6422,7 @@ export class AgentFramework {
             return undefined;
         const reach = this.residentHoldsTraffic(who) ? ' Messages there that address you, such as an @-mention, still reach you.' : '';
         const open = this.canAgentUseTool(who, 'channel_open') && !registry.lifecycleWithheld(channel.serverId)
-            ? ` channel_open with channelId "${channel.channelId}" and serverId "${channel.serverId}" opens it.`
+            ? ` channel_open with channelId ${quotedValue(channel.channelId)} and serverId "${channel.serverId}" opens it.`
             : '';
         return `${this.channelShown(channel)} stays closed: you ${how} it, and your words there don't open it.${reach}${open}`;
     }
@@ -6265,14 +6512,14 @@ export class AgentFramework {
         const body = closedNote ?? tunedOutNote;
         if (!body)
             return answer;
-        const tag = closedNote ? '[closed channel]' : '[tuned out]';
+        const tag = `[${closedNote ? NOTICE_TAG.closedChannel : NOTICE_TAG.tunedOut}]`;
         if (forScript) {
             const window = this.noticeTargetFor(agentName, 'closed-channel');
             try {
                 if (window) {
                     this.addMessage('user', [{
                             type: 'text',
-                            text: `${tag} Your script's ${toolName}: ${body}${this.closedChannelNoteOff(agentName)}`,
+                            text: `${tag} Your script's ${suppliedValue(toolName)}: ${body}${this.closedChannelNoteOff(agentName)}`,
                         }], { system: true, kind: 'channel-notice' }, window);
                 }
             }
@@ -6430,16 +6677,6 @@ export class AgentFramework {
             },
         };
     }
-    warnEmptyUtilityPermissions(agent) {
-        if (agent.allowedTools === 'all' || !agent.allowedTools.includes('utils')
-            || this.emptyUtilityPermissionWarnings.has(agent))
-            return;
-        const utilities = this.moduleRegistry.getAllUtilities();
-        if (utilities.length === 0 || utilities.some(tool => agent.canUseTool(tool.name)))
-            return;
-        console.warn(`[utils] Agent '${agent.name}': ${registeredUtilities(utilities.length)}, 0 permitted; none permitted by this agent's allowedTools. Add each required module--utility name to allowedTools.`);
-        this.emptyUtilityPermissionWarnings.add(agent);
-    }
     getToolsForAgent(agentName, snapshot) {
         const agent = this.agents.get(agentName);
         // Model-facing advice names skip_reply only where dispatch would let this
@@ -6457,11 +6694,8 @@ export class AgentFramework {
                 : t);
             return [...SUBCONSCIOUS_TOOLS, ...basics];
         }
-        if (agent)
-            this.warnEmptyUtilityPermissions(agent);
-        const hasPermittedUtility = !agent || this.moduleRegistry.getAllUtilities().some(tool => agent.canUseTool(tool.name));
         return [...this.getAllTools(), ...(this.toolPresentations.has(agentName) ? presentationTools(this.toolPresentations.get(agentName).config.cataloguePath) : [])]
-            .filter(tool => tool.name !== 'utils' || hasPermittedUtility).map((tool) => {
+            .map((tool) => {
             if (tool.name === 'think') {
                 return this.buildThinkTool(snapshot?.sameRoundThinkTextPolicy
                     ?? this.getAgentRuntimeSettings(agentName).sameRoundThinkTextPolicy, canSkipReply);
@@ -6491,7 +6725,7 @@ export class AgentFramework {
             return null;
         const tools = this.availableToolsForPresentation(agentName, snapshot);
         const sources = new Map();
-        for (const tool of this.moduleRegistry.getAllTools()) {
+        for (const tool of [...this.moduleRegistry.getAllTools(), ...this.moduleRegistry.getAllUtilities()]) {
             sources.set(tool.name, `Module: ${tool.name.split('--')[0]}`);
         }
         // An MCPL tool's source is the server a call of it reaches, by the one
@@ -6506,8 +6740,8 @@ export class AgentFramework {
         return presentation.resolve(tools, sources);
     }
     advertisedToolsForAgent(agentName, snapshot) {
-        return this.inspectToolPresentation(agentName, snapshot)?.advertised
-            ?? this.availableToolsForPresentation(agentName, snapshot);
+        return this.headerTools(agentName, this.inspectToolPresentation(agentName, snapshot)?.advertised
+            ?? this.availableToolsForPresentation(agentName, snapshot));
     }
     /** Compression can revisit calls to hidden tools; never apply visibility here. */
     compressionToolsForAgent(agentName, snapshot) {
@@ -7020,8 +7254,10 @@ export class AgentFramework {
      * CURRENT settings — maintenance may have moved the folded floor and the
      * branch generation, so verdicts are computed at resume time, never reused.
      * Throws ResumeBlockedError (with all failing verdicts) unless `force`.
-     * Unavailable previews warn and pass — refusing to resume because the
-     * strategy cannot preview would hold hosts hostage to a diagnostic.
+     * Unavailable previews pass, with a warning naming the reason unless it is
+     * `no_preview_support`, a strategy with nothing to preview — refusing to
+     * resume because the strategy cannot preview would hold hosts hostage to a
+     * diagnostic.
      */
     async resume(opts) {
         this.refuseOperatorAfterStop('resume');
@@ -7898,7 +8134,8 @@ export class AgentFramework {
             throw new Error(`Agent not found: ${agentName}`);
         }
         const presentation = this.inspectToolPresentation(agentName);
-        const tools = presentation?.advertised ?? this.availableToolsForPresentation(agentName);
+        const availableTools = presentation?.available ?? this.availableToolsForPresentation(agentName);
+        const tools = this.headerTools(agentName, presentation?.advertised ?? availableTools);
         const capture = (request) => {
             if (presentation)
                 this.presentationPreviews.set(request, presentation);
@@ -7911,7 +8148,7 @@ export class AgentFramework {
         // Default: no dynamic injection gathering → no inference, no Chronicle
         // writes of its own, no external RPC. Opt in explicitly.
         if (!opts?.injections) {
-            return capture(await agent.buildActivationRequest(tools, undefined, opts?.budget, presentation?.available ?? tools, { dryRun: true }));
+            return capture(await agent.buildActivationRequest(tools, undefined, opts?.budget, availableTools, { dryRun: true }));
         }
         // Full-fidelity path: mirrors startAgentStream's injection gathering.
         // NOT transparent — see the doc comment above.
@@ -7951,7 +8188,7 @@ export class AgentFramework {
         const plan = this.planInjectionStores(agent, injections);
         const held = plan !== undefined && this.slotHeldFrom(agent);
         const placed = new Set(plan ? (held ? [...plan.leftAt, ...plan.rows.map((row) => row.at)] : plan.leftAt) : []);
-        return capture(await agent.buildActivationRequest(tools, plan ? (injections ?? []).filter((_, at) => placed.has(at)) : injections, opts?.budget, presentation?.available ?? tools, {
+        return capture(await agent.buildActivationRequest(tools, plan ? (injections ?? []).filter((_, at) => placed.has(at)) : injections, opts?.budget, availableTools, {
             dryRun: true,
             ...(plan && !held ? { appendedMessages: plan.rows.map(({ participant, content }) => ({ participant, content })) } : {}),
         }));
@@ -7969,7 +8206,13 @@ export class AgentFramework {
      * see `AutobiographicalStrategy.previewContext` and
      * `Agent.compileWithInjections`.
      *
-     * Returns null when the agent's strategy has no fold plan (non-adaptive).
+     * Returns null when the agent's strategy has nothing to preview: one without
+     * `previewContext`, or a non-adaptive `AutobiographicalStrategy` whose select
+     * fits the budget, built from the framework's own copy of context-manager.
+     * Built from another copy, such a strategy throws its `previewContext
+     * requires adaptiveResolution` error here instead, since the manager
+     * recognises only its own copy's `NoFoldPlanToPreviewError`. Over the
+     * budget, a non-adaptive strategy's preview is an infeasible one.
      */
     previewContextSettings(agentName, budgetTokens, overrides, opts) {
         const agent = this.agents.get(agentName);
@@ -8005,9 +8248,9 @@ export class AgentFramework {
      *
      * Never throws for preview-layer reasons: strategy without previewContext,
      * preview overlap, stale branch generation, the hierarchical (non-
-     * adaptive) path, and a context manager that refuses its queries (its
-     * strategy's initialization pending or failed) all come back as
-     * `{available: false, reason}`. Unknown agent still throws, matching the
+     * adaptive) path within its budget, and a context manager that refuses its
+     * queries (its strategy's initialization pending or failed) all come back
+     * as `{available: false, reason}`. Unknown agent still throws, matching the
      * sibling accessors, and so does a patch whose values the agent refuses,
      * whatever its context manager's state. Whether the strategy takes live
      * tail and pace settings is the manager's to say, so while it refuses, a
@@ -9066,16 +9309,18 @@ export class AgentFramework {
             description: 'Add or replace a wake rule (a gate.json policy) at runtime — no need to ' +
                 'hand-edit the file. The rule is validated and hot-applied immediately. ' +
                 'A rule with the same `name` replaces the existing one in place (add a ' +
-                'position to move it). ⚠️ ORDERING IS SEMANTICS: first match wins, and a ' +
-                'matched rule CONSUMES the event — a broad rule placed early makes every ' +
-                'later rule unreachable for its scope, including your addressed-message ' +
-                '(DM/mention) wake rules. Prefer `insertBefore`/`insertAfter` to place a ' +
-                'rule relative to a specific existing rule; use `position: "prepend"` only ' +
-                'when the rule really must beat EVERYTHING. For "additionally wake me ' +
-                'every Nth event / at most N per hour" governors, set `passthrough: true` ' +
-                'so non-firing matches fall through to your normal rules instead of ' +
-                'swallowing them. The result includes a before/after probe table and any ' +
-                'shadow warnings — READ THEM before ending the turn. Two common shapes:\n' +
+                'position to move it). Rules are checked in order and the first one that ' +
+                'matches an event decides it, so the rules below never see that event: a ' +
+                'broad rule placed early takes events from them, your DM and mention ' +
+                'rules included. Place a rule next to a particular one with ' +
+                '`insertBefore`/`insertAfter`; `position: "prepend"` puts it above all of ' +
+                'them. For a rule that only adds wakes ("also wake me every Nth event", ' +
+                '"at most N an hour"), set `passthrough: true`: the events it doesn\'t ' +
+                'wake for go on to your other rules. The result shows how a few common ' +
+                'events are decided before and after the change. Its `shadowWarnings` ' +
+                'are notes on your whole rule list, not only this change, wherever an ' +
+                'earlier rule takes events a later one could get: each says whether that ' +
+                'matters and what to do about it. Two common shapes:\n' +
                 '• Watch a FILE/workspace path: match on `mount` + `pathGlob`, e.g. ' +
                 '`{ name: "watch-notes", match: { scope: ["workspace:modified"], mount: "project", pathGlob: "notes/*.md" }, behavior: "always" }`.\n' +
                 '• Watch a CHANNEL: match on `source` + `channel` (and/or `tagsAny: ["chat:ambient"]`), ' +
@@ -9564,14 +9809,14 @@ export class AgentFramework {
         const ep = this.rewindEpisode.get(agent.name);
         const count = (ep?.count ?? 0) + 1;
         const why = cause === 'refusal'
-            ? `the model refused on them (content filter: ${category}). Their content is ` +
+            ? `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 (${category}), ` +
+            : `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 = `[refusal-rewind] The ${count} most recent turn(s) were set aside because ` +
+        const text = `[${NOTICE_TAG.refusalRewind}] The ${count} most recent turn(s) were set aside because ` +
             `${why}. 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.`;
@@ -11673,6 +11918,8 @@ export class AgentFramework {
         }
     }
     async createAgent(config) {
+        const sees = (metadata) => !metadata?.tuneOut
+            && !isAnotherAgentsInjection(metadata, config.name);
         // Create context manager for this agent
         const contextManager = await ContextManager.open({
             store: this.store,
@@ -11693,10 +11940,10 @@ export class AgentFramework {
             // Another agent's stored context injections (stored-injections.ts) are
             // that agent's context, not conversation: they stay out of this view,
             // and so out of its folds, as the residents share this slot.
-            viewFilter: (message) => !message.metadata?.tuneOut
-                && !isAnotherAgentsInjection(message.metadata, config.name),
+            viewFilter: (message) => sees(message.metadata),
         });
         this.trackManager(contextManager);
+        this.storeSees.set(contextManager, sees);
         const agent = new Agent(config, contextManager, this.membrane);
         this.adoptToolResultGuard(agent);
         agent.markContextConsumed(); // RFC-006: nothing stored before now is replaceable
@@ -11753,6 +12000,7 @@ export class AgentFramework {
             // oversized tool results / attachments under the same policy.
             maxMessageTokens: primaryConfig.strategy?.maxMessageTokens,
         });
+        const sees = (metadata) => !isAnotherAgentsInjection(metadata, name);
         const contextManager = await ContextManager.open({
             store: this.store,
             namespace: `subconscious/${primaryName}`,
@@ -11763,12 +12011,13 @@ export class AgentFramework {
             // residents' stored context injections (stored-injections.ts): their
             // context, which this agent never saw while they were placed unstored.
             auxiliaryMessageViews: [{}],
-            viewFilter: (message) => !isAnotherAgentsInjection(message.metadata, name),
+            viewFilter: (message) => sees(message.metadata),
             strategy,
             membrane: this.membrane,
             debugLogContext: !!process.env.DEBUG_CONTEXT,
         });
         this.trackManager(contextManager);
+        this.storeSees.set(contextManager, sees);
         // Inherit the principal's inference settings wholesale (fork-template
         // idiom): reasoning effort (thinking), provider params, token ceilings,
         // caching, refusal handling, timezone — a same-model side-process must
@@ -12005,6 +12254,7 @@ export class AgentFramework {
                         flushedTurn.roundsRan = true;
                         if (flushedTurn.unflushedRounds)
                             flushedTurn.unflushedRounds--;
+                        this.endStatedWaitRun(agent.name);
                     }
                     if (flushedTurn && replySent === null && !flushedTurn.privateEnd && !flushedTurn.silent
                         && pendingBlocks.some((b) => b.type === 'text' && b.text?.trim())) {
@@ -12069,11 +12319,12 @@ export class AgentFramework {
                     // with everything queued behind it — the queue keeps its order —
                     // for the turn-end flush, where no reply follows it in this stream.
                     //
-                    // A message a tune-out holds from the residents is drained and
-                    // stored like any other, but not injected: every resident's
-                    // viewFilter leaves it out of the next compile as well, so the
-                    // window's compiled prefix and the live request still match without
-                    // it (#232 gap 5).
+                    // A message the agent's own view filter leaves out, such as one a
+                    // tune-out holds from the residents or another agent's stored
+                    // context injection, is drained and stored like any other, but not
+                    // injected: the next compile leaves it out as well, so the window's
+                    // compiled prefix and the live request still match without it
+                    // (#232 gap 5).
                     //
                     // A stream that declares it can't carry injected messages
                     // (supportsInjectedMessages false: membrane's XML prefill path,
@@ -12105,14 +12356,11 @@ export class AgentFramework {
                         // counts as stored, as what landed of it (writeDrainedInOrder).
                         const stored = this.writeDrainedInOrder(deferred, `tool boundary for ${agent.name}`, (msg) => agent.getContextManager().addMessage(msg.participant, msg.content, withDeferredWriteId(msg.metadata, msg.id)));
                         for (const [msg, { id, content }] of stored) {
+                            this.noteSpokenTo(agent.name, msg.metadata);
                             // Every other resident reads what this boundary stores; for its
                             // own agent, the boundary weighs what it injects below.
                             this.noteForOtherResidents(agent, msg.metadata, id);
-                            // A message a tune-out holds from the residents is stored (the
-                            // subconscious reads it) and left out of every resident's
-                            // compiled view; injecting it here would put in the live turn
-                            // what the next compile hides (#232 gap 5).
-                            if (msg.metadata?.tuneOut)
+                            if (!this.agentSees(agent, msg.metadata))
                                 continue;
                             heard.push({ msg, id, content });
                         }
@@ -12125,10 +12373,12 @@ export class AgentFramework {
                         const rendered = this.renderForInjection(agent, [...(clock ? [clock.id] : []), ...heard.map((h) => h.id)]);
                         const first = clock ? 1 : 0;
                         // A null is a message the render places before its window. Under
-                        // the memory strategy that's one before its recent window, when
-                        // what this boundary stored is bigger than it, or any message
-                        // while a head window a topic change reset hasn't filled yet. The
-                        // next compile still sends it, raw and in order, after the tool
+                        // context-manager 0.23.0's memory strategy that's one before its
+                        // recent window, when what this boundary stored is bigger than it,
+                        // or any message while a head window a topic change reset hasn't
+                        // filled yet; from 0.23.1 that strategy gives no null for a
+                        // message its view holds. The next compile still sends such a
+                        // message, raw and in order, after the tool
                         // result, so leaving it out would change the prefix as surely as
                         // any form, and the agent wouldn't hear it (context-manager#275's
                         // review, R1-1). It goes in as stored, which is the form the next
@@ -12139,13 +12389,12 @@ export class AgentFramework {
                         // cap reaches it. And a body the strategy stored in parts goes in
                         // whole, joined as the store reads it back, where the next
                         // compile sends it in more than one piece.
-                        // That rests on two things. The only view filter this framework
-                        // gives a store is the tune-out stamp (createAgent's; the other
-                        // stores it opens have none), and a stamped message is skipped
-                        // above, so no null here means a message the view hides. And the
-                        // store and the render run with nothing between them, so nothing
-                        // can put a summary in place of what this flush stored, or move
-                        // windowed passthrough's anchor past it, before the render. A
+                        // That rests on two things. A message the agent's own view filter
+                        // leaves out is skipped above, by that filter, so no null here
+                        // means a message the view hides. And the store and the render
+                        // run with nothing between them, so nothing can put a summary in
+                        // place of what this flush stored, or move windowed passthrough's
+                        // anchor past it, before the render. A
                         // write found here that landed at an earlier flush
                         // (writeDrainedInOrder) is the exception: by now a summary may
                         // stand in for it, or the anchor be past it, and then it goes in
@@ -12503,6 +12752,10 @@ export class AgentFramework {
         // Dispatch to all modules, tracking responses with module names
         const responses = [];
         for (const module of this.moduleRegistry.getAllModules()) {
+            // The framework's own toolsets module answers no event; every agent has
+            // it now, so it isn't listed beside the modules that do.
+            if (module instanceof ToolsetsModule)
+                continue;
             try {
                 const processState = this.moduleRegistry.createProcessState(module.name);
                 const response = await module.onProcess(event, processState);
@@ -12589,6 +12842,7 @@ export class AgentFramework {
         // surface carries where the framework records none.
         const eventChannel = event.metadata?.channelId;
         const namesChannel = typeof eventChannel === 'string' && eventChannel !== '';
+        const localInput = event.type === 'external-message' || event.type === 'api:message';
         let added;
         if (response.addMessages) {
             for (const [i, msg] of response.addMessages.entries()) {
@@ -12601,7 +12855,7 @@ export class AgentFramework {
                 if (surface)
                     metadata = { ...metadata, [INBOUND_SOURCE_KEY]: surface };
                 const placement = {};
-                const id = this.addMessage(msg.participant, msg.content, metadata, { placement });
+                const id = this.addMessage(msg.participant, localInput ? markNoticeOpenings(msg.content) : msg.content, metadata, { placement });
                 if (response.addMessages.length === 1 && !surface && !namesChannel && metadata?.channelId === undefined)
                     added = placement;
                 this.emitTrace({ type: 'message:added', messageId: id, source: event.type });
@@ -12816,6 +13070,7 @@ export class AgentFramework {
                 missedCharacters: typeof event.metadata?.missedCharacters === 'number'
                     ? event.metadata.missedCharacters
                     : undefined,
+                targetAgents: event.targetAgents,
             });
             if (invitation) {
                 incomingContent.push(invitation.block);
@@ -13397,11 +13652,6 @@ export class AgentFramework {
      * explicit-prose agent's natural plain reply bounced with nowhere to go
      * (Rhys's first portal mention: a 2,320-char reply stranded).
      *
-     * Wording: option 1 teaches the `>>` destination prefix, which delivers for
-     * BOTH legacy (host-inferred) and explicit prose-routing agents. The
-     * previous "simply write your reply as normal text" was a false promise
-     * under explicit routing (the metadata flags it set had no consumers).
-     *
      * Human-readable names wherever the surface provided them — a mind reading
      * this should see WHO addressed it WHERE, not a wall of snowflake ids. Raw
      * ids remain only inside the tool-argument instructions, where they are the
@@ -13460,8 +13710,11 @@ export class AgentFramework {
         // only where the name lacks one, by proseTargetFor's rule.
         const bareLabel = label && label !== opts.channelId ? label.replace(/^#/, '') : undefined;
         const hashLabel = bareLabel ? `#${bareLabel}` : undefined;
-        const channelLabel = hashLabel ?? `"${opts.channelId}"`;
-        const place = opts.guildName ? `${channelLabel} in "${opts.guildName}"` : channelLabel;
+        const channelId = quotedValue(opts.channelId);
+        const messageId = quotedValue(opts.messageId);
+        const authorName = suppliedValue(opts.authorName);
+        const channelLabel = hashLabel ? suppliedValue(hashLabel) : channelId;
+        const place = opts.guildName ? `${channelLabel} in "${suppliedValue(opts.guildName)}"` : channelLabel;
         // The label is for reading; the prefix must be ONE token that resolves back
         // here, on this server (a DM label "DM: alice" quoted verbatim parses as
         // target "#DM:"). A registry that can name targets is authoritative: no safe
@@ -13470,7 +13723,7 @@ export class AgentFramework {
         const namer = this.channelRegistry;
         const target = typeof namer.proseTargetFor === 'function'
             ? namer.proseTargetFor(channel)
-            : [hashLabel, opts.channelId].find((t) => !!t && isProseTargetToken(t));
+            : [hashLabel, opts.channelId].find((t) => !!t && isProseTargetToken(t) && showsAsItself(t));
         const inboundOnlyServer = this.channelRegistry.inboundOnlyServer(channel);
         // What replying does here is the registry's to say (speechOpens): a reply
         // opens a channel nobody decided to keep closed, and leaves one the agent
@@ -13480,23 +13733,39 @@ export class AgentFramework {
         const replyOpens = this.channelRegistry.speechOpens(channel);
         // The decline is the way to reply without opening a channel, except in a
         // tuned-out one, which channel_decline refuses: the tune-out ends first.
-        const withoutOpening = this.channelRegistry.getDesiredState(opts.serverId, opts.channelId) === 'tuned-out'
+        const tunedOut = this.channelRegistry.getDesiredState(opts.serverId, opts.channelId) === 'tuned-out';
+        const withoutOpening = tunedOut
             ? ''
             : " To reply without opening it, decline it first (option 3): a channel you've declined stays closed when you speak there.";
+        const named = [...new Set(opts.targetAgents ?? [])].filter((name) => this.agents.has(name));
+        const woken = named.length === 1 ? this.agents.get(named[0]) : undefined;
+        const mode = (woken ?? this.deliveryAgent())?.proseRouting ?? 'locus';
+        const prefix = mode === 'hybrid' ? '>>>' : '>>';
+        const delivered = replyOpens
+            ? `it will be delivered there, which opens the channel.${withoutOpening}`
+            : 'it will be delivered there, and the channel stays closed.';
+        const sendTool = `check whether ${opts.serverId} exposes a send tool that can address it`;
+        const plainSpeechRule = `your plain speech lands where the latest word on where it lands says: ` +
+            `a [${NOTICE_TAG.routing}] notice, or channel_open's result. If that is ${this.channelShown(channel)}, ` +
+            `write your reply with no prefix;`;
         const replyOption = inboundOnlyServer
             ? `1. Replying there isn't available: ${inboundOnlyServer} declared this channel inbound-only, so nothing ` +
                 `you write is posted into it. To speak there, use ${inboundOnlyServer}'s own tools.\n`
-            : target
-                ? replyOpens
-                    ? `1. Reply — write your reply this turn prefixed with ">>${target}"; it will be delivered there, which opens ` +
-                        `the channel.${withoutOpening}\n`
-                    : `1. Reply — write your reply this turn prefixed with ">>${target}"; it will be delivered there, and the ` +
-                        `channel stays closed.\n`
-                : `1. Reply — no single-word target reaches this channel unambiguously, ` +
-                    `so a ">>" prefix can't name it; check whether ${opts.serverId} exposes a send tool that can address it.` +
-                    (replyOpens
-                        ? ` Replying there opens the channel.${withoutOpening}\n`
-                        : ` Replying there leaves the channel closed.\n`);
+            : mode === 'disabled'
+                ? `1. Replying in plain text isn't available: your plain text is never published. To speak there, ${sendTool}.\n`
+                : mode === 'locus' && tunedOut
+                    ? `1. Reply — ${plainSpeechRule} it will be delivered there. If that is another channel, or you see none, to reply here, ` +
+                        `${sendTool}.\n`
+                    : mode === 'locus'
+                        ? `1. Reply — ${plainSpeechRule} ${delivered} If that is another channel, or you see none, to reply here, ` +
+                            `${sendTool}, or open it (option 2), whose result says where your plain speech lands.\n`
+                        : target
+                            ? `1. Reply — write your reply this turn prefixed with "${prefix}${target}"; ${delivered}\n`
+                            : `1. Reply — no single-word target reaches this channel unambiguously, ` +
+                                `so a "${prefix}" prefix can't name it; ${sendTool}.` +
+                                (replyOpens
+                                    ? ` Replying there opens the channel.${withoutOpening}\n`
+                                    : ` Replying there leaves the channel closed.\n`);
         const missedCount = opts.missedMessages ?? 0;
         const missedNote = missedCount > 0
             ? `While closed, ${missedCount} message${missedCount === 1 ? '' : 's'}` +
@@ -13505,18 +13774,18 @@ export class AgentFramework {
             : '';
         const block = {
             type: 'text',
-            text: `\n[Channel invitation] ${opts.authorName} addressed you in ${place} — ` +
+            text: `\n[${NOTICE_TAG.channelInvitation}] ${authorName} addressed you in ${place} — ` +
                 `a channel you haven't opened. Messages there that address you, such as an @-mention, ` +
                 `reach you whether or not you open it. ` +
                 missedNote +
                 `Your options:\n` +
                 replyOption +
-                `2. Open the channel — call channel_open with channelId "${opts.channelId}" and serverId "${opts.serverId}"` +
+                `2. Open the channel — call channel_open with channelId ${channelId} and serverId "${opts.serverId}"` +
                 (maxBackscroll > 0
-                    ? `; to also read recent history, add backscroll (a number up to ${maxBackscroll}) and beforeMessageId "${opts.messageId}".\n`
+                    ? `; to also read recent history, add backscroll (a number up to ${maxBackscroll}) and beforeMessageId ${messageId}.\n`
                     : `.\n`) +
-                `3. Stay out — call channel_decline with channelId "${opts.channelId}", serverId "${opts.serverId}", ` +
-                `and messageId "${opts.messageId}" (optionally set acknowledge to an emoji like 👀 so ${opts.authorName} isn't left hanging).\n` +
+                `3. Stay out — call channel_decline with channelId ${channelId}, serverId "${opts.serverId}", ` +
+                `and messageId ${messageId} (optionally set acknowledge to an emoji like 👀 so ${authorName} isn't left hanging).\n` +
                 `Doing nothing is also fine.`,
         };
         return {
@@ -14132,7 +14401,7 @@ export class AgentFramework {
                 messageId: identity.messageId ?? str(origin.messageId) ?? occ.eventId,
                 threadId: identity.threadId ?? str(origin.threadId),
                 author: identity.author ?? { id: str(origin.authorId) ?? '', name: str(origin.authorName) ?? str(origin.authorId) ?? 'Someone' },
-                content: materialized ? materialized.map((block) => convertBlock(block, 'attachment on push event', occ.serverId)) : push.content,
+                content: materialized ? convertBlocks(materialized, 'attachment on push event', occ.serverId) : push.content,
                 timestamp: occ.timestamp,
                 metadata: origin,
                 tags: push.tags,
@@ -14153,7 +14422,7 @@ export class AgentFramework {
             ...occ.event.event,
             eventId: occ.eventId,
             timestamp: occ.timestamp,
-            ...(materialized ? { content: materialized.map((block) => convertBlock(block, 'attachment on push event', occ.serverId)) } : {}),
+            ...(materialized ? { content: convertBlocks(materialized, 'attachment on push event', occ.serverId) } : {}),
             coalescingSubject,
             // §5.2: the materialized occurrence is consumed by the request being
             // assembled; the wake that started it is not repeated.
@@ -14290,21 +14559,13 @@ export class AgentFramework {
         // Every agent that can read this message must not have compiled past it.
         // Residents share one message slot, so a message one of them read is
         // history for all of them (the never-rewrite rule is about the message,
-        // not the agent that happened to be asked). A tune-out-diverted message
-        // never enters a resident's compiled view; only the subconscious reads
-        // it through its merged view — no subconscious, nobody reads it.
-        let readers;
-        if (message.metadata?.tuneOut) {
-            const subconscious = this.subconsciousAgentName ? this.agents.get(this.subconsciousAgentName) : undefined;
-            if (!subconscious)
-                return true;
-            readers = [subconscious];
-        }
-        else {
-            readers = this.sharedSlotAgents.has(agent)
-                ? [...this.sharedSlotAgents].filter((a) => this.agents.get(a.name) === a)
-                : [agent];
-        }
+        // not the agent that happened to be asked). A reader is one whose view
+        // filter keeps the message: a tune-out-diverted message never enters a
+        // resident's compiled view, and only the subconscious reads it through
+        // its merged view — no subconscious, nobody reads it.
+        const readers = (this.sharedSlotAgents.has(agent)
+            ? [...this.sharedSlotAgents].filter((a) => this.agents.get(a.name) === a)
+            : [agent]).filter((a) => this.agentSees(a, message.metadata));
         const branch = cm.currentBranch().name;
         const ts = message.timestamp instanceof Date ? message.timestamp.getTime() : Number(message.timestamp);
         for (const reader of readers) {
@@ -14442,6 +14703,7 @@ export class AgentFramework {
                 tags: event.tags,
                 missedMessages: typeof origin.missedMessages === 'number' ? origin.missedMessages : undefined,
                 missedCharacters: typeof origin.missedCharacters === 'number' ? origin.missedCharacters : undefined,
+                targetAgents: event.targetAgents,
             });
             if (invitation) {
                 content.push(invitation.block);
@@ -14661,7 +14923,8 @@ export class AgentFramework {
                 // A provider wait binds its own model; with a different primary model
                 // selected now, the turn proceeds (the wait stays recorded).
                 const otherModel = providerCooldown.waitModel !== undefined && providerCooldown.waitModel !== agent.model;
-                if (!otherModel && (now < providerCooldown.until || this.extendHostProviderHold(agentName, providerCooldown))) {
+                if (!otherModel && !providerCooldown.rearm
+                    && (now < providerCooldown.until || this.extendHostProviderHold(agentName, providerCooldown))) {
                     for (const req of requests)
                         this.holdRequest(providerCooldown.heldRequests, req);
                     const recovery = this.providerAccelerationRecoveries.get(agentName);
@@ -14674,6 +14937,10 @@ export class AgentFramework {
                 // the held causes into this one current compile.
                 clearTimeout(providerCooldown.timer);
                 this.providerAccelerationCooldowns.delete(agentName);
+                if (providerCooldown.rearm) {
+                    console.error(`[inference-rearm] agent=${agentName} turn queued again with a wake ` +
+                        `(${providerCooldown.rearm.number} of ${providerCooldown.rearm.of})`);
+                }
                 const recovery = this.providerAccelerationRecoveries.get(agentName);
                 if (recovery)
                     recovery.releasedAt = now;
@@ -14754,7 +15021,10 @@ export class AgentFramework {
                     // and a wake for a deferred write or a stored message is dropped
                     // once the agent is done with that write: neither may absorb an
                     // unrelated wake that would vanish with it.
-                    const key = `${request.reason}|${request.addressed ? 'a' : 'n'}|${request.coalescingSubject ?? ''}|${request.readsDeferredWrite ?? ''}|${request.readsStoredMessage ?? ''}`;
+                    // 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.readsDeferredWrite ?? ''}|${request.readsStoredMessage ?? ''}`;
                     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
@@ -14955,13 +15225,14 @@ export class AgentFramework {
             //      an open channel — legacy last-inbound semantics).
             // A chat:system notice (RFC-001 rev 3: weather in a world, someone
             // joining) names no channel at all: nobody spoke there, so a turn it
-            // wakes alone takes the global fallback, as a heartbeat does, and the
-            // agent sends there explicitly if it means to.
+            // wakes alone takes the global fallback, and the agent sends there
+            // explicitly if it means to.
             // Ambient chatter must not outrank an addressed message just by being
             // newest (2026-07-21 Cairn lounge misroute, turn-start variant).
             // Non-channel wakes (heartbeats, module events, reactions — which never
             // carry channelId) leave both undefined → global fallback, which an
-            // ephemeral run never takes (takesGlobalFallback).
+            // ephemeral run never takes (takesGlobalFallback), except a heartbeat's
+            // turn, which takes none (heartbeatTurn below).
             // Track the winning REQUEST, not just its channel: channel, addressed
             // and counterparty must come from the same message, or a batch of
             // "ambient from A, then addressed from B" would report B's channel
@@ -15042,6 +15313,9 @@ export class AgentFramework {
                 wakeLines: mergeWakeLines(requests),
                 suppressProse: silentOnly ? trigger?.suppressProse : undefined,
                 silentHeartbeat: silentOnly ? trigger?.silentHeartbeat : undefined,
+                // A heartbeat's turn when any cause is a heartbeat's wake and none
+                // names a channel, whatever the batch's order (isHeartbeatWake).
+                heartbeatTurn: !channelReq && requests.some((r) => isHeartbeatWake(r)),
                 // The channel and its server from the one request, so the turn's
                 // channel is that message's, never one server's id with another's.
                 channelId: channelReq?.channelId,
@@ -15070,6 +15344,10 @@ export class AgentFramework {
                 start[TURN_CARRY] = carry;
             else
                 delete start[TURN_CARRY];
+            if (requests.every(isRearmed))
+                start[REARMED] = true;
+            else
+                delete start[REARMED];
             // A start that carries a turn on and took in wakes that don't records
             // the batch it was merged from (MERGED_BATCH): until it takes its
             // token it stands for them all.
@@ -15291,7 +15569,7 @@ export class AgentFramework {
         if (hold.kind === 'place') {
             const { place } = hold;
             const where = this.channelShown(place.to);
-            return `your ${place.tool} ${said(place.round)} ${place.delivered ? 'delivered' : 'may have posted'} to ${where}, ` +
+            return `your ${suppliedValue(place.tool)} ${said(place.round)} ${place.delivered ? 'delivered' : 'may have posted'} to ${where}, ` +
                 `where this was going${lasts(place.round, true)}`;
         }
         const why = hold.why === 'error'
@@ -15304,7 +15582,7 @@ export class AgentFramework {
                         ? "it hadn't answered when this speech was routed"
                         : "it hadn't answered by the end of its round";
         const going = target ? `, and this was going to ${this.channelShown(target)}` : '';
-        return `the framework can't tell ${hold.why === 'error' || hold.why === 'no-answer' ? 'whether or where' : 'where'} your ${hold.tool} ${said(hold.round)} posted (${why})${going}${lasts(hold.round, false)}`;
+        return `the framework can't tell ${hold.why === 'error' || hold.why === 'no-answer' ? 'whether or where' : 'where'} your ${suppliedValue(hold.tool)} ${said(hold.round)} posted (${why})${going}${lasts(hold.round, false)}`;
     }
     /**
      * Hold plain speech as drafts (src/prose-drafts.ts) instead of
@@ -15378,7 +15656,7 @@ export class AgentFramework {
             const r = registry.resolveProseTarget(name, { forSpeech: true, own });
             return 'channelId' in r && sameChannel(r, target) ? name : undefined;
         };
-        const destination = JSON.stringify((target && (resent(registry?.proseTargetFor(target)) ?? resent(qualifiedChannelName(target)))) ?? '#channel');
+        const destination = quotedValue((target && (resent(registry?.proseTargetFor(target)) ?? resent(qualifiedChannelName(target)))) ?? NO_CHANNEL_EXAMPLE);
         // Words copied from a draft that may already have been posted resend
         // only with the resident's confirmation; the rest resend freely.
         const free = held.filter((d) => draftState(d) !== 'unconfirmed');
@@ -15393,7 +15671,7 @@ export class AgentFramework {
         ];
         // Named: residents that share one message slot (#197) share this window.
         // "Not sent" only when no copied words may already have been posted.
-        return (`[drafts] ${agentName}: ${risky.length > 0 ? '' : 'not sent — '}` +
+        return (`[${NOTICE_TAG.drafts}] ${agentName}: ${risky.length > 0 ? '' : 'not sent — '}` +
             `${many ? `${held.length} plain-speech segments` : 'a plain-speech segment'} ` +
             `held as draft${many ? 's' : ''} ${ids.join(', ')} — ${because ? `because ${because}` : AgentFramework.DRAFT_REASON_TEXT[reason]}. ` +
             `${resend.join('; ')}; drafts(action: "dismiss", draftIds: [${quoted(held)}]) sets ${many ? 'them' : 'it'} aside.`);
@@ -15410,8 +15688,9 @@ export class AgentFramework {
     /** A destination as the agent is shown it: its label, with its name as
      *  ChannelRegistry.nameShown gives it. */
     destinationText(d) {
-        const label = d.label && d.label !== d.channelId ? `${d.label.startsWith('#') || d.label.startsWith('DM') ? d.label : `#${d.label}`} ` : '';
-        return `${label}(${this.channelRegistry?.nameShown(d) ?? d.channelId})`;
+        const shown = d.label && d.label !== d.channelId ? suppliedValue(d.label) : '';
+        const label = shown ? `${shown.startsWith('#') || shown.startsWith('DM') ? '' : '#'}${shown} ` : '';
+        return `${label}(${this.channelRegistry?.nameShown(d) ?? suppliedValue(d.channelId)})`;
     }
     /** One line per draft: id, state, when, why, size, preview. */
     draftLine(draft) {
@@ -15441,7 +15720,7 @@ export class AgentFramework {
         const risky = uncertainAttempt(draft);
         if (risky) {
             return `${draft.id}'s attempt to ${this.destinationText(risky.destination)} at ` +
-                `${this.draftTime(risky.at)} may already have been posted: ${risky.outcome?.reason ?? this.noOutcomeText(draft, risky)}`;
+                `${this.draftTime(risky.at)} may already have been posted: ${risky.outcome?.reason !== undefined ? suppliedValue(risky.outcome.reason) : this.noOutcomeText(draft, risky)}`;
         }
         const inherited = draft.inheritedRisk;
         const owner = inherited.sourceDraftId ?? inherited.draftId;
@@ -15450,7 +15729,7 @@ export class AgentFramework {
             ? `${owner}'s attempt to ${this.destinationText(inherited.destination)}` +
                 (inherited.at !== undefined ? ` at ${this.draftTime(inherited.at)}` : '')
             : owner;
-        return `${draft.id} includes the words of ${inherited.draftId}${via}, and ${where} may already have been posted: ${inherited.reason}`;
+        return `${draft.id} includes the words of ${inherited.draftId}${via}, and ${where} may already have been posted: ${suppliedValue(inherited.reason)}`;
     }
     /** Whether an attempt with no outcome is still out: its draft's latest,
      *  while that draft is being sent. Otherwise it never got one (a crash). */
@@ -15469,7 +15748,7 @@ export class AgentFramework {
             return `${draft.id}: not delivered`;
         return `${draft.id}: delivered — confirmed at ${this.draftTime(delivered.outcome.at)} to ` +
             `${this.destinationText(delivered.destination)}` +
-            (delivered.outcome.messageId ? `, message ${delivered.outcome.messageId}` : '') +
+            (delivered.outcome.messageId ? `, message ${nameToTypeBack(delivered.outcome.messageId)}` : '') +
             ' (a record of that delivery, not a check that the message is still there)';
     }
     /**
@@ -15514,7 +15793,7 @@ export class AgentFramework {
         const shown = pending.slice(0, 8).map((d) => `${d.id} (${this.draftStateText(d)}; ${AgentFramework.DRAFT_REASON_SHORT[d.reason]})`);
         const rest = pending.slice(shown.length).map((d) => d.id);
         const more = rest.length > 0 ? ` · and ${rest.length} more: ${rest.join(', ')}` : '';
-        const text = `[drafts] ${agent.name}: ${pending.length === 1 ? 'an open draft' : `${pending.length} open drafts`} of yours ` +
+        const text = `[${NOTICE_TAG.drafts}] ${agent.name}: ${pending.length === 1 ? 'an open draft' : `${pending.length} open drafts`} of yours ` +
             `that no recent notice on this branch names: ${shown.join(' · ')}${more}. ` +
             'drafts(action: "list") shows your open drafts; resend or dismiss them by id.';
         let mid;
@@ -15751,17 +16030,17 @@ export class AgentFramework {
             const blocks = drafts.map((d) => {
                 const lines = [
                     `${d.id} — ${draftState(d)}; held ${this.draftTime(d.heldAt)} (${AgentFramework.DRAFT_REASON_TEXT[d.reason]})` +
-                        (d.note ? `; ${d.note}` : ''),
+                        (d.note ? `; ${suppliedValue(d.note)}` : ''),
                     ...(d.inheritedRisk && draftState(d) === 'unconfirmed' && !uncertainAttempt(d) ? [`  ${this.riskText(d)}`] : []),
                     ...d.attempts.map((a) => {
                         const o = a.outcome;
                         const status = !o
                             ? (this.attemptIsOut(d, a) ? 'being sent right now — no outcome yet' : 'outcome never recorded — it may have been posted')
                             : o.status === 'delivered'
-                                ? `delivered${o.messageId ? `, message ${o.messageId}` : ''}`
+                                ? `delivered${o.messageId ? `, message ${nameToTypeBack(o.messageId)}` : ''}`
                                 : o.status === 'unknown'
-                                    ? `UNKNOWN — may have been posted: ${o.reason ?? 'no valid receipt'}`
-                                    : `failed, nothing posted: ${o.reason ?? 'refused'}`;
+                                    ? `UNKNOWN — may have been posted: ${o.reason !== undefined ? suppliedValue(o.reason) : 'no valid receipt'}`
+                                    : `failed, nothing posted: ${o.reason !== undefined ? suppliedValue(o.reason) : 'refused'}`;
                         return `  attempt ${this.draftTime(a.at)} → ${this.destinationText(a.destination)}: ${status}` +
                             (o?.status === 'unknown' && o.detail !== undefined ? `; connector detail: ${connectorText(o.detail)}` : '') +
                             (a.confirmedDuplicate ? ' (resent knowing it might duplicate)' : '');
@@ -15854,8 +16133,10 @@ export class AgentFramework {
             // its turn a name the turn's own channel answers to means that channel.
             const resolved = registry.resolveProseTarget(spec, { forSpeech: true, own });
             if ('error' in resolved) {
-                const cand = resolved.candidates?.length ? ` It could mean: ${resolved.candidates.join(', ')}.` : '';
-                return refuse(`Destination "${spec}" did not resolve: ${resolved.error}.${cand} Nothing was sent.`);
+                const cand = resolved.candidates?.length
+                    ? ` It could mean: ${resolved.candidates.join(', ')}.${registry.publishRouteFor(resolved.candidates) ?? ''}`
+                    : '';
+                return refuse(`Destination "${spec}" did not resolve: ${suppliedValue(resolved.error)}.${cand} Nothing was sent.`);
             }
             named = resolved;
         }
@@ -15863,9 +16144,9 @@ export class AgentFramework {
             named = home;
         }
         const target = registry.resolveDestination({ serverId: named.serverId, channelId: named.channelId });
-        // Channels named as the agent names them back (nameShown).
+        // Channels named as the agent names them back (quotedShown).
         if ('error' in target)
-            return refuse(`Destination "${spec || registry.nameShown(home)}": ${target.error}. Nothing was sent.`);
+            return refuse(`Destination ${spec ? `"${spec}"` : registry.quotedShown(home)}: ${suppliedValue(target.error)}. Nothing was sent.`);
         const destination = target.destination;
         if (home && !sameChannel(destination, home)) {
             return refuse(`This conversation is bound to channel ${registry.quotedShown(home)}; resending to ${registry.quotedShown(destination)} ` +
@@ -15954,7 +16235,7 @@ export class AgentFramework {
                 // it, so say what the draft reads as now rather than guess.
                 const unrecorded = recorded ? '' : ` (recording this outcome failed; the draft reads as ${this.draftStateNow(agentName, d.id)} now)`;
                 if (outcome.status === 'delivered') {
-                    lines.push(`${d.id}: delivered to ${where}${outcome.messageId ? `, message ${outcome.messageId}` : ''}${unrecorded}.`);
+                    lines.push(`${d.id}: delivered to ${where}${outcome.messageId ? `, message ${nameToTypeBack(outcome.messageId)}` : ''}${unrecorded}.`);
                     sendingTurn?.engaged.add(destinationKey(destination));
                     resender?.notePublished(destinationKey(destination), readThrough);
                     continue;
@@ -15965,9 +16246,9 @@ export class AgentFramework {
                 // The connector's data may say what a multi-part send already posted.
                 const detail = outcome.status === 'unknown' && outcome.detail !== undefined ? ` Connector detail: ${connectorText(outcome.detail)}` : '';
                 lines.push((outcome.status === 'unknown'
-                    ? `${d.id}: delivery to ${where} NOT confirmed — it may or may not have been posted: ${outcome.reason ?? 'no valid receipt'}. ` +
+                    ? `${d.id}: delivery to ${where} NOT confirmed — it may or may not have been posted: ${outcome.reason !== undefined ? suppliedValue(outcome.reason) : 'no valid receipt'}. ` +
                         `Sending it again could post it twice, so a resend needs confirmDuplicate: true${unrecorded}.`
-                    : `${d.id}: not sent to ${where} — ${outcome.reason ?? 'refused'}. Nothing was posted by this attempt${unrecorded}.` +
+                    : `${d.id}: not sent to ${where} — ${outcome.reason !== undefined ? suppliedValue(outcome.reason) : 'refused'}. Nothing was posted by this attempt${unrecorded}.` +
                         (stillAtRisk
                             ? ` The draft stays unconfirmed: ${this.riskText(after)}.`
                             : ' The draft stays held.')) + detail);
@@ -15993,6 +16274,37 @@ export class AgentFramework {
         }
         return undefined;
     }
+    /** Why a heartbeat's turn holds its plain speech, in a held-draft notice ("because …"). */
+    static HEARTBEAT_HOLD_BECAUSE = 'this turn came from your heartbeat, not from a channel, so its plain speech has no destination ' +
+        'and is kept for you to send where you choose';
+    /**
+     * Locus mode's delivery of plain speech to the turn's frozen locus. A
+     * heartbeat's turn with no locus of its own (TurnRouting.heartbeat) holds
+     * the words as a draft instead of failing the delivery: nobody was waiting
+     * for them, and the agent may send them where it chooses.
+     */
+    async routeLocusSpeech(agent, round, text, locus) {
+        if (locus === null && round.routing.heartbeat) {
+            this.holdHeartbeatProse(agent, [text], round);
+            return null;
+        }
+        return this.channelRegistry.routeSpeech(agent.name, text, locus);
+    }
+    /** The mark a framework wake takes from a heartbeat's turn with no locus
+     *  of its own (InferenceRequest.heartbeatTurn), so the turn it opens is a
+     *  heartbeat's too; nothing for any other turn. */
+    heartbeatTurnMark(routing) {
+        return routing.heartbeat && !routing.locus ? { heartbeatTurn: true } : {};
+    }
+    /** 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)`);
+        return this.holdProseDrafts(agent, texts, 'no-destination', {
+            routing: round.routing,
+            notice: round.draftsRound ? 'later' : round.notice,
+            because: AgentFramework.HEARTBEAT_HOLD_BECAUSE,
+        });
+    }
     /** Record a successful plain-prose delivery for this turn's receipt. */
     recordProseDelivery(routing, outcome) {
         if (!outcome?.delivered)
@@ -16120,10 +16432,10 @@ export class AgentFramework {
         // reports itself in its tool result. Disabled mode holds no drafts, so
         // it is never uncertain.
         const text = shown.length > 0
-            ? `[delivered] plain speech → ${shown.join(' · ')}${suppressedNote ? ` · ${suppressedNote}` : ''}${closedNote}`
+            ? `[${NOTICE_TAG.delivered}] plain speech → ${shown.join(' · ')}${suppressedNote ? ` · ${suppressedNote}` : ''}${closedNote}`
             : agent.proseRouting === 'disabled'
-                ? `[delivered] plain speech → no channel — ${suppressedNote}`
-                : `[delivered] nothing${uncertain ? ' confirmed' : ''} — ${suppressedNote}`;
+                ? `[${NOTICE_TAG.delivered}] plain speech → no channel — ${suppressedNote}`
+                : `[${NOTICE_TAG.delivered}] nothing${uncertain ? ' confirmed' : ''} — ${suppressedNote}`;
         try {
             const mid = agent.getContextManager().addMessage('user', [{ type: 'text', text }], {
                 system: true,
@@ -16142,7 +16454,7 @@ export class AgentFramework {
         try {
             agent.getContextManager().addMessage('user', [{
                     type: 'text',
-                    text: `[speech-not-posted] Nothing you wrote before your tool calls in the rounds just above was posted. ` +
+                    text: `[${NOTICE_TAG.speechNotPosted}] Nothing you wrote before your tool calls in the rounds just above was posted. ` +
                         `If any of it should go out, send it again.`,
                 }], { system: true, kind: 'speech-not-posted' });
             delete routing.unpostedSpeech;
@@ -16153,7 +16465,7 @@ export class AgentFramework {
     }
     noteFailedTurnEnd(agent, routing) {
         const callsCutOff = (routing.unflushedRounds ?? 0) > 0;
-        if (routing.roundsRan || callsCutOff) {
+        if (gotPartway(routing)) {
             this.exhaustedTurns?.set(agent.name, {
                 roundsRan: routing.roundsRan === true, callsCutOff, liveSpeech: routing.liveSpeech === true,
                 speechRouting: (routing.speechRouting ?? 0) > 0,
@@ -16187,12 +16499,32 @@ export class AgentFramework {
         if (!target)
             return;
         try {
-            this.addMessage('user', [{ type: 'text', text: `[closed channel] ${notes.join(' ')}${this.closedChannelNoteOff(agent.name)}` }], { system: true, kind: 'delivery-receipt' }, target);
+            this.addMessage('user', [{ type: 'text', text: `[${NOTICE_TAG.closedChannel}] ${notes.join(' ')}${this.closedChannelNoteOff(agent.name)}` }], { system: true, kind: 'delivery-receipt' }, target);
         }
         catch (err) {
             console.error('closed-channel note append failed:', err);
         }
     }
+    /**
+     * Tell a heartbeat's turn, before it compiles, that its plain speech has
+     * no destination (TurnRouting.heartbeat): the last `[routing]` notice may
+     * name a channel, and this turn's words won't go there. It leaves the
+     * announced baseline alone (announceLocusIfChanged).
+     */
+    noticeHeartbeatTurn(agentName) {
+        const agent = this.agents.get(agentName);
+        if (!agent)
+            return;
+        const text = `[${NOTICE_TAG.routing}] This turn came from your heartbeat, not from a channel, so plain speech here isn't posted: ` +
+            'it\'s held as a draft you can send with the drafts tool. An explicit send reaches a channel now.';
+        try {
+            const id = agent.getContextManager().addMessage('user', [{ type: 'text', text }], { system: true, kind: 'routing-notice' });
+            this.emitTrace({ type: 'message:added', messageId: id, source: 'routing-notice' });
+        }
+        catch (err) {
+            console.error('noticeHeartbeatTurn: failed to record the notice:', err);
+        }
+    }
     /**
      * Announce-on-change locus notice (turn-frozen routing). Appends a durable
      * `[routing]` window message when the turn's effective outbound locus
@@ -16217,16 +16549,16 @@ export class AgentFramework {
         let text;
         if (locus === null) {
             text =
-                '[routing] Your plain speech currently has no channel — it stays in ' +
+                `[${NOTICE_TAG.routing}] Your plain speech currently has no channel — it stays in ` +
                     'your archive. Use an explicit send tool to reach a channel.';
         }
         else {
             const shown = this.channelShown(locus);
             const inboundOnlyServer = this.channelRegistry?.inboundOnlyServer(locus);
             text = inboundOnlyServer
-                ? `[routing] The conversation is now in ${shown}. ${inboundOnlySpeechNote(inboundOnlyServer)} ` +
+                ? `[${NOTICE_TAG.routing}] The conversation is now in ${shown}. ${inboundOnlySpeechNote(inboundOnlyServer)} ` +
                     'Other channels need an explicit send tool.'
-                : `[routing] Your plain speech now lands in ${shown}. ` +
+                : `[${NOTICE_TAG.routing}] Your plain speech now lands in ${shown}. ` +
                     'Other channels need an explicit send tool.';
         }
         try {
@@ -16499,18 +16831,23 @@ export class AgentFramework {
         }
         return { newestRowAt, lastClockAt: undefined };
     }
+    agentSees(agent, metadata) {
+        const sees = this.storeSees.get(agent.getContextManager());
+        return !sees || sees(metadata);
+    }
     /**
      * Weigh a message that no tool boundary of the agent's open logical turn
      * will weigh: one that would re-pin the locus becomes one of the turn's
-     * arrivals (TurnRouting.arrivals). A message tune-out diverted
-     * (metadata.tuneOut) never enters a resident's compiled view, so the agent
-     * won't see it, and it moves nothing.
+     * arrivals (TurnRouting.arrivals). A message the agent's own view leaves
+     * out, such as one a tune-out diverted (metadata.tuneOut), never enters
+     * its compiled view, so the agent won't see it, and it moves nothing.
      */
     noteArrival(agentName, metadata, messageId) {
         const open = this.openLogical.get(agentName);
         if (!open)
             return;
-        if (metadata?.tuneOut)
+        const agent = this.agents.get(agentName);
+        if (agent && !this.agentSees(agent, metadata))
             return;
         if (isConversationalInjection(metadata))
             (open.heard ??= new Map()).set(messageId, ++lastHeardAt);
@@ -16538,6 +16875,7 @@ export class AgentFramework {
             return;
         for (const reader of this.sharedSlotAgents) {
             if (reader !== agent && this.agents.get(reader.name) === reader && this.isOrdinaryResident(reader)) {
+                this.noteSpokenTo(reader.name, metadata);
                 this.noteArrival(reader.name, metadata, messageId);
             }
         }
@@ -16604,9 +16942,9 @@ export class AgentFramework {
         const content = [{
                 type: 'text',
                 text: inboundOnlyServer
-                    ? `[routing] The conversation moved to ${shown}. ${inboundOnlySpeechNote(inboundOnlyServer)} ` +
+                    ? `[${NOTICE_TAG.routing}] The conversation moved to ${shown}. ${inboundOnlySpeechNote(inboundOnlyServer)} ` +
                         'Other channels need an explicit send tool.'
-                    : `[routing] The conversation moved to ${shown} — your plain ` +
+                    : `[${NOTICE_TAG.routing}] The conversation moved to ${shown} — your plain ` +
                         'speech now lands there for the rest of this turn. Other ' +
                         'channels need an explicit send tool.',
             }];
@@ -16742,7 +17080,7 @@ export class AgentFramework {
             }
             const sender = this.agentForPrimary(agentName);
             return [{
-                    text: `[channels] Now open: ${shown}: a message from ${sender.first} into the closed channel opened it; ${sender.again} has ended.` +
+                    text: `[${NOTICE_TAG.channels}] Now open: ${shown}: a message from ${sender.first} into the closed channel opened it; ${sender.again} has ended.` +
                         optOut(this.holdsChannelTraffic(primary, refs), this.canCloseChannels(primary, refs)),
                     metadata: { system: true, kind: 'channel-notice', speaker: agentName },
                     told: `the primary, by name (${agentName} has ended)`,
@@ -16762,13 +17100,13 @@ export class AgentFramework {
         const tellPrimary = !!agentName && !canClose && primary !== undefined && this.agents.has(primary) &&
             this.canCloseChannels(primary, refs);
         const readerText = (told) => (cause === 'subscription-policy'
-            ? `[channels] Selected for opening by subscription policy: ${shown}. ` +
+            ? `[${NOTICE_TAG.channels}] Selected for opening by subscription policy: ${shown}. ` +
                 (plural
                     ? "The host opens them, and if one doesn't open, tries again when its server next registers it; " +
                         'channel_list shows whether each is open yet.'
                     : 'The host opens it, and if that fails, tries again when its server next registers it; ' +
                         "channel_list shows whether it's open yet.")
-            : `[channels] Now open: ${shown}: your own message into the closed channel opened it.`) +
+            : `[${NOTICE_TAG.channels}] Now open: ${shown}: your own message into the closed channel opened it.`) +
             optOut(this.holdsChannelTraffic(who, refs), canClose) + told;
         const reader = {
             text: readerText(tellPrimary ? ` ${this.primaryForReader(agentName, primary)} has been told and can close ${plural ? 'them' : 'it'}.` : ''),
@@ -16785,7 +17123,7 @@ export class AgentFramework {
         if (tellPrimary) {
             const sender = this.agentForPrimary(agentName);
             notices.push({
-                text: `[channels] Now open: ${shown}: a message from ${sender.first} into the closed channel opened it, and ${sender.again} can't close ${plural ? 'them' : 'it'}.` +
+                text: `[${NOTICE_TAG.channels}] Now open: ${shown}: a message from ${sender.first} into the closed channel opened it, and ${sender.again} can't close ${plural ? 'them' : 'it'}.` +
                     optOut(this.holdsChannelTraffic(primary, refs), true),
                 metadata: { system: true, kind: 'channel-notice', speaker: agentName },
                 told: `the primary, by name (${agentName} can't close ${plural ? 'them' : 'it'})`,
@@ -16967,7 +17305,7 @@ export class AgentFramework {
             primary !== undefined && this.agents.has(primary) &&
             this.canCloseChannels(primary, [{ serverId, channelId: channel.channelId }]);
         const sender = ended ? this.agentForPrimary(agentName) : undefined;
-        const readerText = (told) => `[channels] Not open: ${shown}. ` +
+        const readerText = (told) => `[${NOTICE_TAG.channels}] Not open: ${shown}. ` +
             (ended
                 ? `A reply from ${sender.first} went out there, but opening the channel failed; ${sender.again} has ended.`
                 : 'Your reply there went out, but opening the channel failed.') +
@@ -16994,7 +17332,7 @@ export class AgentFramework {
             const primaryCanOpen = !this.conversationAgentHomes.has(primary) && this.canAgentUseTool(primary, 'channel_open');
             const reader = this.agentForPrimary(who);
             notices.push({
-                text: `[channels] Not open: ${shown}. A reply from ${reader.first} went out there, but opening the channel failed, and ${reader.again} can't close it.` +
+                text: `[${NOTICE_TAG.channels}] Not open: ${shown}. A reply from ${reader.first} went out there, but opening the channel failed, and ${reader.again} can't close it.` +
                     selected + ', and channel_close withdraws that.' +
                     (primaryCanOpen && !hostRetries ? ' channel_open tries again.' : ''),
                 metadata: { system: true, kind: 'channel-notice', speaker: who },
@@ -17034,6 +17372,7 @@ export class AgentFramework {
             reason: 'prose-continuation',
             source: 'framework',
             timestamp: Date.now(),
+            ...this.heartbeatTurnMark(routing),
         });
     }
     /**
@@ -17102,7 +17441,7 @@ export class AgentFramework {
         }
         this.autoContinueStreaks.set(name, count);
         console.error(`[continue] ${name}: turn ended (${stopReason}) without skip_reply — continuation ${count} of ${config.maxConsecutive}` +
-            (routing.locus ? ` in ${this.channelRegistry?.nameShown(routing.locus) ?? routing.locus.channelId}` : ''));
+            (routing.locus ? ` in ${this.channelRegistry?.nameShown(routing.locus) ?? suppliedValue(routing.locus.channelId)}` : ''));
         // The next turn speaks where this one did (locus and hybrid modes): the
         // locus's server and id, as the framework's own wakes name a channel. A
         // turn that had no channel (noChannel: its wake named one that resolves
@@ -17120,6 +17459,7 @@ export class AgentFramework {
             timestamp: Date.now(),
             ...channel,
             autoContinueRun: { stop, ...(opts.heldAfterSend ? { heldAfterSend: true } : {}) },
+            ...this.heartbeatTurnMark(routing),
         });
     }
     /** How an autoContinue agent stops a run, as its `[continue]` row says it,
@@ -17140,11 +17480,12 @@ export class AgentFramework {
      * starts (startAgentStream), with the run's count as it stands and the
      * agent's cap. False when it couldn't be stored.
      */
-    writeAutoContinueNotice(agent, mark) {
+    writeAutoContinueNotice(agent, mark, heartbeat = false) {
         const count = this.autoContinueStreaks.get(agent.name) ?? 1;
         const max = agent.autoContinue?.maxConsecutive ?? count;
         const text = autoContinueNotice({
             agentName: agent.name, stop: mark.stop, last: count >= max, heldAfterSend: mark.heldAfterSend,
+            heartbeat,
         });
         const before = this.storedCountOf(agent);
         let id;
@@ -17341,7 +17682,7 @@ export class AgentFramework {
                 const target = this.noticeTargetFor(agent.name, 'empty-{{unsent}}');
                 try {
                     if (target)
-                        this.addMessage('user', [{ type: 'text', text: `[prose-routing] ${reason}, so nothing was sent. drafts(action: "list") shows your open drafts.` }], { system: true, kind: 'prose-bounce' }, target);
+                        this.addMessage('user', [{ type: 'text', text: `[${NOTICE_TAG.proseRouting}] ${reason}, so nothing was sent. drafts(action: "list") shows your open drafts.` }], { system: true, kind: 'prose-bounce' }, target);
                 }
                 catch (err) {
                     console.error('[drafts] empty-unsent notice failed:', err);
@@ -17363,7 +17704,7 @@ export class AgentFramework {
         else if (draftState(draft) === 'unconfirmed') {
             why = this.riskText(draft);
             next = 'sending that draft again could post it twice. To send it anyway, use ' +
-                `drafts(action: "resend", draftIds: ["${draft.id}"], destination: "#channel", confirmDuplicate: true)`;
+                `drafts(action: "resend", draftIds: ["${draft.id}"], destination: ${quotedValue(NO_CHANNEL_EXAMPLE)}, confirmDuplicate: true)`;
         }
         else {
             return { draft };
@@ -17381,7 +17722,7 @@ export class AgentFramework {
                 ? ` Your message is held as draft ${held.id}, with {{unsent}} written out; since it includes ${draft.id}'s words, it ` +
                     `can be resent only with confirmDuplicate: true${afterResult}.`
                 : ' Your message could not be held as a draft; its words remain in your history.';
-        const text = `[prose-routing] {{unsent}} is draft ${draft.id}, ${why.startsWith('which') ? why : `and ${why}`}. ` +
+        const text = `[${NOTICE_TAG.proseRouting}] {{unsent}} is draft ${draft.id}, ${why.startsWith('which') ? why : `and ${why}`}. ` +
             `Nothing was sent; ${next}.${kept}`;
         const target = this.noticeTargetFor(agent.name, 'refused-{{unsent}}');
         try {
@@ -17440,7 +17781,7 @@ export class AgentFramework {
             }
             catch (err) {
                 console.error(`[drafts] ${agent.name}: outcome of ${unsent.id} not recorded:`, err);
-                const text = `[prose-routing] {{unsent}} was draft ${unsent.id}; its send came back ${outcome.status}, but recording that ` +
+                const text = `[${NOTICE_TAG.proseRouting}] {{unsent}} was draft ${unsent.id}; its send came back ${outcome.status}, but recording that ` +
                     `failed, so the draft reads as ${this.draftStateNow(agent.name, unsent.id)} now. drafts(action: "read") shows it.`;
                 const target = this.noticeTargetFor(agent.name, 'unrecorded-outcome');
                 try {
@@ -17523,14 +17864,14 @@ export class AgentFramework {
                     // not bounced, so its words are not re-held as a fresh draft that
                     // invites a duplicate.
                     if (outcome.status === 'failed') {
-                        this.bounceProse(agent, parsed.body, `delivery to ${this.channelRegistry?.nameShown(resolved) ?? resolved.channelId} failed: ${outcome.reason ?? 'refused'}`, undefined, '>>>', round, { substituted: unsent.draft });
+                        this.bounceProse(agent, parsed.body, `delivery to ${this.channelRegistry?.nameShown(resolved) ?? suppliedValue(resolved.channelId)} failed: ${outcome.reason !== undefined ? suppliedValue(outcome.reason) : 'refused'}`, undefined, '>>>', round, { substituted: unsent.draft });
                     }
                 }
             }
             catch (err) {
                 delete routing.pin;
                 routing.hybridHold = 'failed';
-                this.bounceProse(agent, parsed.body, `sending to ${this.channelRegistry?.nameShown(resolved) ?? resolved.channelId} threw: ${err instanceof Error ? err.message : String(err)}`, undefined, '>>>', round, { substituted: unsent.draft, outcome: 'unknown' });
+                this.bounceProse(agent, parsed.body, `sending to ${this.channelRegistry?.nameShown(resolved) ?? suppliedValue(resolved.channelId)} threw: ${suppliedValue(err instanceof Error ? err.message : String(err))}`, undefined, '>>>', round, { substituted: unsent.draft, outcome: 'unknown' });
             }
             return;
         }
@@ -17549,6 +17890,10 @@ export class AgentFramework {
             this.holdProseDrafts(agent, [envelope], 'no-destination', round.draftsRound ? { ...round, notice: 'later' } : round);
             return;
         }
+        if (!sticky && locus === null && routing.heartbeat) {
+            this.holdHeartbeatProse(agent, [envelope], round);
+            return;
+        }
         const target = sticky ?? locus;
         try {
             const outcome = await this.channelRegistry.routeSpeech(agent.name, envelope, target);
@@ -17584,7 +17929,7 @@ export class AgentFramework {
             }
         };
         if (this.draftsSending.has(`${agent.name}\u0000${draft.id}`)) {
-            tell(`[prose-routing] {{unsent}} is draft ${draft.id}, which is being sent right now. It was not set aside, ` +
+            tell(`[${NOTICE_TAG.proseRouting}] {{unsent}} is draft ${draft.id}, which is being sent right now. It was not set aside, ` +
                 'since that can\'t call back words already on their way; wait for that result.', 'in-flight-dismiss');
             return;
         }
@@ -17601,13 +17946,13 @@ export class AgentFramework {
             if (now === 'dismissed')
                 this.emitTrace({ type: 'prose:drafts-dismissed', agentName: agent.name, draftIds: [draft.id] });
             const named = this.proseDrafts.latestBounce(agent.name)?.id === draft.id;
-            tell(`[prose-routing] Recording setting aside draft ${draft.id}, which {{unsent}} named, failed ` +
+            tell(`[${NOTICE_TAG.proseRouting}] Recording setting aside draft ${draft.id}, which {{unsent}} named, failed ` +
                 `(${err instanceof Error ? err.message : String(err)}): it reads as ${now} now, and {{unsent}} ` +
                 `${named ? 'still names it' : 'names nothing'}.${now === 'dismissed' && risk ? ` Note that ${risk}.` : ''}`, 'failed-dismiss');
             return;
         }
         if (risk)
-            tell(`[prose-routing] Draft ${draft.id} is set aside. Note that ${risk}.`, 'at-risk-dismiss');
+            tell(`[${NOTICE_TAG.proseRouting}] Draft ${draft.id} is set aside. Note that ${risk}.`, 'at-risk-dismiss');
     }
     async deliverProseEnvelope(agent, envelope, round) {
         const name = agent.name;
@@ -17669,12 +18014,12 @@ export class AgentFramework {
                     if (!('draft' in words)) {
                         const held = this.holdProseDrafts(agent, [{ text: words.text, ...(words.inheritedRisk ? { inheritedRisk: words.inheritedRisk } : {}) }], 'no-destination', { ...round, notice: 'later' });
                         if (held.length === 0 && words.text.trim().length > 0) {
-                            this.bounceProse(agent, rawText, 'no destination prefix, and this turn has no destination now', undefined, '>>', round);
+                            this.bounceProse(agent, rawText, 'no destination prefix, and this turn has no destination now', undefined, '>>', round, { unprefixed: true });
                         }
                     }
                     return;
                 }
-                this.bounceProse(agent, rawText, 'no destination prefix, and this turn has no destination now', undefined, '>>', round);
+                this.bounceProse(agent, rawText, 'no destination prefix, and this turn has no destination now', undefined, '>>', round, { unprefixed: true });
                 return;
             }
             targetChannel = sticky;
@@ -17706,11 +18051,11 @@ export class AgentFramework {
             else if (outcome.status === 'failed') {
                 // Unknown deliveries are marker-only: offering a fresh draft would
                 // invite a duplicate. Keep the authored body for the re-bounce rule.
-                this.bounceProse(agent, envelopeBody, `delivery to ${this.channelRegistry?.nameShown(targetChannel) ?? targetChannel.channelId} failed: ${outcome.reason ?? 'refused'}`, undefined, '>>', round, { substituted: unsent.draft });
+                this.bounceProse(agent, envelopeBody, `delivery to ${this.channelRegistry?.nameShown(targetChannel) ?? suppliedValue(targetChannel.channelId)} failed: ${outcome.reason !== undefined ? suppliedValue(outcome.reason) : 'refused'}`, undefined, '>>', round, { substituted: unsent.draft });
             }
         }
         catch (err) {
-            this.bounceProse(agent, envelopeBody, `sending to ${this.channelRegistry?.nameShown(targetChannel) ?? targetChannel.channelId} threw: ${err instanceof Error ? err.message : String(err)}`, undefined, '>>', round, { substituted: unsent.draft, outcome: 'unknown' });
+            this.bounceProse(agent, envelopeBody, `sending to ${this.channelRegistry?.nameShown(targetChannel) ?? suppliedValue(targetChannel.channelId)} threw: ${suppliedValue(err instanceof Error ? err.message : String(err))}`, undefined, '>>', round, { substituted: unsent.draft, outcome: 'unknown' });
         }
         if (!delivered && this.channelRegistry.inboundOnlyServer(targetChannel) !== undefined) {
             // The channel is inbound-only by now: its server declared it after the
@@ -17801,7 +18146,7 @@ export class AgentFramework {
             // Words with no draft behind them, whose send threw, may have gone
             // out. Like an unknown outcome, that is marker-only: holding them as a
             // draft would invite a duplicate post.
-            const notice = `[prose-routing] Your text (${text.length} chars) may not have been delivered — ${reason}. ` +
+            const notice = `[${NOTICE_TAG.proseRouting}] Your text (${text.length} chars) may not have been delivered — ${suppliedValue(reason)}. ` +
                 "It isn't held as a draft, since a resend could post it twice; the words remain in your history.";
             const target = this.noticeTargetFor(name, 'unknown-send');
             try {
@@ -17827,13 +18172,22 @@ export class AgentFramework {
             // The bounce notice below names the draft, so no separate held notice.
             draft = this.holdProseDrafts(agent, [{ text: words.text, ...(inherited ? { inheritedRisk: inherited } : {}) }], 'bounced', { routing: round.routing, note: reason, notice: 'later' })[0];
         }
-        const streak = (this.proseBounceStreaks.get(name) ?? 0) + 1;
-        this.proseBounceStreaks.set(name, streak);
-        const cand = candidates?.length ? ` Known channels it could mean: ${candidates.join(', ')}.` : '';
+        // A heartbeat's turn came from no channel: its bounce is noticed, and
+        // waits for the agent's next turn, rather than starting one of its own,
+        // so it neither wakes the agent nor counts toward the bounce-wake cap.
+        // Only words with no destination: a `>>` or `>>>` target that fails was
+        // meant for someone, and its bounce wakes the agent as any does.
+        const quiet = round.routing.heartbeat === true && after.unprefixed === true;
+        const streak = (this.proseBounceStreaks.get(name) ?? 0) + (quiet ? 0 : 1);
+        if (!quiet)
+            this.proseBounceStreaks.set(name, streak);
+        const cand = candidates?.length
+            ? ` Known channels it could mean: ${candidates.map(suppliedValue).join(', ')}.${this.channelRegistry?.publishRouteFor(candidates) ?? ''}`
+            : '';
         // The examples name the first candidate that is one token, as a target
-        // takes it, so they show the form to write, such as a server-qualified
-        // `a:general`; with none, a generic `#channel`.
-        const example = candidates?.find(isProseTargetToken) ?? '#channel';
+        // takes it, and shows as itself, so they show the form to write, such as a server-qualified
+        // `a:general`; with none, the generic `#<channel>`.
+        const example = candidates?.find((c) => isProseTargetToken(c) && showsAsItself(c)) ?? NO_CHANNEL_EXAMPLE;
         // A bare {{unsent}} whose send failed re-bounces the draft it sent, which
         // a later bounce may have displaced as the latest; and {{unsent}} refuses
         // a draft that may already have been posted. Then only the drafts tool
@@ -17844,11 +18198,11 @@ export class AgentFramework {
             ? 'It could not be held as a draft; the words remain in your history.'
             : byToken
                 ? `It is held as draft ${draft.id}; nothing is lost. To deliver it unchanged, reply with a destination plus the ` +
-                    `token {{unsent}}, e.g. "${prefix}${example} {{unsent}}" or "${prefix}@person {{unsent}}", or use ` +
-                    `drafts(action: "resend", draftIds: ["${draft.id}"], destination: "${example}"). ` +
+                    `token {{unsent}}, e.g. "${prefix}${example} {{unsent}}" or "${prefix}${NO_PERSON_EXAMPLE} {{unsent}}", or use ` +
+                    `drafts(action: "resend", draftIds: ["${draft.id}"], destination: ${quotedValue(example)}). ` +
                     `"${prefix}skip_reply {{unsent}}" sets it aside.`
                 : `It is held as draft ${draft.id}; nothing is lost. To deliver it unchanged, use ` +
-                    `drafts(action: "resend", draftIds: ["${draft.id}"], destination: "${example}"` +
+                    `drafts(action: "resend", draftIds: ["${draft.id}"], destination: ${quotedValue(example)}` +
                     `${inherited || ownRisk ? ', confirmDuplicate: true' : ''}); ` +
                     `drafts(action: "dismiss", draftIds: ["${draft.id}"]) sets it aside.`;
         const risky = inherited && draft
@@ -17863,7 +18217,7 @@ export class AgentFramework {
         // A send that threw has no known outcome: the notice doesn't say it
         // wasn't delivered.
         const delivered = after.outcome === 'unknown' ? 'may not have been delivered' : 'was not delivered';
-        const notice = `[prose-routing] Your text (${text.length} chars) ${delivered} — ${reason}.${cand} ${kept}${risky}` +
+        const notice = `[${NOTICE_TAG.proseRouting}] Your text (${text.length} chars) ${delivered} — ${suppliedValue(reason)}.${cand} ${kept}${risky}` +
             (prefix === '>>' && this.canAgentUseTool(agent.name, 'prose_help') ? ' The prose_help tool shows the full syntax.' : '');
         const target = this.noticeTargetFor(name, 'prose-bounce');
         if (target) {
@@ -17887,8 +18241,8 @@ export class AgentFramework {
         }
         const capped = streak > AgentFramework.PROSE_BOUNCE_WAKE_CAP;
         console.error(`[prose] ${name}: BOUNCED ${text.length} chars — ${reason}` +
-            (capped ? ' (bounce-wake cap reached; notice appended without wake)' : ''));
-        if (!capped && target) {
+            (quiet ? ' (a heartbeat turn: notice appended without wake)' : capped ? ' (bounce-wake cap reached; notice appended without wake)' : ''));
+        if (!capped && !quiet && target) {
             // Wake so the resend can happen immediately — an unsent DM reply must
             // not sit invisible until the next unrelated event.
             this.pendingRequests.push({
@@ -17896,6 +18250,7 @@ export class AgentFramework {
                 reason: 'prose-bounce',
                 source: 'framework',
                 timestamp: Date.now(),
+                ...this.heartbeatTurnMark(round.routing),
             });
         }
     }
@@ -18105,6 +18460,7 @@ export class AgentFramework {
                     stopReason: 'exhausted', speech: '', error: error instanceof Error ? error.message : String(error),
                 }, this.openLogical.get(agent.name));
             }
+            this.endStatedWaitRun(agent.name);
             // The agent's window at the event gate ends here too, while this start
             // still holds the turn token, as at the provider-wait hold above. A
             // start that resumes a turn (a budget restart, a tool-result-guard
@@ -18602,13 +18958,16 @@ export class AgentFramework {
         // without the mark, so a retry doesn't write it again. A row that can't
         // be stored gives back the run's count, and withdraws a turn the
         // continuation alone caused: it would wake to nothing it can read.
+        // A framework wake that continues a heartbeat's turn (heartbeatTurn) is
+        // one too, and isn't told again what the turn that started the run was.
+        const continuesHeartbeat = trigger?.heartbeatTurn === true && trigger.source === 'framework';
         if (attempt === 0 && !resumesTurn && trigger?.autoContinueRun) {
             const mark = trigger.autoContinueRun;
             const { autoContinueRun: _mark, ...unmarked } = trigger;
             trigger = unmarked;
             // Another reader's turn may have started since the scheduler checked.
             const busy = this.sharedSlotBusy(agent);
-            if (busy || !this.writeAutoContinueNotice(agent, mark)) {
+            if (busy || !this.writeAutoContinueNotice(agent, mark, trigger.heartbeatTurn === true)) {
                 this.giveBackAutoContinue(agent.name, busy ? "another resident's turn is alive in the shared slot" : 'its row could not be stored');
                 if (mark.sole) {
                     console.error(`[continue] ${agent.name}: turn not started (the continuation was its only cause)`);
@@ -18747,9 +19106,10 @@ export class AgentFramework {
         this.noticeHeadMoves(agent);
         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 heartbeat
-            // / no-trigger turn, which falls back to the global default rather
-            // than inheriting a previous turn's channel. A wake whose channel,
+            // 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,
             // 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
@@ -18766,6 +19126,12 @@ export class AgentFramework {
                 routing.noChannel = true;
             else
                 delete routing.noChannel;
+            // A heartbeat's turn has no channel, and takes no fallback: its plain
+            // speech is held as a draft (TurnRouting.heartbeat).
+            if (isHeartbeatWake(trigger))
+                routing.heartbeat = true;
+            else
+                delete routing.heartbeat;
             // 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
@@ -18773,8 +19139,8 @@ export class AgentFramework {
             // chatter and reactions hijacked it before, 2026-07-21); only an
             // addressed message, a follow-up in a channel the turn engaged
             // (repinTurnLocus) or the agent's own channel_open moves it, between
-            // rounds. The eager snapshot protects heartbeat turns from a moving
-            // defaultPublishChannel. Explicit mode uses a turn-scoped `>>` target
+            // rounds. The eager snapshot protects a no-trigger turn that takes the
+            // fallback (a timer's) from a moving defaultPublishChannel. Explicit mode uses a turn-scoped `>>` target
             // and disabled mode has no prose target, so neither resolves or
             // announces a locus. If the effective locus differs from the last one
             // announced, a durable `[routing]` notice goes into the window BEFORE
@@ -18788,8 +19154,17 @@ export class AgentFramework {
                     routing.locus = locus;
                     noteTurnChannel(routing, locus);
                 }
-                if (attempt === 0)
+                // A heartbeat's turn speaks nowhere by design. It's told so up front,
+                // once per heartbeat (a continuation of its run isn't told again),
+                // without moving the announced baseline, so the next channel turn
+                // doesn't announce its channel again.
+                if (attempt === 0 && routing.heartbeat) {
+                    if (!continuesHeartbeat)
+                        this.noticeHeartbeatTurn(agent.name);
+                }
+                else if (attempt === 0) {
                     this.announceLocusIfChanged(agent.name, locus);
+                }
             }
         }
         else {
@@ -18856,7 +19231,9 @@ export class AgentFramework {
             const presentation = this.inspectToolPresentation(agent.name, requestSnapshot);
             const compressionTools = presentation?.available
                 ?? structuredClone(this.availableToolsForPresentation(agent.name, requestSnapshot));
-            const tools = presentation?.advertised ?? compressionTools;
+            // The tool list: what the agent's presentation advertises, less the
+            // host's own toolsets (the built-in one, servers it has as tabs).
+            const tools = this.headerTools(agent.name, presentation?.advertised ?? compressionTools);
             // Gather context from modules (pull-based) and MCPL hooks (push-based)
             // Both produce ContextInjection[] that get merged before inference.
             let injections;
@@ -19120,7 +19497,8 @@ export class AgentFramework {
                 this.endHeldStart(agent, checkWindow, turnToken, turnStartedAt, routing);
                 return false;
             }
-            const action = statedWait === 'fail' ? { retry: false } : this.errorPolicy.onInferenceError(err, agent.name, attempt);
+            const action = statedWait === 'fail' || (isRearmed(trigger) && !gotPartway(routing))
+                ? { retry: false } : this.errorPolicy.onInferenceError(err, agent.name, attempt);
             if (action.retry) {
                 // A policy's delay can be a provider's retry-after: wait all of it.
                 await this.waitForRetry(action.delayMs, checkWindow, agent);
@@ -19181,6 +19559,8 @@ export class AgentFramework {
                     speech: '',
                     ...(statedWait === 'fail' ? this.statedWaitNotSlept(err) : { error: err.message }),
                 }, routing);
+                if (isRearmed(trigger) && isTransientFailure(err))
+                    this.exhaustingRearms.add(agent.name);
                 this.emitTrace({
                     type: 'inference:exhausted',
                     agentName: agent.name,
@@ -19200,6 +19580,7 @@ export class AgentFramework {
                 if (action.emit) {
                     this.pushEvent(action.emit);
                 }
+                this.rearmExhaustedTurn(agent, err, trigger, ownsProviderGate, routing);
             }
             // No handoff on either failure branch: the terminal branch deleted the
             // token above; the retry branch's recursive startAgentStream replaced
@@ -19484,9 +19865,9 @@ export class AgentFramework {
                 }
             };
         };
-        const enqueueSpeech = (text, locus, onPublished) => {
+        const enqueueSpeech = (text, locus, onPublished, round) => {
             chainSpeech(routingSpeech(async () => {
-                const outcome = await this.channelRegistry.routeSpeech(agent.name, text, locus);
+                const outcome = await this.routeLocusSpeech(agent, round ?? { routing: streamRouting, notice: 'later' }, text, locus);
                 this.recordProseDelivery(streamRouting, outcome);
                 if (outcome?.delivered) {
                     streamRouting.liveSpeech = true;
@@ -20008,9 +20389,11 @@ export class AgentFramework {
                                 console.error(`[routing] ${agent.name}: mid-turn round [${toolNames.join(', ')}] -> prose NOT routed (same_round_think_text_policy=private)`);
                             }
                             else {
-                                console.error(`[routing] ${agent.name}: mid-turn round [${toolNames.join(', ')}] -> routing ${roundSegments.length} prose segment(s) live -> ${roundLocus ?? '(default)'}`);
+                                console.error(roundLocus === null && streamRouting.heartbeat
+                                    ? `[routing] ${agent.name}: mid-turn round [${toolNames.join(', ')}] -> ${roundSegments.length} prose segment(s) held as drafts (a heartbeat turn)`
+                                    : `[routing] ${agent.name}: mid-turn round [${toolNames.join(', ')}] -> routing ${roundSegments.length} prose segment(s) live -> ${roundLocus ?? '(default)'}`);
                                 for (const seg of roundSegments) {
-                                    enqueueSpeech(seg, roundLocus, roundPublished);
+                                    enqueueSpeech(seg, roundLocus, roundPublished, roundOpts);
                                 }
                             }
                         };
@@ -20311,7 +20694,7 @@ export class AgentFramework {
                             // self-seed. Exact raw output remains in the provider ledger.
                             agent.getContextManager().addMessage('user', [{
                                     type: 'text',
-                                    text: '[tool-boundary] No tool was called.',
+                                    text: `[${NOTICE_TAG.toolBoundary}] No tool was called.`,
                                 }], {
                                 system: true,
                                 kind: 'tool-wrapper-prose-contained',
@@ -20350,7 +20733,7 @@ export class AgentFramework {
                         else if (cut?.unnamed) {
                             agent.getContextManager().addMessage('user', [{
                                     type: 'text',
-                                    text: '[tool-boundary] Your response was cut off at the output limit inside a tool-call block, before any call in it ' +
+                                    text: `[${NOTICE_TAG.toolBoundary}] Your response was cut off at the output limit inside a tool-call block, before any call in it ` +
                                         'was named, so nothing ran. To make a call, send less in one response.',
                                 }], { system: true, kind: 'cut-off-tool-block', ...this.silentTurnRowMetadata(agent.name) });
                         }
@@ -20617,7 +21000,7 @@ export class AgentFramework {
                                     console.error(`[routing] ${agent.name}: text-only turn -> routing speech -> ${locus ? qualifiedChannelName(locus) : '(none)'}`);
                                     for (const segment of speechSegments) {
                                         try {
-                                            const outcome = await this.channelRegistry.routeSpeech(agent.name, segment, locus);
+                                            const outcome = await this.routeLocusSpeech(agent, textOnlyHold, segment, locus);
                                             this.recordProseDelivery(streamRouting, outcome);
                                             if (outcome?.delivered)
                                                 endPublished(outcome, segment, outcome.messageId);
@@ -20737,7 +21120,7 @@ export class AgentFramework {
                                 // Deliver sequentially (await each) so the segments land in order.
                                 for (const seg of segments) {
                                     try {
-                                        const outcome = await this.channelRegistry.routeSpeech(agent.name, seg, locus);
+                                        const outcome = await this.routeLocusSpeech(agent, trailingHold, seg, locus);
                                         this.recordProseDelivery(streamRouting, outcome);
                                         if (outcome?.delivered)
                                             endPublished(outcome, seg, outcome.messageId);
@@ -20883,7 +21266,8 @@ export class AgentFramework {
                                 this.eventGate?.onInferenceEnded(agent.name);
                             break;
                         }
-                        const action = statedWait === 'fail' ? { retry: false } : this.errorPolicy.onInferenceError(err, agent.name, attempt);
+                        const action = statedWait === 'fail' || (isRearmed(trigger) && !gotPartway(streamRouting))
+                            ? { retry: false } : this.errorPolicy.onInferenceError(err, agent.name, attempt);
                         if (action.retry) {
                             // A stop made during the wait reaches no stream: the check after
                             // the wait ends the turn, as the guard's check after its wait
@@ -20945,6 +21329,8 @@ export class AgentFramework {
                                 speech: '',
                                 ...(statedWait === 'fail' ? this.statedWaitNotSlept(err) : { error: err.message }),
                             }, this.agents.get(agent.name) === agent && agent.streamId === myStreamId ? streamRouting : undefined, streamRouting);
+                            if (isRearmed(trigger) && isTransientFailure(err))
+                                this.exhaustingRearms.add(agent.name);
                             this.emitTrace({
                                 type: 'inference:exhausted',
                                 agentName: agent.name,
@@ -20963,6 +21349,7 @@ export class AgentFramework {
                             if (action.emit) {
                                 this.pushEvent(action.emit);
                             }
+                            this.rearmExhaustedTurn(agent, err, trigger, ownsProviderGate, streamRouting);
                         }
                         break;
                     }
@@ -21037,6 +21424,7 @@ export class AgentFramework {
                                     agentName: agent.name,
                                     error: terminal,
                                 });
+                                this.rearmExhaustedTurn(agent, new Error(terminal), trigger, ownsProviderGate, streamRouting);
                                 // Postmortem 2026-05-28 P2 #7: persist the abort to the
                                 // inference log so future investigations can attribute the
                                 // terminal cause without relying on live in-memory reducer
@@ -21313,12 +21701,15 @@ export class AgentFramework {
                 speech: '',
                 ...(statedWait === 'fail' ? this.statedWaitNotSlept(err) : { error: err.message }),
             }, streamRouting);
+            if (isRearmed(trigger) && isTransientFailure(err))
+                this.exhaustingRearms.add(agent.name);
             this.emitTrace({
                 type: 'inference:exhausted',
                 agentName: agent.name,
                 error: err.message,
                 ...this.classifyInferenceError(err),
             });
+            this.rearmExhaustedTurn(agent, err, trigger, ownsProviderGate, streamRouting);
             // Postmortem 2026-05-28 P2 #7: catch-path failures (stream itself
             // threw) were previously only visible via in-memory trace listeners.
             // Persist to inference log for forensic attribution.
@@ -21537,8 +21928,7 @@ export class AgentFramework {
      * exists only through the private closure handed to ModuleRegistry
      * (ctx.callTool → executeToolCallFrom with {kind:'module'}), which is exempt
      * from agent allowlists. Registered agents' allowedTools is enforced at
-     * dispatch, including namespaced utility names; utils only grants the
-     * list/describe/run slot. Genuinely unidentified public callers (including
+     * dispatch, including namespaced utility names. Genuinely unidentified public callers (including
      * unknown legacy names) remain unrestricted. Framework-created identities
      * are refused while unregistered, even if their configured list allows it.
      */
@@ -21735,6 +22125,9 @@ export class AgentFramework {
             this.emitTrace({ type: 'tool:failed', module: 'framework', tool: call.name, callId: call.id, error: traced });
             return failure;
         };
+        // utils was removed: said whatever the allowlist names (dispatchToolCall).
+        if (call.name === 'utils')
+            return failed({ success: false, isError: true, error: this.utilsRemoved(origin.kind === 'agent' ? origin.agentName : call.callerAgentName) });
         if (origin.kind === 'agent') {
             const failure = this.agentToolPermissionFailure(origin.agentName, call, false);
             if (failure)
@@ -21754,6 +22147,15 @@ export class AgentFramework {
         if (call.name === CODE_EXECUTION_TOOL_NAME && this.codeExecution) {
             return this.runCodeExecution(call.callerAgentName ?? '__ephemeral__', call);
         }
+        // toolsets--act on a host toolset's tool (the built-in one, a server's
+        // tab) goes where a programmatic call of that tool goes, under its name.
+        if (call.name === META_TOOL_NAMES.act && call.callerAgentName !== undefined) {
+            const host = this.hostPresentation?.resolveAct(call.callerAgentName, call.input) ?? null;
+            if (host?.kind === 'refused')
+                return failed({ success: false, error: host.error, isError: true });
+            if (host?.kind === 'call')
+                return this.executeToolCallFrom({ ...call, name: host.name, input: host.args }, origin);
+        }
         // RFC-014: toolsets--act, resolved to the dynamic tool it calls, goes
         // where a programmatic call of that tool goes, with its instance.
         if (call.name === META_TOOL_NAMES.act && this.toolsetHub && this.mcplServerRegistry) {
@@ -21797,21 +22199,13 @@ export class AgentFramework {
         if (call.name === 'drafts' && this.channelRegistry && origin.kind === 'agent') {
             return this.draftsToolResult(origin.agentName, call.input);
         }
-        // The utils meta-tool, for callers that await a tool's result. A call
-        // through executeToolCall (the puppet, a host) reaches what its agent's
-        // allowedTools permits, as the model's does, and an unidentified caller
-        // is unrestricted, as executeToolCall's doc says; a module, through
-        // callTool, is trusted and reaches every utility.
         // The heartbeat's tools, for callers that await a tool's result (an
-        // in-process call, a puppet, a module's callTool). A module is trusted,
-        // as it is for utils; an agent is held to what dispatch holds it to.
+        // in-process call, a puppet, a module's callTool). A module is trusted;
+        // an agent is held to what dispatch holds it to.
         if (this.heartbeat?.ownsTool(call.name)) {
             const refusal = origin.kind === 'module' ? null : this.heartbeatRefusal(call.callerAgentName ?? '__ephemeral__', call);
             return refusal ? { success: false, error: refusal, isError: true } : this.runHeartbeatTool(call);
         }
-        if (call.name === 'utils') {
-            return this.handleUtilsToolCall(call.callerAgentName ?? '__ephemeral__', call, { inProcess: true, trustedModule: origin.kind === 'module' });
-        }
         // Module tools. The caller uses the result in process, so it gets the
         // module's own result, as the module returned it, less a refusal it
         // claims, which is the dispatcher's to say.
@@ -21855,6 +22249,22 @@ export class AgentFramework {
         (this.toolsetActCalls ??= new WeakMap()).set(inner, target.instance !== undefined ? { instance: target.instance } : {});
         return { ok: true, call: inner, serverId: target.serverId, prefix, ...(target.instance !== undefined ? { instance: target.instance } : {}) };
     }
+    /** A toolsets--act call a host toolset resolved (HostPresentation.resolveAct):
+     *  its refusal answered, or the tool's own call dispatched in its place,
+     *  with the act's id, so its result is the act's. */
+    dispatchHostAct(agentName, call, host, turnId) {
+        if (host.kind === 'refused') {
+            this.emitTrace({ type: 'tool:failed', module: TOOLSETS_MODULE, tool: call.name, callId: call.id, error: host.error });
+            this.pushEvent({
+                type: 'tool-result', callId: call.id, toolName: call.name, agentName, moduleName: TOOLSETS_MODULE,
+                result: this.refusedResult(agentName, call.id, host.error),
+            });
+            return;
+        }
+        const inner = { ...call, name: host.name, input: host.args };
+        this.toolLifecycleEmitter?.retarget(agentName, call.id, inner);
+        this.dispatchToolCall(agentName, inner, turnId);
+    }
     /**
      * RFC-014 §8.2: a toolsets--act call from the agent (the model's, or a
      * script's) goes down the path a direct call of the server's tool takes
@@ -22669,17 +23079,17 @@ export class AgentFramework {
     spillNotice(headLength, content, shown, bound, readCap, written) {
         if (written && written.error === undefined) {
             const canRaise = bound === undefined || cutStoredToolResultToFit(content, bound, shown, bound).head.length > headLength;
-            return `\n\n[truncated — showing ${headLength} of ${content.length} chars; full content: workspace file ${written.path}`
+            return `\n\n[${NOTICE_TAG.truncated} — showing ${headLength} of ${content.length} chars; full content: workspace file ${written.path}`
                 + `. ${this.spillPageAdvice(written.path, readCap, canRaise)}]`;
         }
         if (written) {
             // A workspace was there and the write FAILED — say that, loudly and
             // distinctly. Telling the agent "no writable workspace" would teach
             // them their residence lacks a capability it actually has.
-            return `\n\n[truncated — showing ${headLength} of ${content.length} chars; spill to workspace file ${written.path} FAILED`
+            return `\n\n[${NOTICE_TAG.truncated} — showing ${headLength} of ${content.length} chars; spill to workspace file ${written.path} FAILED`
                 + ` (${written.error}); content over the cap was not retained]`;
         }
-        return '\n\n[truncated — original was ' + content.length + ' chars; ' + this.noFileMountText() + ', full content not retained]';
+        return `\n\n[${NOTICE_TAG.truncated} — original was ${content.length} chars; ${this.noFileMountText()}, full content not retained]`;
     }
     /**
      * The length of the notice a cut of `content` that keeps no head would
@@ -23539,6 +23949,17 @@ export class AgentFramework {
      * script left running, which no call watches, has none.
      */
     dispatchToolCall(agentName, call, turnId) {
+        // utils was removed; its utilities are in the built-in toolset. Said
+        // whatever the allowlist names, so an old call learns where they went.
+        if (call.name === 'utils') {
+            const removed = this.utilsRemoved(agentName);
+            this.emitTrace({ type: 'tool:failed', module: 'framework', tool: call.name, callId: call.id, error: removed });
+            this.pushEvent({
+                type: 'tool-result', callId: call.id, toolName: call.name, agentName, moduleName: 'framework',
+                result: this.refusedResult(agentName, call.id, removed),
+            });
+            return;
+        }
         const refusal = this.agentToolPermissionFailure(agentName, call) ?? this.markedInputFailure(agentName, call);
         if (refusal) {
             this.pushEvent({
@@ -23559,6 +23980,16 @@ export class AgentFramework {
             this.pushEvent({ type: 'tool-result', callId: call.id, toolName: call.name, agentName, moduleName: 'tool-presentation', result });
             return;
         }
+        // toolsets--act on a host toolset's tool (the built-in one, a server's
+        // tab): the call of that tool, under its own name, down the path a
+        // direct call of it takes, permissions included.
+        if (enrichedCall.name === META_TOOL_NAMES.act) {
+            const host = this.hostPresentation?.resolveAct(agentName, enrichedCall.input) ?? null;
+            if (host) {
+                this.dispatchHostAct(agentName, call, host, turnId);
+                return;
+            }
+        }
         // RFC-014: toolsets--act calls a server's dynamic tool, down the same
         // path as a direct call of it (dispatchToolsetAct).
         if (enrichedCall.name === META_TOOL_NAMES.act && this.toolsetHub && this.mcplServerRegistry) {
@@ -23584,11 +24015,6 @@ export class AgentFramework {
             this.dispatchChannelToolCall(agentName, enrichedCall);
             return;
         }
-        // Route the agent's typed, allowlisted hot-settings surface.
-        if (enrichedCall.name === 'utils') {
-            this.dispatchUtilsToolCall(agentName, enrichedCall);
-            return;
-        }
         if (enrichedCall.name === 'agent_settings') {
             this.dispatchAgentSettingsToolCall(agentName, enrichedCall);
             return;
@@ -23621,7 +24047,7 @@ export class AgentFramework {
             void this.tuneOutCoordinator
                 .handleSubconsciousTool(enrichedCall.name, enrichedCall.input, this.callOwnChannels(agentName, enrichedCall))
                 // A rejection is answered with a failed result, as a framework tool's
-                // dispatch failure is (dispatchUtilsToolCall), never left unhandled.
+                // dispatch failure is (dispatchAgentSettingsToolCall), never left unhandled.
                 .catch((err) => ({ success: false, error: thrownText(err), isError: true }))
                 .then((result) => {
                 // Through pushEvent, like every other tool's result, so one that
@@ -23688,10 +24114,18 @@ export class AgentFramework {
                 }
                 const wake = readSkipReplyWake(enrichedCall.input);
                 if (wake.kind === 'wake' && this.eventGate) {
+                    const armedAt = Date.now();
                     const { inMs, armed } = this.eventGate.armSelfWake(agentName, wake.seconds, 'skip_reply');
+                    // The heartbeat's tick or reminder due before the timer: if it wakes
+                    // the agent, its turn cancels the timer, so the confirmation names
+                    // it and the time the self-wake would have left.
+                    const earlierWake = armed ? this.heartbeatWakeBefore(agentName, armedAt + inMs) : undefined;
                     console.error(armed
                         ? `[self-wake] agent=${agentName} armed in ${Math.round(inMs / 1000)}s (skip_reply)`
+                            + (earlierWake ? `; due sooner, in ~${earlierWake.inSeconds}s: ${logDetail(earlierWake.what)}` : '')
                         : `[self-wake] agent=${agentName} not armed: the framework has stopped (skip_reply)`);
+                    this.dispatchChannelToolCall(agentName, enrichedCall, earlierWake);
+                    return;
                 }
             }
             this.dispatchChannelToolCall(agentName, enrichedCall);
@@ -23853,7 +24287,7 @@ export class AgentFramework {
         // messages flush at the next turn's START (before its compile — riding
         // their own wake), at the agent's next tool boundary (where they are
         // ALSO injected into the live stream — hear-while-acting — all but a
-        // message a tune-out holds from the residents), or in driveStream's
+        // message the agent's own view leaves out), or in driveStream's
         // finally when the turn ends.
         // Quiesce (issue #122): the window exists to run compression/refold
         // against a FROZEN context — module events and api message.send must not
@@ -24044,18 +24478,20 @@ export class AgentFramework {
         }
     }
     /** Whether `entry`'s own stored entry is the newest in `agent`'s window,
-     *  clock rows and stored context injections after it aside: a channel
-     *  message by its server, channel and message id, a push event by its
-     *  server and event id, and never one a tune-out holds. Past
+     *  clock rows, stored context injections and rows the agent's own view
+     *  leaves out after it aside: a channel message by its server, channel and
+     *  message id, a push event by its server and event id, and never one the
+     *  agent's view leaves out, such as one a tune-out holds. Past
      *  NEWEST_SCAN_ROWS such rows, it answers no. */
     isNewestIn(agent, entry) {
         // A clock row the framework wrote after it (a turn start's, an event's),
         // or a stored context injection (any agent's, a start's), isn't a
         // message a reply could be meant for, so it doesn't count.
         const newest = agent.getContextManager().queryMessages({ limit: AgentFramework.NEWEST_SCAN_ROWS, reverse: true }).messages
-            .find((m) => m.metadata?.kind !== CLOCK_ROW_KIND && !storedInjectionMarkOf(m.metadata));
+            .find((m) => m.metadata?.kind !== CLOCK_ROW_KIND && !storedInjectionMarkOf(m.metadata)
+            && this.agentSees(agent, m.metadata));
         const md = newest?.metadata;
-        if (!md || 'tuneOut' in md || entry.serverId === undefined || md.serverId !== entry.serverId)
+        if (!md || entry.serverId === undefined || md.serverId !== entry.serverId)
             return false;
         if (entry.eventType === 'mcpl:channel-incoming') {
             return entry.messageId !== undefined && md.messageId === entry.messageId && md.channelId === entry.channelId;
@@ -24074,11 +24510,19 @@ export class AgentFramework {
                 ? this.agents.get(this.primaryAgentName)
                 : this.agents.values().next().value;
     }
+    noteSpokenTo(agentName, metadata) {
+        const agent = this.agents.get(agentName);
+        if ((agent && !this.agentSees(agent, metadata)) || isOwnScheduleWrite(metadata) || !isConversationalInjection(metadata))
+            return;
+        if (this.turnRearms?.delete(agentName))
+            console.error(`[inference-rearm] agent=${agentName} re-send count started again: a message was said to it`);
+    }
     /** The notes addMessage takes for a message it stored: an arrival for the
      *  agent when none of its turns is alive or the message was assembled for
      *  the start now beginning (no tool boundary will weigh it), and one for
      *  every other resident's open turn. */
     noteStored(agent, metadata, stored, bypassDeferralFor) {
+        this.noteSpokenTo(agent.name, metadata);
         if (!this.activeTurnTokens.has(agent.name) || bypassDeferralFor === agent.name) {
             this.noteArrival(agent.name, metadata, stored);
         }
@@ -24525,6 +24969,7 @@ export class AgentFramework {
         const stored = this.writeDrainedInOrder(this.drainDeferredFor(agent.name), `${occasion} flush for ${agent.name}`, (msg) => agent.getContextManager().addMessage(msg.participant, msg.content, withDeferredWriteId(msg.metadata, msg.id)));
         for (const [msg, { id }] of stored) {
             this.emitTrace({ type: 'message:added', messageId: id, source: `deferred-flush:${occasion}` });
+            this.noteSpokenTo(agent.name, msg.metadata);
             this.noteArrival(agent.name, msg.metadata, id);
             this.noteForOtherResidents(agent, msg.metadata, id);
         }
@@ -25017,18 +25462,18 @@ export class AgentFramework {
         const outcome = failure.outcome === 'failed' || failure.outcome === 'unknown' ? failure.outcome : undefined;
         const detail = typeof failure.detail === 'string' ? failure.detail : undefined;
         const size = textLen !== undefined ? ` (${textLen} chars)` : '';
-        const why = reason !== undefined ? ` (${reason})` : '';
+        const why = reason !== undefined ? ` (${suppliedValue(reason)})` : '';
         // A notice queued by an earlier build names no server: its channel is
         // the one registered channel its id means, or shown by its id alone.
         const named = this.channelNamed(failure.channelId, typeof failure.serverId === 'string' ? failure.serverId : undefined);
-        const where = named ? this.channelForNotice(named) : failure.channelId;
+        const where = named ? this.channelForNotice(named) : suppliedValue(failure.channelId);
         const text = outcome === 'unknown'
-            ? `[discord-send-failed] Delivery of a reply by ${speaker}${size} to ${where} was not confirmed${why}. ` +
+            ? `[${NOTICE_TAG.discordSendFailed}] Delivery of a reply by ${speaker}${size} to ${where} was not confirmed${why}. ` +
                 `It may or may not have been posted, so sending it again could post it twice. ${speaker} has ended.`
-            : `[discord-send-failed] A reply by ${speaker}${size} could not be delivered to ${where}${why}. ` +
+            : `[${NOTICE_TAG.discordSendFailed}] A reply by ${speaker}${size} could not be delivered to ${where}${why}. ` +
                 `Nothing was posted. ${speaker} has ended.`;
         return {
-            content: [{ type: 'text', text: text + (detail !== undefined ? ` Connector detail: ${detail}` : '') }],
+            content: [{ type: 'text', text: text + (detail !== undefined ? ` Connector detail: ${suppliedValue(detail)}` : '') }],
             metadata: {
                 system: true, kind: 'discord-send-failed', channelId: failure.channelId, speaker,
                 // The channel's server, as the marker it passes on carries it.
@@ -25055,17 +25500,16 @@ export class AgentFramework {
      * channel no string picks alone, its id and its server.
      */
     channelShown(channel) {
-        const name = this.channelRegistry?.nameShown(channel) ?? channel.channelId;
+        const name = this.channelRegistry?.nameShown(channel) ?? suppliedValue(channel.channelId);
         const label = this.channelRegistry?.getDescriptor(channel)?.label;
-        return label && label !== channel.channelId
-            ? `${label.startsWith('#') ? label : `#${label}`} (${name})`
-            : name;
+        const shown = label && label !== channel.channelId ? suppliedValue(label) : undefined;
+        return shown ? `${shown.startsWith('#') ? '' : '#'}${shown} (${name})` : name;
     }
     /** A channel named in a notice with the label it was given there: the
      *  label, with its name as ChannelRegistry.nameShown gives it. */
     labelledChannel(channel) {
-        const name = this.channelRegistry?.nameShown(channel) ?? channel.channelId;
-        return channel.label && channel.label !== channel.channelId ? `${channel.label} (${name})` : name;
+        const name = this.channelRegistry?.nameShown(channel) ?? suppliedValue(channel.channelId);
+        return channel.label && channel.label !== channel.channelId ? `${suppliedValue(channel.label)} (${name})` : name;
     }
     /**
      * A module's write through its context (ModuleContext.addMessage):
@@ -25481,6 +25925,11 @@ export class AgentFramework {
             if (name && this.exhaustionRewinds.get(name)) {
                 this.exhaustionRewinds.set(name, 0);
             }
+            if (name)
+                this.turnRearms?.delete(name);
+        }
+        if (event.type === 'inference:completed' || event.type === 'inference:exhausted' || event.type === 'inference:aborted') {
+            this.endStatedWaitRun(event.agentName);
         }
         const traceEvent = {
             ...event,
@@ -25788,7 +26237,7 @@ export class AgentFramework {
             streak,
             // The refused agent's own view: a subagent's refusal names no channel.
             // Named as the agent is shown it, so a shared id names its server.
-            locus: ((channel) => (channel ? this.channelRegistry?.nameShown(channel) ?? channel.channelId : null))(this.channelRegistry?.incomingFor(agentName)?.channel),
+            locus: ((channel) => (channel ? this.channelRegistry?.nameShown(channel) ?? suppliedValue(channel.channelId) : null))(this.channelRegistry?.incomingFor(agentName)?.channel),
             tokens: tokens ?? null,
         });
         if (streak >= 2) {
@@ -25853,6 +26302,7 @@ export class AgentFramework {
     noteInferenceExhausted(agentName, rawReason, retryable, rawErrorType, detail) {
         const ended = this.exhaustedTurns?.get(agentName);
         this.exhaustedTurns?.delete(agentName);
+        const rearmed = this.exhaustingRearms?.delete(agentName) === true;
         // The reason is the failure's own message, and a provider can echo the
         // whole rejected request in it: one household's [inference-failed]
         // marker carried ~1.7 MB of its own request back into its context. Every
@@ -25902,7 +26352,7 @@ export class AgentFramework {
         this.logFailure({ agent: agentName, consecutive: streak, reason, kind: 'inference-exhausted', ...classification, ...cutAt(reason) });
         // (2) Agent-facing chronicle marker (no inference triggered → no loop).
         const agent = this.agents.get(agentName);
-        if (agent && process.env.SUPPRESS_INFERENCE_FAILED_MARKER !== '1') {
+        if (agent && !(rearmed && !ended) && process.env.SUPPRESS_INFERENCE_FAILED_MARKER !== '1') {
             const cause = [errorType, httpStatus !== undefined ? `HTTP ${httpStatus}` : undefined]
                 .filter((part) => part !== undefined)
                 .join(', ');
@@ -25910,15 +26360,15 @@ export class AgentFramework {
                 agent.getContextManager().addMessage('user', [{
                         type: 'text',
                         text: (ended
-                            ? `[inference-failed] Your previous turn did not complete: it ` +
-                                `failed${cause ? ` (${cause})` : ''}.` +
+                            ? `[${NOTICE_TAG.inferenceFailed}] Your previous turn did not complete: it ` +
+                                `failed${cause ? ` (${suppliedValue(cause)})` : ''}.` +
                                 `${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: `
-                            : `[inference-failed] Your previous turn did not complete: the model ` +
-                                `call failed${cause ? ` (${cause})` : ''} and produced no response, so nothing was sent. Reason: `) +
-                            `${markerReason}. If this recurs with the same cause, change approach ` +
+                            : `[${NOTICE_TAG.inferenceFailed}] Your previous turn did not complete: the model ` +
+                                `call failed${cause ? ` (${suppliedValue(cause)})` : ''} and produced no response, so nothing was sent. Reason: `) +
+                            `${failureShown(markerReason)}. If this recurs with the same cause, change approach ` +
                             `rather than retrying identically (e.g. drop an oversized attachment ` +
                             `or an unsupported setting).`,
                     }], { system: true, kind: 'inference-failed', reason: markerReason, consecutive: streak, ...classification, ...cutAt(markerReason) });
@@ -26168,13 +26618,14 @@ export class AgentFramework {
             // channel hijacks it. An opening start resolves the turn's locus from
             // it (the trigger channel then), and the channel context names it, so
             // a later start of the turn is told where its unprefixed speech lands
-            // unless a hybrid `>>>` destination takes it. Empty for a heartbeat /
-            // no-trigger turn until its locus is resolved, so that resolution
-            // takes the global fallback (none for an ephemeral run); the turn then
-            // keeps that channel.
+            // 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
+            // that channel; null for a heartbeat's turn, which takes none
+            // (TurnRouting.heartbeat).
             activeChannelResolver: (agentName) => {
                 const routing = this.turnRouting.get(agentName);
-                return routing?.locus ?? routing?.triggerChannel ?? (routing?.noChannel ? null : undefined);
+                return routing?.locus ?? routing?.triggerChannel ?? (routing?.noChannel || routing?.heartbeat ? null : undefined);
             },
             // An ephemeral run (a subagent) never takes the process-global
             // fallback: its prose is its caller's result, and the latest inbound
@@ -26230,11 +26681,11 @@ export class AgentFramework {
                         ? (outcome === 'unknown'
                             // A request went out and no valid receipt came back: it may
                             // have been posted (in part or whole). Never claim it wasn't.
-                            ? `[discord-send-failed] Delivery of your previous reply (${textLen} chars) to ${where} was not confirmed (${reason}). It may or may not have been posted, so sending it again could post it twice. It is saved in your archive.`
-                            : `[discord-send-failed] Your previous reply (${textLen} chars) could not be delivered to ${where} (${reason}). Nothing was posted; it is saved in your archive.`)
-                        : `[send-undeliverable] Your previous reply (${textLen} chars) had no channel to go to — ${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.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.`;
                     // A registered speaker's notice is addressed to it (noticeTargetFor).
-                    this.addMessage('user', [{ type: 'text', text: text + (detail !== undefined ? ` Connector detail: ${detail}` : '') }], metadata, { forAgent: conversationId });
+                    this.addMessage('user', [{ type: 'text', text: text + (detail !== undefined ? ` Connector detail: ${suppliedValue(detail)}` : '') }], metadata, { forAgent: conversationId });
                 }
                 catch (err) {
                     console.error('onRouteFailure: failed to record send-failure marker:', err);
@@ -26351,6 +26802,9 @@ export class AgentFramework {
     restartClaims() {
         return (this.mcpRestartClaims ??= { ids: new Map(), prefixes: new Map() });
     }
+    closedTabConfigs() {
+        return (this.closedTabConfigMap ??= new Map());
+    }
     legacyConnectAborts() {
         return (this.legacyConnectAbortMap ??= new Map());
     }
@@ -26898,14 +27352,63 @@ export class AgentFramework {
                 'it stays registered until a disconnect, restart or shutdown closes it:', closeError instanceof Error ? closeError.message : closeError);
         });
     }
+    /** RFC-014: who held the name `toolsets` at startup (a module given to
+     *  create(); a server's toolPrefix of it is refused), so a server that
+     *  leaves toolHints out has none for the life of this framework; null when
+     *  the name was free. */
+    toolsetsNameHeldAtStart = null;
+    /** At startup: note who holds the name the meta-tools need, and say which
+     *  servers that leaves without hints. */
+    reserveToolsetsName(modules, servers) {
+        const module = modules.find((m) => m.name === TOOLSETS_MODULE);
+        this.toolsetsNameHeldAtStart = module ? `module "${TOOLSETS_MODULE}"` : null;
+        if (!this.toolsetsNameHeldAtStart)
+            return;
+        // Those that would have had hints: MCPL servers that leave the setting out.
+        const defaulted = servers
+            .filter((s) => (s.toolHints === undefined || s.toolHints === null) && isLegacyFamily(s))
+            .map((s) => s.id);
+        if (defaulted.length) {
+            console.error(`[mcpl] tool hints (RFC-014) are off for ${defaulted.join(', ')}, which leave toolHints out: the name "${TOOLSETS_MODULE}" ` +
+                `the meta-tools need is ${this.toolsetsNameHeldAtStart}. Free the name to give them hints, or set toolHints: false on them to keep them off without this line.`);
+        }
+    }
+    /**
+     * RFC-014: whether a server has tool hints. Only an MCPL (legacy-family)
+     * server can: a modern MCP server never has them. `true` and `false` are
+     * as configured. Left out (or null) they're on, wherever the name
+     * `toolsets` the meta-tools need is free: no other module holds it and no
+     * server's prefix is it, now or at startup. So a configuration that loaded
+     * when hints were opt-in still loads. A name held at startup stays held
+     * for the framework's life.
+     */
+    hintsFor(config) {
+        if (config.toolHints === false || !isLegacyFamily(config))
+            return false;
+        if (config.toolHints === true)
+            return true;
+        if (this.toolsetsNameHeldAtStart !== null)
+            return false;
+        if ((config.toolPrefix ?? `mcpl--${config.id}`) === TOOLSETS_MODULE)
+            return false;
+        const module = this.moduleRegistry.getAllModules().find((m) => m.name === TOOLSETS_MODULE);
+        if (module && !(module instanceof ToolsetsModule))
+            return false;
+        // A restart moving its server to the prefix holds the name as a claim.
+        if (this.restartClaims().prefixes.has(TOOLSETS_MODULE))
+            return false;
+        const owner = this.mcplPrefixMap.get(TOOLSETS_MODULE);
+        return owner === undefined || owner === config.id;
+    }
     /**
      * The host capabilities offered to one server: the host's own, plus
-     * RFC-014's `toolHints` where its configuration asks for them. Without it,
-     * the very object every server is offered.
+     * RFC-014's `toolHints` unless its configuration turns them off
+     * (`toolHints: false`). With them off, the very object every server is
+     * offered.
      */
-    mcplHostCapabilitiesFor(config) {
+    mcplHostCapabilitiesFor(config, hints = this.hintsFor(config)) {
         const base = this.mcplHostCapabilities;
-        return config.toolHints === true ? { ...base, toolHints: true } : base;
+        return hints ? { ...base, toolHints: true } : base;
     }
     /** RFC-014: every toolHints server's presence, made on first use. */
     toolsets() {
@@ -26923,20 +27426,181 @@ export class AgentFramework {
                     return undefined;
                 return this.mcplTools.some((t) => t.name === name) ? 'static' : 'dynamic';
             },
+            hostOpen: (agentName) => this.hostPresentation?.openMarkers(agentName) ?? [],
         }));
     }
-    /** RFC-014: the `toolsets` module (toolsets--open, --act, --look,
-     *  --close), registered once, by the first server configured with
-     *  toolHints. Its tools don't change after that. */
+    /**
+     * The host's own toolsets (host-presentation.ts): the built-in "settings"
+     * toolset and each MCPL server's tab. State is kept beside the store, in
+     * `config/toolsets.json`; with no store path, in memory only.
+     */
+    makeHostPresentation(storePath) {
+        return new HostPresentation({
+            // As the agent is shown them: its description overrides applied.
+            available: (agentName) => (this.agents.has(agentName) ? this.compressionToolsForAgent(agentName) : this.getAllTools()),
+            placedInBuiltin: (name) => this.placedInBuiltin(name),
+            hidden: (agentName) => {
+                if (!this.agents.has(agentName))
+                    return new Set();
+                const snapshot = this.inspectToolPresentation(agentName);
+                return new Set(snapshot?.entries.filter((e) => !e.visible).map((e) => e.name) ?? []);
+            },
+            serverOf: (name) => this.resolveMcplTool(name)?.[0] ?? null,
+            servers: () => {
+                const out = new Map();
+                for (const [id, config] of this.mcplServerConfigs) {
+                    out.set(id, { id, configured: config.presentation ?? 'full', connected: !!this.mcplServerRegistry?.getServer(id) || this.modernServers().has(id) });
+                }
+                for (const [id, config] of this.closedTabConfigs()) {
+                    if (!out.has(id))
+                        out.set(id, { id, configured: config.presentation ?? 'full', connected: false });
+                }
+                return [...out.values()];
+            },
+            canUseMeta: (agentName) => this.hostToolsetsFor(agentName),
+            disconnect: async (serverId) => {
+                const config = this.mcplServerConfigs.get(serverId);
+                if (!config)
+                    throw new Error(`no MCPL server "${serverId}" is connected here`);
+                this.refuseOperatorAfterStop('disconnect MCPL server');
+                // As a transient close: its checkpoint trees and RFC-014 state stay
+                // for the connect its next open makes.
+                await this.trackOperatorOperation('mcpl:disconnect', () => this.runDisconnectMcplServer(serverId, { keepToolsets: true, keepCheckpoints: true }));
+                this.closedTabConfigs().set(serverId, config);
+            },
+            reconnect: async (serverId) => {
+                const config = this.closedTabConfigs().get(serverId);
+                if (!config)
+                    throw new Error(`no MCPL server "${serverId}" is kept as a closed tab here`);
+                this.refuseOperatorAfterStop('connect MCPL server');
+                await this.trackOperatorOperation('mcpl:connect', () => this.runConnectMcplServer(config, undefined, { reopen: true }));
+            },
+            log: (line) => console.error(line),
+            isUtility: (name) => this.isModuleUtility(name),
+            residents: () => this.heartbeatTargets(),
+        }, storePath ? join(storePath, 'config', 'toolsets.json') : null);
+    }
+    /** Whether a name is a module utility (and not a tool of its module, which takes the name). */
+    isModuleUtility(name) {
+        const sep = name.indexOf('--');
+        if (sep <= 0)
+            return false;
+        const module = this.moduleRegistry.getModule(name.slice(0, sep));
+        if (!module)
+            return false;
+        const bare = name.slice(sep + 2);
+        try {
+            return !module.getTools().some((t) => t.name === bare) && (module.getUtilities?.()?.some((t) => t.name === bare) ?? false);
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Whether an agent has the host's own toolsets: the meta-tools registered, and
+     *  usable by it (the subconscious keeps its own small surface). */
+    /**
+     * What a call of the removed `utils` is answered: where utilities went, as
+     * this agent can reach them. One that can't use the built-in toolset is
+     * told to call a utility by its own name and which ones it may call.
+     */
+    utilsRemoved(agentName) {
+        if (agentName === undefined || this.hostToolsetsFor(agentName))
+            return UTILS_REMOVED;
+        const agent = this.agents.get(agentName);
+        const why = this.moduleRegistry.getAllModules().find((m) => m.name === TOOLSETS_MODULE) instanceof ToolsetsModule
+            ? `its allowedTools doesn't permit ${META_TOOL_NAMES.open} and ${META_TOOL_NAMES.act}`
+            : `this host's module named "${TOOLSETS_MODULE}" isn't the framework's`;
+        const mine = this.getAllTools().filter((t) => this.isModuleUtility(t.name) && (agent?.canUseTool(t.name) ?? true)).map((t) => t.name);
+        return `utils was removed: module utilities are in the host's built-in toolset now, which this agent can't use (${why}). ` +
+            `Call a utility by its own name instead${mine.length ? `; this agent may call ${mine.join(', ')}` : '; this agent may call none'}. Nothing was run.`;
+    }
+    hostToolsetsFor(agentName) {
+        if (agentName === this.subconsciousAgentName)
+            return false;
+        const module = this.moduleRegistry.getAllModules().find((m) => m.name === TOOLSETS_MODULE);
+        if (!(module instanceof ToolsetsModule))
+            return false;
+        const agent = this.agents.get(agentName);
+        if (!agent)
+            return true;
+        return agent.canUseTool(META_TOOL_NAMES.open) && agent.canUseTool(META_TOOL_NAMES.act);
+    }
+    /**
+     * Whether a host tool belongs to the built-in toolset: the framework's own
+     * rarely-used ones (BUILTIN_TOOLSET_TOOLS), a module's that it places there
+     * (Module.toolPlacement), and every module utility.
+     */
+    placedInBuiltin(name) {
+        if (BUILTIN_TOOLSET_TOOLS.has(name))
+            return true;
+        const sep = name.indexOf('--');
+        if (sep <= 0)
+            return false;
+        const module = this.moduleRegistry.getModule(name.slice(0, sep));
+        if (!module)
+            return false;
+        const bare = name.slice(sep + 2);
+        // A module whose listing throws keeps its tools where they are.
+        try {
+            if (module.getTools().some((t) => t.name === bare))
+                return module.toolPlacement?.(bare) === 'builtin';
+            return module.getUtilities?.()?.some((t) => t.name === bare) ?? false;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * The tool list an agent's requests carry, from the tools it may call: its
+     * host presentation applied (the built-in toolset's tools, the servers it
+     * has as tabs and its hidden tools left out; a utility never in it), as
+     * every request of a registered agent has it (with its own tool
+     * presentation, hidden tools and descriptions, applied first). For a stream that isn't
+     * registered yet, such as a fork whose orientation is written before its
+     * run starts, the host says whether it will be able to call
+     * `toolsets--open` and `toolsets--act` (`canUseMeta`); left out, the agent
+     * registered under that name is asked. Presentation it chose itself (open
+     * toolsets, tabs) is read under that name, so a new name starts from the
+     * configured presentation.
+     */
+    presentedTools(agentName, tools, canUseMeta) {
+        // A registered agent's own presentation first, as its requests have it
+        // before the host's: the tools it hid left out, its descriptions applied.
+        const snapshot = this.agents.has(agentName) ? this.inspectToolPresentation(agentName) : undefined;
+        if (snapshot) {
+            const hidden = new Set(snapshot.entries.filter((e) => !e.visible).map((e) => e.name));
+            const shown = new Map(snapshot.advertised.map((t) => [t.name, t]));
+            tools = tools.filter((t) => !hidden.has(t.name)).map((t) => shown.get(t.name) ?? t);
+        }
+        if (!this.hostPresentation)
+            return tools;
+        if (canUseMeta === undefined)
+            return this.hostPresentation.header(agentName, tools);
+        // As hostToolsetsFor decides for a registered agent: the subconscious and
+        // a host whose module named toolsets isn't the framework's present nothing.
+        const meta = canUseMeta && agentName !== this.subconsciousAgentName
+            && this.moduleRegistry.getAllModules().find((m) => m.name === TOOLSETS_MODULE) instanceof ToolsetsModule;
+        return this.hostPresentation.header(agentName, tools, meta);
+    }
+    /** The host presentation of a server's tools, for the tool list: the agent's
+     *  view, less the built-in toolset and the servers it has as tabs. */
+    headerTools(agentName, tools) {
+        return this.hostPresentation ? this.hostPresentation.header(agentName, tools) : tools;
+    }
+    /** The `toolsets` module (toolsets--open, --act, --look, --close): the
+     *  meta-tools of the host's own toolsets and of RFC-014 servers' toolsets.
+     *  Registered once, at create(), unless a module given to create() holds
+     *  the name; a server with toolHints: true then can't have hints, and its
+     *  connect is refused here. Its tools don't change after that. */
     async ensureToolsetsModule() {
         const hub = this.toolsets();
         const existing = this.moduleRegistry.getAllModules().find((m) => m.name === TOOLSETS_MODULE);
         if (existing instanceof ToolsetsModule)
             return;
         if (existing) {
-            throw new Error(`A module named "${TOOLSETS_MODULE}" is registered, and a server configured with toolHints needs that name for its meta-tools`);
+            throw new Error(`A module named "${TOOLSETS_MODULE}" is registered, and a server configured with toolHints: true needs that name for its meta-tools: set toolHints: false on it (or leave the setting out: it then has no hints here), or free the name`);
         }
-        await this.addModule(new ToolsetsModule(hub, (call) => this.changeTaker(call)));
+        await this.addModule(new ToolsetsModule(hub, (call) => this.changeTaker(call), this.hostPresentation));
     }
     /** RFC-014 §5.3: after a (re)connect whose policy has settled, read what
      *  the server holds open and adopt it. In the background: its notices are
@@ -26969,7 +27633,7 @@ export class AgentFramework {
             return false;
         }
         try {
-            this.addMessage('user', [{ type: 'text', text: `MCPL server "${serverId}", tool changes:\n${text}` }], { system: true, kind: 'mcpl-toolsets', serverId, ...(opts.invite ? { invite: true } : {}) });
+            this.addMessage('user', [{ type: 'text', text: `[${NOTICE_TAG.toolsets}] MCPL server "${serverId}", tool changes:\n${text}` }], { system: true, kind: 'mcpl-toolsets', serverId, ...(opts.invite ? { invite: true } : {}) });
             return true;
         }
         catch (error) {
@@ -27119,20 +27783,24 @@ export class AgentFramework {
         let registeredEpoch = 0;
         const abort = new AbortController();
         this.legacyConnectAborts().set(config.id, abort);
+        // RFC-014: decided once for this connect, so the meta-tools, the offer
+        // and the read tap agree though the state hintsFor reads can change
+        // across the awaits below.
+        const hints = this.hintsFor(config);
         try {
-            // RFC-014: a toolHints server's meta-tools exist before it connects.
-            if (config.toolHints === true)
+            // RFC-014: a hinted server's meta-tools exist before it connects.
+            if (hints)
                 await this.ensureToolsetsModule();
             // Its policy exchange is in flight from its registration until the
             // exchange settles: an opener that runs meanwhile (a resume, startup's
             // staged open) passes the connection by, so nothing opens its planes
             // before its grant exists.
-            connection = await this.mcplServerRegistry.addServer(connectionConfig, this.mcplHostCapabilitiesFor(config), abort.signal, (registering) => {
+            connection = await this.mcplServerRegistry.addServer(connectionConfig, this.mcplHostCapabilitiesFor(config, hints), abort.signal, (registering) => {
                 registeredEpoch = registering.transportEpoch;
                 this.mcplPolicyExchanges.set(registering, registeredEpoch);
                 // RFC-014 §6.1: hints apply as the connection reads them, from its
                 // first message, so the tap is on before any I/O can deliver one.
-                if (config.toolHints === true)
+                if (hints)
                     this.toolsets().controllerFor(config).attach(registering);
             });
         }
@@ -27444,7 +28112,7 @@ export class AgentFramework {
             // instances; toolHints withdrawn makes every tool static. Its impact is
             // surface-changed, applied, with no grant consequence (§17.6).
             const declarations = toolsetDeclarationsOf(fetched);
-            const toolsetsChanged = config.toolHints === true
+            const toolsetsChanged = this.hintsFor(config)
                 && JSON.stringify(declarations) !== JSON.stringify(connection.toolsetDeclarations);
             connection.toolsetDeclarations = declarations;
             if (toolsetsChanged)
@@ -27727,7 +28395,7 @@ export class AgentFramework {
     }
     /** connectMcplServer's work, for a restart's connect too: the id and tool
      *  prefix its `claim` holds are free to it, and refused to everyone else. */
-    async runConnectMcplServer(config, claim) {
+    async runConnectMcplServer(config, claim, opts = {}) {
         assertServerConfigBooleans(config);
         // Lazily bring up the MCPL subsystem — a framework that started with zero
         // configured servers can still deploy its first one at runtime.
@@ -27753,8 +28421,31 @@ export class AgentFramework {
         // registers. A server already registered was refused just above, so the
         // read never reaches a registered server's trees.
         this.checkpointManager?.loadHostStates(config.id);
+        // An operator's connect ends a closed tab as it begins, as a restart
+        // does: one that fails once its configuration is taken leaves an
+        // ordinary server that's down, under that configuration; one refused
+        // before (its transport, the awareness ledger) changes nothing, and the
+        // closed tab is put back. Whether it was one is the kept configuration's
+        // to say. An agent's open (reopen) ends it only once connected, so one
+        // that fails leaves the closed tab to open again.
+        const keptClosedTab = opts.reopen ? undefined : this.closedTabConfigs().get(config.id);
+        const closedWas = keptClosedTab ? this.hostPresentation?.closedState(config.id) : undefined;
+        if (keptClosedTab) {
+            this.closedTabConfigs().delete(config.id);
+            this.hostPresentation?.noteConnected(config.id, true);
+        }
         const oldToolNames = new Set(this.mcplTools.map(t => t.name));
-        const connection = await this.connectMcplServerInternal(config, false, claim);
+        let connection;
+        try {
+            connection = await this.connectMcplServerInternal(config, false, claim);
+        }
+        catch (error) {
+            if (keptClosedTab && !this.mcplServerConfigs.has(config.id) && !this.closedTabConfigs().has(config.id)) {
+                this.closedTabConfigs().set(config.id, keptClosedTab);
+                this.hostPresentation?.restoreClosed(config.id, closedWas);
+            }
+            throw error;
+        }
         // A stop() that began during the connect's setup or its tool listing
         // ends the connect: it doesn't wait on a server for a framework that is
         // stopping, and the teardown closes what the connect set up.
@@ -27777,6 +28468,9 @@ export class AgentFramework {
         if (this.mcpServerOps?.get(config.id)?.kind === 'disconnect' || !AgentFramework.mcpConnectionServes(connection)) {
             throw new Error(`MCP server "${config.id}" was not connected: it was disconnected or lost while its tools were being listed`);
         }
+        // Connected, however it was asked for: not a closed tab any more.
+        const wasClosedTab = this.closedTabConfigs().delete(config.id);
+        this.hostPresentation?.noteConnected(config.id, wasClosedTab);
         this.emitMcplToolDiff(oldToolNames, config.id);
     }
     /**
@@ -27803,7 +28497,17 @@ export class AgentFramework {
         const claim = this.restartClaims().ids.get(id);
         if (claim)
             claim.endedBy = `MCP server "${id}" was disconnected, which ends the restart of "${claim.restarting}"`;
-        return this.trackOperatorOperation('mcpl:disconnect', () => this.runDisconnectMcplServer(id));
+        // A closed tab removed by its operator: there's nothing to connect it
+        // again with, and what its disconnect kept for that connect (checkpoint
+        // trees, RFC-014 state) goes, as any disconnect removes it.
+        if (this.closedTabConfigs().delete(id) && !this.mcplServerConfigs.has(id)) {
+            this.checkpointManager?.removeServer(id);
+            this.toolsetHub?.forget(id);
+            this.hostPresentation?.noteRemoved(id);
+            return;
+        }
+        await this.trackOperatorOperation('mcpl:disconnect', () => this.runDisconnectMcplServer(id));
+        this.hostPresentation?.noteRemoved(id);
     }
     async runDisconnectMcplServer(id, opts = {}) {
         if (!this.mcplServerRegistry) {
@@ -27856,7 +28560,10 @@ export class AgentFramework {
             // already transiently closed (reconnect pending) emits no second 'close'
             // from close(), and the transient path deliberately preserves checkpoints.
             this.featureSetManager?.removeServer(id);
-            this.checkpointManager?.removeServer(id);
+            // A closed tab (host-presentation.ts) keeps its checkpoint trees for
+            // the connect its next open makes, as a transient close does.
+            if (!opts.keepCheckpoints)
+                this.checkpointManager?.removeServer(id);
             if (!opts.keepToolsets)
                 this.toolsetHub?.forget(id);
             // Only this server's own claims, as the prefix map holds them rather
@@ -27869,6 +28576,7 @@ export class AgentFramework {
             }
             this.mcplServerConfigs.delete(id);
             referenceRegistry.forgetServerAddress(id, this);
+            this.eventGate?.sourcesChanged();
             await this.refreshMcplTools();
             this.emitMcplToolDiff(oldToolNames, id);
         }
@@ -27920,7 +28628,8 @@ export class AgentFramework {
         // A stop(), or a disconnect of the id it moves the server to, that
         // begins after these checks isn't held off: it ends the restart, as it
         // would end a connect.
-        const config = newConfig ?? this.mcplServerConfigs.get(id);
+        // A closed tab restarts from the configuration it's kept with.
+        const config = newConfig ?? this.mcplServerConfigs.get(id) ?? this.closedTabConfigs().get(id);
         if (!config) {
             throw new Error(`MCPL server "${id}" is not configured`);
         }
@@ -27962,7 +28671,17 @@ export class AgentFramework {
         this.restartClaims().ids.set(config.id, claim);
         this.restartClaims().prefixes.set(prefix, claim);
         try {
-            await this.runDisconnectMcplServer(id, { keepToolsets: config.id === id && config.toolHints === true });
+            await this.runDisconnectMcplServer(id, { keepToolsets: config.id === id && this.hintsFor(config) });
+            // A restart ends a closed tab as it begins: the operator connects the
+            // server now, and one whose connect fails is left an ordinary server
+            // that's down. Moved to another id, the old id's tab is no more.
+            if (this.closedTabConfigs().has(id)) {
+                if (config.id === id)
+                    this.hostPresentation?.noteConnected(id, true);
+                else
+                    this.hostPresentation?.noteRemoved(id);
+                this.closedTabConfigs().delete(id);
+            }
             try {
                 await this.runConnectMcplServer(config, claim);
             }
@@ -28076,6 +28795,17 @@ export class AgentFramework {
                 return prefixesMeetError(config.id, prefix, otherId, other).message;
             }
         }
+        // A closed tab keeps its prefix (and the prefixes it would meet) for the
+        // connect its next open makes.
+        for (const [otherId, other] of this.closedTabConfigs()) {
+            if (otherId === config.id || otherId === leaving || this.mcplServerConfigs.has(otherId))
+                continue;
+            const otherPrefix = other.toolPrefix ?? `mcpl--${otherId}`;
+            if (otherPrefix === prefix)
+                return `MCPL server "${config.id}" toolPrefix "${prefix}" collides with server "${otherId}" (a closed tab)`;
+            if (prefixesMeet(prefix, otherPrefix))
+                return prefixesMeetError(config.id, prefix, otherId, otherPrefix).message;
+        }
         for (const [other, holder] of this.restartClaims().prefixes) {
             if (holder !== claim && other !== prefix && prefixesMeet(prefix, other)) {
                 return `MCPL server "${config.id}" toolPrefix "${prefix}" meets the toolPrefix "${other}" the restart of ` +
@@ -28107,7 +28837,12 @@ export class AgentFramework {
      */
     listMcplServers() {
         const result = [];
-        for (const [id, config] of this.mcplServerConfigs) {
+        // Closed tabs too: configured, kept disconnected until an agent opens one.
+        const configured = [...this.mcplServerConfigs];
+        for (const [id, config] of this.closedTabConfigs())
+            if (!this.mcplServerConfigs.has(id))
+                configured.push([id, config]);
+        for (const [id, config] of configured) {
             const prefix = config.toolPrefix ?? `mcpl--${id}`;
             const modern = this.modernServers().get(id) ?? null;
             const connection = modern ? null : this.mcplServerRegistry?.getServer(id) ?? null;
@@ -28131,6 +28866,7 @@ export class AgentFramework {
             result.push({
                 id,
                 connected,
+                closedTab: this.closedTabConfigs().has(id),
                 retrying: !connected && (modern?.willReconnect ?? connection?.willReconnect ?? false),
                 family: binding?.family ?? null,
                 protocolVersion: modern?.protocolVersion ?? connection?.protocolVersion ?? null,
@@ -29125,7 +29861,7 @@ export class AgentFramework {
             moduleName: `mcpl:${serverId}:tools-refreshed`,
         });
         if (newTools.length > 0) {
-            const toolList = newTools.map(t => t.name).join(', ');
+            const toolList = newTools.map(t => suppliedValue(t.name)).join(', ');
             this.pushEvent({
                 type: 'external-message',
                 source: `mcpl:${serverId}`,
@@ -29703,7 +30439,7 @@ export class AgentFramework {
     /**
      * Dispatch a synthesized channel tool call.
      */
-    dispatchChannelToolCall(agentName, call) {
+    dispatchChannelToolCall(agentName, call, earlierWake) {
         // Conversation forks act only on their home channel. channel_publish and
         // channel_close default a missing channelId to home and reject foreign
         // ones; channel_open is rejected outright — opening channels mutates
@@ -29729,7 +30465,7 @@ export class AgentFramework {
             };
             // The home quoted for a sentence (quotedShown), as the agent names it
             // back, whose id-and-server form carries its own quotes.
-            const homeQuoted = this.channelRegistry?.quotedShown(home) ?? JSON.stringify(home.channelId);
+            const homeQuoted = this.channelRegistry?.quotedShown(home) ?? quotedValue(home.channelId);
             // A home its server no longer registers (a channels/changed update
             // removed it, or this host removed its server; a dropped connection
             // keeps the entry) takes nothing, and the fork has nowhere else to
@@ -29811,7 +30547,9 @@ export class AgentFramework {
         const publisher = call.name === 'channel_publish' && callingTurn ? this.agents.get(agentName) : undefined;
         const readThrough = publisher ? this.publishReadThrough(publisher, call.id) : null;
         const published = {};
-        this.channelRegistry.handleChannelToolCall(call.name, call.input, { kind: 'agent', agentName, own: callingTurn ? this.ownChannels(callingTurn) : [] }, published)
+        this.channelRegistry.handleChannelToolCall(call.name, call.input, {
+            kind: 'agent', agentName, own: callingTurn ? this.ownChannels(callingTurn) : [], ...(earlierWake ? { earlierWake } : {}),
+        }, published)
             .then((result) => {
             const destination = published.outcome?.status === 'delivered' ? published.outcome.destination : undefined;
             if (publisher && destination)
@@ -29861,13 +30599,15 @@ export class AgentFramework {
                         noteTurnChannel(callingTurn, opened);
                         this.lastAnnouncedLocus.set(agentName, opened);
                         const inboundOnlyServer = this.channelRegistry?.inboundOnlyServer(opened);
+                        // The routing word comes first, ahead of any backscroll, so a
+                        // result cut to its head for being long keeps it.
                         result = {
                             ...result,
                             data: {
-                                ...result.data,
                                 routing: inboundOnlyServer
                                     ? `${inboundOnlySpeechNote(inboundOnlyServer)} Other channels need an explicit send tool.`
                                     : 'Your plain speech now lands in this channel. Other channels need an explicit send tool.',
+                                ...result.data,
                             },
                         };
                         console.error(`[routing] ${agentName}: channel_open -> pin moved to ${qualifiedChannelName(opened)} (announced in tool result)`);
@@ -30202,7 +30942,7 @@ export class AgentFramework {
                     // answered for it.
                     const now = this.channelRegistry.getTuneOutState(channel.serverId, channelId);
                     const error = now?.params.epochId === tuneOut.params.epochId
-                        ? alreadyTunedOutText(shownNow(), now.params, openError ?? 'Its transport is open now, so its messages reach the subconscious.')
+                        ? alreadyTunedOutText(this.channelRegistry.quotedShown(channel), now.params, openError ?? 'Its transport is open now, so its messages reach the subconscious.')
                         : TUNE_OUT_REPLACED;
                     this.pushEvent({
                         type: 'tool-result',
@@ -30341,6 +31081,9 @@ export class AgentFramework {
                     console.error(`[sleep] ${agentName}: no prose target this turn — sleep announcement not posted (explicit mode never guesses)`);
                 }
             }
+            else if (!callingTurn.locus && callingTurn.heartbeat) {
+                console.error(`[sleep] ${agentName}: a heartbeat turn has no channel — sleep announcement not posted`);
+            }
             else {
                 const locus = callingTurn.locus ?? null;
                 registry.routeSpeech(agentName, announcement(locus), locus).then(noted).catch((err) => {
@@ -30523,7 +31266,7 @@ export class AgentFramework {
                 return;
             if (Date.now() - startedAt > BARRIER_MS) {
                 throw new Error(`save_recent_image: ${open.length} sibling tool call(s) in this batch still pending after ` +
-                    `${Math.round(BARRIER_MS / 1000)}s (${open.map((p) => `${p.name} (call ${p.id})`).join(', ')}) — their results ` +
+                    `${Math.round(BARRIER_MS / 1000)}s (${open.map((p) => `${suppliedValue(p.name)} (call ${p.id})`).join(', ')}) — their results ` +
                     'may carry newer images than anything in your context, so no index can be trusted yet. Nothing written. ' +
                     'Save again once they have finished.');
             }
@@ -30570,7 +31313,7 @@ export class AgentFramework {
                     throw new Error('save_recent_image: `path` (mount-prefixed) is required');
                 }
                 const ledger = this.toolImageLedgerFor(agentName);
-                const describeTool = (c) => `${c.toolName} (call ${c.toolCallId})`;
+                const describeTool = (c) => `${suppliedValue(c.toolName)} (call ${c.toolCallId})`;
                 const unavailable = (status) => status === 'evicted'
                     ? 'its bytes were evicted from the bounded retention budget'
                     : 'this process has no record of that ref (refs are per-process and a restart clears them; ' +
@@ -30773,9 +31516,10 @@ export class AgentFramework {
                         const content = messages[i]?.content;
                         if (!Array.isArray(content))
                             continue;
-                        // Another agent's stored context injection isn't in this agent's
-                        // view (stored-injections.ts), so its images aren't either.
-                        if (isAnotherAgentsInjection(messages[i]?.metadata, agentName))
+                        // A row the agent's own view leaves out, such as another agent's
+                        // stored context injection (stored-injections.ts), isn't in its
+                        // window, so its images aren't either.
+                        if (!this.agentSees(agent, messages[i]?.metadata))
                             continue;
                         const messagesBack = total - (start + i);
                         for (let b = content.length - 1; b >= 0 && collecting(); b--) {
@@ -30847,7 +31591,8 @@ export class AgentFramework {
                         // error says that whether the entry changed isn't known
                         // (writeBinary); the images before it are saved, and the
                         // failure says so, as a returned one does.
-                        failed(error);
+                        console.error(`[save_recent_image] writing "${destination}" failed:`, error);
+                        failed(thrownWords(error));
                         return;
                     }
                     const inChronicle = result.data?.inChronicle === true;
@@ -30884,117 +31629,6 @@ export class AgentFramework {
             }
         })();
     }
-    /** The `utils` meta-tool: list/describe/run over module utilities
-     *  (Module.getUtilities). Shared by the model-facing dispatcher, which a
-     *  running code_execution script's calls take too, and executeToolCallFrom,
-     *  which the puppet and a host reach through executeToolCall and a module
-     *  through callTool. */
-    async handleUtilsToolCall(agentName, call, options = {}) {
-        const input = (call.input ?? {});
-        const allUtilities = this.moduleRegistry.getAllUtilities();
-        const utilities = allUtilities.filter(def => options.trustedModule || this.canAgentUseTool(agentName, def.name));
-        const counts = `${registeredUtilities(allUtilities.length)}, ${utilities.length} permitted`;
-        const available = () => utilities.length
-            ? `Available: ${utilities.map((u) => u.name).join(', ')} (${counts})`
-            : allUtilities.length
-                ? `${counts}; none permitted by this agent's allowedTools. Add each required module--utility name to allowedTools.`
-                : `${counts} (none registered)`;
-        switch (input.action) {
-            case 'list':
-                if (allUtilities.length > 0 && utilities.length === 0) {
-                    return { success: false, isError: true, error: available() };
-                }
-                return {
-                    success: true,
-                    data: utilities.map((u) => ({ name: u.name, description: utilityOneLiner(u.description) })),
-                };
-            case 'describe': {
-                const def = allUtilities.find((u) => u.name === input.name);
-                if (!def) {
-                    return { success: false, isError: true, error: `No utility "${String(input.name)}". ${available()}` };
-                }
-                if (!options.trustedModule) {
-                    const refusal = this.agentToolPermissionFailure(agentName, { ...call, name: def.name }, false);
-                    if (refusal)
-                        return refusal;
-                }
-                return { success: true, data: def };
-            }
-            case 'run': {
-                const def = allUtilities.find((u) => u.name === input.name);
-                if (!def) {
-                    return { success: false, isError: true, error: `No utility "${String(input.name)}", so nothing was done. ${available()}` };
-                }
-                if (!options.trustedModule) {
-                    // The allowed outer utils call owns its lifecycle and terminal trace;
-                    // refusing the utility does not create or refuse a separate call.
-                    const refusal = this.agentToolPermissionFailure(agentName, { ...call, name: def.name }, false);
-                    if (refusal)
-                        return refusal;
-                }
-                const args = input.args ?? {};
-                const problems = toolArgsProblems(args, def.inputSchema, { values: true, field: 'args' });
-                if (problems.length > 0) {
-                    // Teach by bounce: the error carries the schema, so the retry needs
-                    // no describe round-trip.
-                    return {
-                        success: false,
-                        isError: true,
-                        error: `Nothing was done: ${def.name} ${problems.join('; ')}. Schema for ${def.name}: ${JSON.stringify(def.inputSchema)}`,
-                    };
-                }
-                // Same dispatch as a first-class tool call — the module cannot tell
-                // which surface the call came through. The registry checks the call
-                // against the utility resolved here, even where one of the module's
-                // tools shares its name. An in-process caller gets the module's own
-                // result; the model's path takes the result's stored form.
-                //
-                // The result goes where the utils call's does. On the model's path it
-                // is stored or handed to a script as that call's result, so it may be
-                // as long as that call's may (resultMaxCharsFor). An in-process caller
-                // gets it back, and the utils call carries what that caller may take,
-                // if anything does: the puppet's carries the agent's cap, since the
-                // puppet stores the pair under it.
-                const resultMaxChars = options.inProcess ? call.resultMaxChars : this.resultMaxCharsFor(agentName, call.id);
-                const utilityCall = {
-                    id: call.id, name: def.name, input: args, callerAgentName: agentName,
-                    ...(call.callerTurnId !== undefined ? { callerTurnId: call.callerTurnId } : {}),
-                    ...(resultMaxChars !== undefined ? { resultMaxChars } : {}),
-                };
-                return options.inProcess
-                    ? this.moduleRegistry.handleToolCall(utilityCall, { definition: def })
-                    : this.moduleRegistry.storableToolCall(utilityCall, { definition: def });
-            }
-            default:
-                return { success: false, isError: true, error: 'action must be "list", "describe", or "run"' };
-        }
-    }
-    dispatchUtilsToolCall(agentName, call) {
-        this.emitTrace({ type: 'tool:started', module: 'framework', tool: 'utils', callId: call.id, input: call.input });
-        const startedAt = Date.now();
-        void this.handleUtilsToolCall(agentName, call)
-            .catch((err) => ({
-            success: false,
-            error: err instanceof Error ? err.message : String(err),
-            isError: true,
-        }))
-            .then((result) => {
-            if (result.success) {
-                this.emitTrace({ type: 'tool:completed', module: 'framework', tool: 'utils', callId: call.id, durationMs: Date.now() - startedAt });
-            }
-            else {
-                this.emitTrace({ type: 'tool:failed', module: 'framework', tool: 'utils', callId: call.id, error: result.error ?? 'unknown error' });
-            }
-            this.pushEvent({
-                type: 'tool-result',
-                callId: call.id,
-                toolName: call.name,
-                agentName,
-                moduleName: 'framework',
-                result,
-            });
-        });
-    }
     readAgentSettings(agentName, touched) {
         const s = this.getAgentRuntimeSettings(agentName);
         const saved = this.agents.get(agentName)?.getRuntimeSettingsOverrides() ?? {};
@@ -31326,4 +31960,11 @@ export class AgentFramework {
         };
     }
 }
+function thrownWords(error) {
+    if (error instanceof Refusal)
+        return error.message;
+    const code = errnoCode(error);
+    const on = errnoWayOn(code, "Calling again may work; if it fails the same way, whoever runs this host can find the whole error in this host's log.");
+    return `${systemWords(code, error).replace(/\.$/, '')}. ${on}`;
+}
 //# sourceMappingURL=framework.js.map