@animalabs/agent-framework 0.23.1 → 0.24.0

package/dist/src/mcpl/channel-registry.js

@@ -15,7 +15,7 @@
 import { convertBlock } from './convert-block.js';
 import { isDeepStrictEqual } from 'node:util';
 import { ensureStateRegistered } from '../module-registry.js';
-import { expandCoreTags } from './tags.js';
+import { expandCoreTags, isMarkerTagged } from './tags.js';
 import { coalesceRejectionReason, EmptyContentError, validateCoalescedContent } from './push-coalescer.js';
 import { isVisiblyEmptyConversion } from './visible-content.js';
 import { logDetail, logValue } from './log-value.js';
@@ -28,16 +28,52 @@ import { readSkipReplyWake } from './skip-reply-wake.js';
 // ============================================================================
 const TYPING_INTERVAL_MS = 7_000;
 const MAX_CHANNEL_LIFECYCLE_ATTEMPTS = 5;
-/** A successful RPC can still fail to establish the latest channel target. */
-class ChannelLifecycleConvergenceError extends Error {
-}
-/** A channels/open answered for a channel other than the one it named. */
-class ChannelOpenSubstitutionError extends Error {
-}
-/** An operation queued for a server's registrations that were removed. */
-class ChannelLifecycleCancelledError extends Error {
+/**
+ * A channel's lifecycle operation, or a delivery waiting on one, that didn't
+ * complete. Its message is a clause in the agent's words, which its traces
+ * carry too, so the two never drift apart; `kind` says what the agent can do
+ * next, and `reach` where the server stood, for `unreachable`.
+ * - `unreachable`: its server isn't up (ServerReach).
+ * - `not-permitted`: its server is up, and its grant lacks channels.lifecycle.
+ * - `cancelled`: queued for a server whose registrations were removed.
+ * - `unlisted`: the server no longer lists the channel.
+ * - `superseded`: a later decision about the channel came first.
+ * - `converge`: a successful RPC kept failing to establish the latest target.
+ * - `substituted`: a channels/open answered for a channel other than the one
+ *   it named.
+ * - `removed`, `not-open`: a delivery's wait (waitForOpenChannel) ended with
+ *   the channel's registration gone, or with its close standing
+ *   (closeStands) or its open not confirmed. These are whole reasons for
+ *   words that didn't go out, said as they are.
+ * - `unrecorded`: the decision couldn't be written to the lifecycle log
+ *   (appendLifecycleEvent), so nothing changed and nothing was sent.
+ * - `overtaken`, `put-back-unrecorded`, `selected-again`: an open by speech
+ *   or a reply that failed (openChannelNow), carrying its own failure's
+ *   clause. `overtaken`: a decision made during its round-trip, such as the
+ *   agent's own close or channel_open, replaced the one the open wrote; that
+ *   decision stands, and nothing is put back. `put-back-unrecorded`: the
+ *   decision it replaced couldn't be put back on record, so the decision to
+ *   open stays, the channel stays selected for opening, and reconciliation
+ *   may open it later. `selected-again`: the pure default it put back is
+ *   lifted by the channel's current descriptor or the subscription policy,
+ *   so the channel is selected for opening again; `by` says which.
+ */
+class ChannelLifecycleError extends Error {
+    kind;
+    reach;
+    by;
+    constructor(message, kind, reach, options) {
+        super(message, options && 'cause' in options ? { cause: options.cause } : undefined);
+        this.kind = kind;
+        this.reach = reach;
+        this.name = 'ChannelLifecycleError';
+        this.by = options?.by;
+    }
 }
 const CHANNEL_LIFECYCLE_LOG_ID = 'mcpl/channel-lifecycle';
+/** The sources of a decision the agent itself made: channel_open and
+ *  channel_close, and channel_decline. */
+const AGENT_DECISION_SOURCES = new Set(['agent-tool', 'invitation-declined']);
 /**
  * What a channels/open answer says about which channel the server opened:
  * its `channel.id`, or else the `channelId` of a history item. Each is
@@ -74,6 +110,43 @@ function substitutedChannel(result, requested) {
  * `resolveProseTargetDurable`.
  */
 const CHANNEL_LABEL_HISTORY_LOG_ID = 'mcpl/channel-label-history';
+/** A lifecycle-log item as a desired-state decision, or null when it isn't
+ *  one this build reads: the one rule the registry's replay
+ *  (initializeLifecycleStore) and desiredStateInLog read the log by. */
+function desiredStateRecord(item) {
+    const event = item;
+    if (event?.kind !== 'desired-state' || typeof event.serverId !== 'string' || typeof event.channelId !== 'string')
+        return null;
+    if (!(event.desired === 'open' || event.desired === 'closed' || (event.desired === 'tuned-out' && event.tuneOut)))
+        return null;
+    return {
+        serverId: event.serverId,
+        channelId: event.channelId,
+        state: event.desired,
+        source: typeof event.source === 'string' ? event.source : 'unknown',
+        ...(event.desired === 'tuned-out' ? { tuneOut: event.tuneOut } : {}),
+    };
+}
+/**
+ * The desired state `store`'s lifecycle log records for `channelId` on
+ * `serverId`, for a reader with no registry yet, as a serving boot's
+ * deferred-write flush is, before initializeMcpl: the last decision wins, as
+ * the registry's replay reads it (getDesiredState answers once there is a
+ * registry). undefined when no decision names it.
+ */
+export function desiredStateInLog(store, serverId, channelId) {
+    ensureStateRegistered(store, { id: CHANNEL_LIFECYCLE_LOG_ID, strategy: 'append_log' });
+    const raw = store.getStateJson(CHANNEL_LIFECYCLE_LOG_ID);
+    if (!Array.isArray(raw))
+        return undefined;
+    let state;
+    for (const item of raw) {
+        const decision = desiredStateRecord(item);
+        if (decision?.serverId === serverId && decision.channelId === channelId)
+            state = decision.state;
+    }
+    return state;
+}
 /** Extract a DM's identity/classification fields from a descriptor's
  *  metadata, if present — mirrors `resolveProseTarget()`'s own local
  *  `dmMeta()` read (`recipientId`, `recipientName`, `channelType`). Used
@@ -121,6 +194,25 @@ function shallowEqualRecord(a, b) {
     }
     return true;
 }
+/**
+ * A channel its server declared inbound-only (SPEC §14.2 `direction`): its
+ * messages come in, and the host publishes nothing into it. No publish, from
+ * plain speech, `channel_publish` or `publishForAgent`, and no outgoing
+ * stream starts there, though one the channel took before the declaration
+ * ends there (sendOutgoingChunk). Typing and acknowledgements, which carry
+ * no content, still go (SPEC §14.5: "Delivery occurs only via
+ * `channels/publish`"). A channel declared `outbound` or `bidirectional`, or
+ * with no direction, isn't one.
+ */
+function isInboundOnly(entry) {
+    return entry.descriptor.direction === 'inbound';
+}
+/** Why the host sends nothing into an inbound-only channel, as the resident
+ *  reads it in a send-failure marker or a tool error. */
+function inboundOnlyReason(entry) {
+    return (`inbound-only: server "${entry.serverId}" declared this channel's direction "inbound", ` +
+        'so the host publishes nothing into it; to speak there, use that server\'s own tools');
+}
 function sameChannelTarget(a, b) {
     return a.type === b.type && isDeepStrictEqual(a.address, b.address);
 }
@@ -140,6 +232,30 @@ export function journalToolDescription(canSkipReply) {
         'why, notes for later. It does not end your turn and does not affect where ordinary ' +
         'text is routed' + (canSkipReply ? '; to end the turn without replying, call skip_reply afterwards.' : '.');
 }
+/**
+ * channel_open's and channel_close's descriptions for an agent whose window doesn't hold a channel's traffic: an
+ * ephemeral run, whose store is its own unless it's where channel messages are stored (on a host with no residents,
+ * the first registered agent), and on a host that routes conversations every agent but a fork, since a channel's
+ * messages go to its fork or, unrouted, nowhere. The descriptions in CHANNEL_TOOL_DEFINITIONS, written for the agents
+ * that read a channel, promised such an agent what it never gets: "Messages that address you still reach you", and
+ * history "preceding the message that invited you" when nothing invites it. Given per agent (AgentFramework's
+ * getToolsForAgent), so a holder's cached tool list doesn't change.
+ *
+ * Both say the call is for every agent: the decision is recorded per server and channel (setDesiredState), so a run's
+ * close closes the channel for the agents whose windows hold it, which "its messages don't come to you" alone could
+ * read as costing nothing. They claim only what holds on both lanes: a push that names a channel is stored in the
+ * residents' shared slot whether or not the channel is open (handleMcplPushEvent), so on a routed host the residents
+ * get the channel's pushes, and a server may push while a channel is closed and send channels/incoming once it's
+ * open. So opening brings the caller none of the channel's messages, and closing stops none reaching it. The history
+ * channel_open asks for comes back in its result (handleToolOpen), so that clause is true for anyone.
+ */
+export const NON_HOLDER_CHANNEL_DESCRIPTIONS = {
+    channel_open: 'Open a channel for every agent on this host. Opening it brings you none of its messages; for the agents they do ' +
+        'come to, its server decides what it delivers. Optionally request some of its history, which comes back to you in ' +
+        'this call.',
+    channel_close: 'Close a channel for every agent on this host. Closing it stops none of its messages reaching you; for the agents ' +
+        'they do come to, its server decides what closing it stops.',
+};
 const CHANNEL_TOOL_DEFINITIONS = [
     {
         name: 'channel_list',
@@ -201,11 +317,11 @@ const CHANNEL_TOOL_DEFINITIONS = [
     },
     {
         name: 'channel_publish',
-        description: 'Publish a message to a channel. If channelId is omitted, publishes to the channel this conversation is bound to, if any, else to the most recent incoming channel. A subagent has neither, and must name one.',
+        description: "Publish a message to a channel. If channelId is omitted, publishes to your conversation's channel if you are bound to one; otherwise to the channel of the most recent incoming message this host received on any channel, whether or not you've been shown it. Reactions, reaction removals, deletions and edits don't set it, though an edit of a message you hadn't been shown can count as that message. A message pushed to you rather than posted on a channel never sets it. A subagent has neither default, so it must name a channel.",
         inputSchema: {
             type: 'object',
             properties: {
-                channelId: { type: 'string', description: 'ID of the channel to publish to (defaults to the conversation\'s bound channel, else the most recent incoming channel; required of a subagent)' },
+                channelId: { type: 'string', description: "ID of the channel to publish to (defaults to your conversation's channel if you are bound to one; otherwise the channel of the most recent incoming message this host received on any channel, whether or not you've been shown it, other than a reaction, reaction removal, deletion or edit, though an edit of a message you hadn't been shown can count; a message pushed to you rather than posted on a channel never sets it; required of a subagent)" },
                 content: { type: 'string', description: 'Text content to publish' },
                 text: { type: 'string', description: 'Alias for content' },
             },
@@ -275,7 +391,8 @@ const CHANNEL_TOOL_DEFINITIONS = [
 // Constructor Options
 // ============================================================================
 /** Bound connector values for notices, logs and an outcome's reason. A
- *  PublishOutcome keeps the connector's structured data (`detail`) whole. */
+ *  PublishOutcome keeps the connector's structured data (`detail`) as the
+ *  connection gives it, its strings redacted (redactedData). */
 export function connectorText(value) {
     let text;
     try {
@@ -288,6 +405,140 @@ export function connectorText(value) {
     const suffix = '… [truncated]';
     return text.length > limit ? text.slice(0, limit - suffix.length) + suffix : text;
 }
+/** One key per destination, its server and channel: unlike joining the two
+ *  with a separator, no two destinations share one, whatever their ids hold. */
+export function destinationKey(to) {
+    return JSON.stringify([to.serverId, to.channelId]);
+}
+/**
+ * A failed request's words, bounded, for a reason that a caller composes.
+ * This host's own words, for a request that wasn't sent or wasn't answered
+ * or for an error of its own, such as its store's, are sentences, and every
+ * composition of a reason adds its own ending, so one final period comes
+ * off them. A server's error answer keeps its words as they came.
+ */
+function requestErrorText(err) {
+    const text = connectorText(err instanceof Error ? err.message : String(err));
+    return err instanceof McplRequestError && err.outcome === 'error-response' ? text : text.replace(/(?<!\.)\.$/, '');
+}
+/** A server that isn't up (ServerReach), as a clause the agent reads. */
+function unreachableClause(serverId, reach) {
+    switch (reach) {
+        case 'gone': return `the "${serverId}" server isn't connected, and this host won't reconnect to it on its own`;
+        case 'connecting': return `this host is connecting to the "${serverId}" server`;
+        case 'down': return `the "${serverId}" server isn't connected, and this host is reconnecting to it`;
+    }
+}
+/** What helps when a server isn't up (ServerReach), as the end of the
+ *  clause that says so. */
+function unreachableRemedy(reach) {
+    switch (reach) {
+        case 'gone': return '; if you need it, ask whoever runs this host';
+        case 'connecting': return ', so try again in a moment';
+        case 'down': return ', so try again later';
+    }
+}
+/** Whether an entry's descriptor carries the key a push's placeholder has
+ *  (ensureChannelRegistered's lazyRegistered metadata), as main reads it for
+ *  whether the server has declared the channel: a registration or a
+ *  channels/changed update brings the server's own descriptor, which
+ *  doesn't normally carry it. The traffic rule doesn't read it, since a
+ *  server's descriptor can (untargetedPushEntries). */
+function pushPlaceholder(entry) {
+    return entry.descriptor.metadata?.lazyRegistered === true;
+}
+/** When reconciling applies a recorded decision: at the server's next
+ *  registration of the channel, where this host directs its channels'
+ *  lifecycle then (reconcileChannels, §14.1). A channel made from a push
+ *  may never be registered at all, so for one the text says "if". */
+function laterClause(entry) {
+    return pushPlaceholder(entry)
+        ? `if the "${entry.serverId}" server registers this channel at a time this host may open and close its channels`
+        : `when the "${entry.serverId}" server next registers this channel, if this host may open and close its channels then`;
+}
+/** A channel decision the lifecycle log refused to append, as on a full
+ *  disk: nothing changed (appendLifecycleEvent). */
+function unrecordedDecision(err) {
+    return new ChannelLifecycleError(`this host couldn't record the decision: ${requestErrorText(err)}`, 'unrecorded');
+}
+/** A failure's clause, then more said of the same failure. A server's own
+ *  words keep their final stop (requestErrorText), so after them the rest
+ *  is a sentence of its own. */
+function afterClause(clause, more) {
+    return /[.!?]$/.test(clause) ? `${clause} ${more.charAt(0).toUpperCase()}${more.slice(1)}` : `${clause}; ${more}`;
+}
+/** A lifecycle failure as a clause: its own words, or its request's. */
+function lifecycleClause(err) {
+    return err instanceof ChannelLifecycleError ? err.message : requestErrorText(err);
+}
+/** Why words didn't go out when their channel's registration went away
+ *  first, at a delivery's wait or at its last check. */
+const CHANNEL_REMOVED_CLAUSE = 'the channel was removed before these words went out';
+/** A tune-out's open answered for a tune-out that ended, or that a later
+ *  decision or a later tune-out replaced, while the open was out: by
+ *  openForTuneOut, and by a repeated tune_out whose tune-out isn't the one it
+ *  read before it waited. */
+export const TUNE_OUT_REPLACED = "The tune-out was recorded, but it isn't in effect any more: it ended, or a later " +
+    'decision about the channel or a later tune-out replaced it, while its transport was being opened.';
+/**
+ * Why words a send opened their channel for didn't go out. The delivery's
+ * wait after the open says it whole (`removed`, `not-open`). The open's own
+ * failure is said as one, with what helps where there's a step to take. It
+ * names no state of the channel's transport: one decided closed can still
+ * be open, after a close that failed.
+ */
+function openFailedReason(err) {
+    if (err instanceof ChannelLifecycleError && (err.kind === 'removed' || err.kind === 'not-open'))
+        return err.message;
+    return `opening the channel for these words didn't complete: ${lifecycleClause(err)}${refusalRemedy(err)}`;
+}
+/** What helps after a lifecycle failure, as the end of the clause that says
+ *  it: the server state's remedy, whom to ask for a grant, or another try
+ *  where the channel's target kept changing or the decision couldn't be
+ *  recorded. Nothing for any other failure. */
+function refusalRemedy(err) {
+    if (!(err instanceof ChannelLifecycleError))
+        return '';
+    if (err.kind === 'unreachable' && err.reach)
+        return unreachableRemedy(err.reach);
+    if (err.kind === 'not-permitted')
+        return '; if you need it, ask whoever runs this host';
+    if (err.kind === 'converge')
+        return ', so try again';
+    if (err.kind === 'unrecorded')
+        return ', so try again; if it fails the same way, ask whoever runs this host';
+    return '';
+}
+/** Why an open or a close doesn't stand when a later decision about the
+ *  channel came first (`now`, its desired state since). */
+function supersededClause(action, now) {
+    if (now === 'tuned-out')
+        return 'it was tuned out meanwhile';
+    return action === 'close' ? 'a later decision to keep it open came first' : 'a later decision to close it came first';
+}
+/** A channel tool's refusal of a tuned-out channel, whose cancel is what ends
+ *  the tune-out, with the backlog it delivers. As an error result the agent
+ *  reads the pointer itself; `data` names the refusal for an in-process
+ *  caller. */
+function tunedOutRefusal(tool, channelId) {
+    return {
+        success: false,
+        isError: true,
+        error: `Channel "${channelId}" is tuned out: its messages go to the subconscious, and ${tool} doesn't change that. ` +
+            `Call tune_out with channelId "${channelId}" and mode "cancel" for it to resume normal attention; cancelling ` +
+            'delivers the diverted backlog.',
+        data: { refusal: 'tuned-out', channelId },
+    };
+}
+/** A clause as the start of a sentence. */
+function sentenceStart(clause) {
+    return clause.charAt(0).toUpperCase() + clause.slice(1);
+}
+/** Words as a sentence's end: a stop, unless they end in one already, as a
+ *  server's own words may. */
+function withStop(text) {
+    return /[.!?]$/.test(text) ? text : `${text}.`;
+}
 /**
  * What a channels/publish request that threw establishes. Only a request
  * that never left the host proves nothing was posted. An error response may
@@ -297,12 +548,7 @@ export function connectorText(value) {
  * a failed request this way.
  */
 function publishErrorOutcome(err, destination, at) {
-    // This host's own words for a request that wasn't sent or wasn't answered
-    // are sentences, and every composition of the reason adds its own ending,
-    // so one final period comes off them. A server's error answer keeps its
-    // words as they came.
-    const text = connectorText(err instanceof Error ? err.message : String(err));
-    const message = err instanceof McplRequestError && err.outcome !== 'error-response' ? text.replace(/(?<!\.)\.$/, '') : text;
+    const message = requestErrorText(err);
     const notSent = err instanceof McplRequestError && err.outcome === 'not-sent';
     const detail = err instanceof McplRequestError ? err.data : undefined;
     return {
@@ -330,16 +576,17 @@ function publishReceiptOutcome(result, destination, at) {
     }
     if (receipt.delivered === false) {
         if (receipt.messageId === undefined || receipt.messageId === null) {
-            return { status: 'failed', destination, reason: `server "${destination.serverId}" reported delivered:false`, at };
+            return { status: 'failed', destination, reason: `the "${destination.serverId}" server said it didn't post the message`, at };
         }
         return {
             status: 'unknown',
             destination,
             ...(messageId ? { messageId } : {}),
             reason: messageId
-                ? `server "${destination.serverId}" reported delivered:false but named posted message ${connectorText(messageId)} (delivery uncertain)`
-                : `server "${destination.serverId}" reported delivered:false beside a malformed message id ` +
-                    `${connectorText(receipt.messageId)} (contradictory receipt; delivery uncertain)`,
+                ? `the "${destination.serverId}" server said it didn't post the message, yet named message ` +
+                    `${connectorText(messageId)} as posted (delivery uncertain)`
+                : `the "${destination.serverId}" server said it didn't post the message, along with a message id that ` +
+                    `isn't valid (${connectorText(receipt.messageId)}) (delivery uncertain)`,
             at,
         };
     }
@@ -347,7 +594,7 @@ function publishReceiptOutcome(result, destination, at) {
         status: 'unknown',
         destination,
         ...(messageId ? { messageId } : {}),
-        reason: `server "${destination.serverId}" returned no valid delivery receipt (delivery uncertain)`,
+        reason: `the "${destination.serverId}" server's answer didn't say whether it posted the message (delivery uncertain)`,
         at,
     };
 }
@@ -367,9 +614,17 @@ export class ChannelRegistry {
     homeChannelResolver;
     activeChannelResolver;
     takesGlobalFallback;
+    serverConnecting;
     store;
     /** Registered channels, keyed by `{serverId}:{channelId}`. */
     channels = new Map();
+    /**
+     * Each outgoing stream, by `inferenceId`, with the destinations it has
+     * started at (destinationKey): the rest of the stream there goes on there,
+     * and its `complete` goes only there (sendOutgoingChunk). An entry goes
+     * with the stream's `complete` for its destination.
+     */
+    takenStreams = new Map();
     /** Holds back repeats of the line for a message refused because its
      *  channel isn't registered (RefusalLines). */
     unknownChannelLines = new RefusalLines();
@@ -418,9 +673,12 @@ export class ChannelRegistry {
      * sent at all.
      */
     dmClassified = new Map();
-    /** Most recent incoming channel ID — used for speech routing / default publish. */
+    /** The channel of the most recent incoming message that isn't a reaction,
+     *  reaction removal, edit or deletion marker, apart from an edit the
+     *  coalescer delivers on acceptance as the agent's first view: used for
+     *  speech routing and the default publish. */
     defaultPublishChannel = null;
-    /** Most recent incoming message metadata, used for buildChannelContext. */
+    /** The same message's id and thread, used for buildChannelContext. */
     defaultPublishMessageId = null;
     defaultPublishThreadId = undefined;
     /** Per-channel typing indicator timers. */
@@ -447,9 +705,31 @@ export class ChannelRegistry {
     // target before confirming anything. Unlike the tail, which settles a few
     // microtasks after its operation's last check, this drops at that check.
     lifecycleOutstanding = new Map();
+    // The removal count each channel's newest outstanding operation was queued
+    // under. Where it's older than its server's, every operation still
+    // outstanding for the channel cancels when it would run.
+    lifecycleQueuedRemovals = new Map();
     // Losing an open receipt does not confirm closure. Keep that distinction
     // private while preserving the public open:boolean availability projection.
     unconfirmedChannelTargets = new WeakSet();
+    // Marked entries a close failed for since a receipt or traffic last
+    // confirmed them, cleared where the mark is: a failed request's outcome is
+    // unknown, so such a close may have closed the channel, where an open,
+    // failed or not, can't have. Only a tune-out reads it (openForTuneOut),
+    // since its success says the channel's traffic will arrive.
+    failedCloseTargets = new WeakSet();
+    // Each tune-out's open in flight, by channel and epoch, so tune_out
+    // repeated meanwhile waits for that open's answer rather than send another.
+    tuneOutOpens = new Map();
+    // Entries ensureChannelRegistered made from a push, until a channels/changed
+    // update gives one a target (handleChanged's retarget). A registration makes
+    // a new entry, which isn't here. Kept by the host, not read from the
+    // descriptor, whose metadata a server's own registration supplies.
+    untargetedPushEntries = new WeakSet();
+    // How many times each server's transport has closed (transportClosed).
+    // handleIncoming reads it as a batch arrives, so traffic admitted after a
+    // close it arrived before confirms nothing.
+    transportCloses = new Map();
     invalidateTransportConfirmation(entry) {
         entry.open = false;
         this.unconfirmedChannelTargets.add(entry);
@@ -460,12 +740,195 @@ export class ChannelRegistry {
     directsLifecycle(serverId) {
         return CapabilityGrant.of(this.serverRegistry.getServer(serverId)).has('channels.lifecycle');
     }
-    /** A registration's entry: nothing about its transport is known until a
-     *  receipt for its target confirms it open or closed. */
+    /** Whether a decided close holds words back from a channel: only where
+     *  the host directs the server's lifecycle. Without that grant the host
+     *  can't close the channel, and words go into a transport that is open,
+     *  as the open step's engagesDecidedClosed reads it too. */
+    closeStands(entry) {
+        return this.getDesiredState(entry.serverId, entry.descriptor.id) === 'closed' &&
+            this.directsLifecycle(entry.serverId);
+    }
+    /** Where this server stands for a request this host would make of it
+     *  (ServerReach). One without a connection's state reads as connected.
+     *  A closed connection the host is restarting reads as connecting, as
+     *  one being connected does. */
+    serverReach(serverId) {
+        const server = this.serverRegistry.getServer(serverId);
+        const connecting = this.serverConnecting?.(serverId) ?? false;
+        if (!server)
+            return connecting ? 'connecting' : 'gone';
+        if (server.isConnected === false)
+            return connecting ? 'connecting' : server.willReconnect ? 'down' : 'gone';
+        return connecting ? 'connecting' : 'up';
+    }
+    /**
+     * Why this host won't open or close this server's channels, for a caller
+     * that found its grant without channels.lifecycle (§14.1), which decides:
+     * the server's state says why. It isn't up, or it's up without that grant.
+     * Neither the grant's name, which is the operator's, nor an empty grant's
+     * refusal, which needn't be the server's, reaches the agent.
+     */
+    lifecycleRefusal(serverId) {
+        const reach = this.serverReach(serverId);
+        if (reach !== 'up')
+            return new ChannelLifecycleError(unreachableClause(serverId, reach), 'unreachable', reach);
+        return new ChannelLifecycleError(`this host isn't permitted to open or close the "${serverId}" server's channels`, 'not-permitted');
+    }
+    /**
+     * Why a send to this server's channels is refused before anything goes
+     * out, as one clause with what works from there, for a caller that found
+     * no server or a grant without channels.publish (§14.1), which decides:
+     * the server's state says why. Plain speech gives it as its reason, and
+     * channel_publish and speak_in_channel as theirs, so one refusal has one
+     * wording. `checked` is the connection whose grant refused, where that
+     * was read before the words waited: one the registry has replaced since
+     * says nothing about the server that stands now.
+     */
+    sendRefusal(serverId, checked) {
+        const now = this.serverRegistry.getServer(serverId);
+        const reach = this.serverReach(serverId);
+        // A replacement that would take the words is worth another try; one
+        // that wouldn't is worded as it stands.
+        if (checked && now && now !== checked && reach === 'up' && CapabilityGrant.of(now).has('channels.publish')) {
+            return `the "${serverId}" server's connection was replaced while these words waited, so try again`;
+        }
+        if (reach !== 'up')
+            return unreachableClause(serverId, reach) + unreachableRemedy(reach);
+        return `this host isn't permitted to post to the "${serverId}" server's channels, and trying again won't change that; ` +
+            'if you need it, ask whoever runs this host';
+    }
+    /**
+     * What a failed channel_open or channel_close tells the agent. Its
+     * decision was recorded before the server was asked, and reconciling
+     * applies it when the server next registers the channel (for a push's
+     * placeholder, if it ever does), if this host directs their lifecycle then
+     * (laterClause). A decision the log refused changed nothing, so that comes
+     * first. A channel no longer registered
+     * can't be reached by any channel tool, so its text names none. A later
+     * decision that came first is what stands, so that comes next. Then the
+     * server's state: one that isn't up gets the change when it's back, though
+     * not a backscroll's history. For the request's own failure, its state is
+     * read now, since a request out when the server dropped may have taken
+     * effect, and reconciling settles it either way. A decision already in
+     * effect, with no other work for the channel under way, says so, as one
+     * whose backscroll alone failed is. Then the failure's kind, since each
+     * has its own next step (ChannelLifecycleError). A request's own failure
+     * is in the connection's words.
+     */
+    lifecycleFailureText(action, entry, err, opts) {
+        const channel = `"${entry.descriptor.id}"`;
+        const tool = action === 'open' ? 'channel_open' : 'channel_close';
+        const done = action === 'open' ? 'opened' : 'closed';
+        const later = laterClause(entry);
+        // A decision never recorded is no decision a later one overtook, and
+        // nothing about the channel changed, whatever its transport's state.
+        if (err instanceof ChannelLifecycleError && err.kind === 'unrecorded') {
+            return `Nothing changed for channel ${channel}: ${err.message}, so nothing was sent to the server. ` +
+                `Calling ${tool} again tries again; if it fails the same way, ask whoever runs this host.`;
+        }
+        const failure = err instanceof ChannelLifecycleError ? err : undefined;
+        const now = this.getDesiredState(entry.serverId, entry.descriptor.id);
+        const current = this.channels.get(`${entry.serverId}:${entry.descriptor.id}`);
+        if (!current) {
+            // Its registration may have gone at the server's word or at this
+            // host's (removeServer). Only a failure that says which (cancelled,
+            // unlisted) names it; otherwise the server's state where it isn't up,
+            // and a request's own words where it failed with them. Another
+            // failure's words are about a request whose channel is gone.
+            const reach = this.serverReach(entry.serverId);
+            const why = failure?.kind === 'cancelled' || failure?.kind === 'unlisted' ? `: ${failure.message}`
+                : reach !== 'up' ? `: ${unreachableClause(entry.serverId, reach)}` : '';
+            // A tune-out is in effect already: only its transport waits for the
+            // server's next registration.
+            const stays = now === 'tuned-out' ? 'It was tuned out meanwhile, and that stays recorded.'
+                : `Its ${now === 'closed' ? 'close' : 'open'} stays recorded, and happens ${later}.`;
+            return `Channel ${channel} isn't registered here any more${why}. ${stays}` +
+                (reach === 'gone' ? ' If you need the server back, ask whoever runs this host.' : '') +
+                (failure === undefined ? ` ${withStop(lifecycleClause(err))}` : '');
+        }
+        // A tune-out sends the channel's messages to the subconscious, and
+        // channel_open refuses a tuned-out channel.
+        if (action === 'open' ? now !== 'open' : now !== 'closed') {
+            if (action === 'open' && now === 'tuned-out') {
+                return `Channel ${channel} was tuned out meanwhile: its messages go to the subconscious, and channel_open doesn't ` +
+                    `change that. Call tune_out with channelId ${channel} and mode "cancel" for it to resume normal attention.`;
+            }
+            // The later decision's own work settles the transport, and its call
+            // says what became of it, so this says only that this call's change
+            // doesn't stand.
+            return `Channel ${channel}: ${supersededClause(action, now)}, so this ${action} doesn't stand. Call ${tool} again to ` +
+                `${action} it.`;
+        }
+        const reach = failure ? (failure.kind === 'unreachable' ? failure.reach : undefined) : this.serverReach(entry.serverId);
+        if (reach !== undefined && reach !== 'up') {
+            // Reconciling opens a channel, but asks for no history.
+            const history = action === 'open' && opts?.history;
+            return `${sentenceStart(unreachableClause(entry.serverId, reach))}, so channel ${channel} may not be ` +
+                `${action === 'open' ? 'open' : 'closed'} there yet. The ${action} is recorded and happens ${later}` +
+                (history
+                    ? ', but the history you asked for doesn\'t come with it: calling channel_open with backscroll once the server is ' +
+                        'connected asks for it.'
+                    : `, so there's no need to call ${tool} again.`) +
+                (reach === 'gone' ? ' If you need the server back, ask whoever runs this host.' : '') +
+                (action === 'open' ? ' channel_close withdraws it.' : '');
+        }
+        const said = lifecycleClause(err);
+        // Other work for the channel still under way (lifecycleOutstanding,
+        // released as each operation's last look ends) may change its state.
+        const settled = !this.lifecycleOutstanding.has(this.lifecycleKey(entry.serverId, entry.descriptor.id));
+        // The registry's own reading, as its checks make it (channel_open's
+        // already-open return, the decline's refusal, delivery): a request that
+        // failed leaves the open flag as it was, and the unconfirmed mark counts
+        // only while the channel isn't open (runLifecycleOperation).
+        const inEffect = current !== undefined && settled && (action === 'open'
+            ? current.open
+            : !current.open && !this.unconfirmedChannelTargets.has(current));
+        if (inEffect) {
+            // What was asked already holds. Without the grant, nothing more can be
+            // asked of the server, so calling again won't change anything.
+            const state = `Channel ${channel} is ${action === 'open' ? 'open' : 'closed'}`;
+            if (action === 'open' && opts?.history) {
+                return failure?.kind === 'not-permitted'
+                    ? `${state}, but the history you asked for didn't come: ${failure.message}, so calling channel_open again ` +
+                        "won't change that. If you need it, ask whoever runs this host."
+                    : withStop(`${state}, but the history you asked for didn't come: ${said}`) +
+                        ' Calling channel_open again with backscroll tries once more.';
+            }
+            return failure?.kind === 'not-permitted'
+                ? `${state}. ${sentenceStart(failure.message)}, so it sent the server nothing.`
+                : withStop(`${state}, though this call didn't complete: ${said}`);
+        }
+        switch (failure?.kind) {
+            case 'not-permitted':
+                // The decision was recorded before the refusal, and reconciling
+                // applies it at a registration whose grant allows it.
+                return `${sentenceStart(failure.message)}, so this ${action} of channel ${channel} didn't go through, and calling ${tool} ` +
+                    `again won't change that. The ${action} stays recorded, and happens ${later}. If you need it, ask whoever runs this host.`;
+            case 'cancelled':
+            case 'unlisted':
+                return `Channel ${channel} wasn't ${done}: ${failure.message}. The ${action} stays recorded, and happens ${later}.`;
+            case 'converge':
+                return `Channel ${channel} wasn't ${done}: ${failure.message}. The ${action} stays recorded, and calling ${tool} again ` +
+                    'tries once more.';
+            case 'substituted':
+                // Only an open is answered for another channel.
+                return `Channel ${channel} wasn't ${done}: ${failure.message}. The ${action} stays recorded, and this host tries it ` +
+                    `again ${later}; calling ${tool} again is likely to get the same answer. channel_close withdraws it.`;
+        }
+        return `${action === 'open' ? 'Opening' : 'Closing'} channel ${channel} didn't complete; the ${action} stays recorded, and this ` +
+            `host tries it again ${later}, or now if you call ${tool} again. ${withStop(said)}`;
+    }
+    /** A registration's entry, or a push's (ensureChannelRegistered): nothing
+     *  about its transport is known until a receipt for its target confirms it
+     *  open or closed, or the channel's traffic shows it open, which it does
+     *  where the host doesn't direct the lifecycle, and for a push's entry
+     *  decided open or tuned out that no update has given a target
+     *  (handleIncoming). */
     registerEntry(key, serverId, descriptor) {
         const entry = { serverId, descriptor, open: false };
         this.channels.set(key, entry);
         this.unconfirmedChannelTargets.add(entry);
+        return entry;
     }
     hasPendingLifecycle(entry) {
         return this.channelLifecycleTails.has(this.lifecycleKey(entry.serverId, entry.descriptor.id));
@@ -498,6 +961,7 @@ export class ChannelRegistry {
         this.homeChannelResolver = options?.homeChannelResolver;
         this.activeChannelResolver = options?.activeChannelResolver;
         this.takesGlobalFallback = options?.takesGlobalFallback;
+        this.serverConnecting = options?.serverConnecting;
         this.store = options?.store;
         this.initializeLifecycleStore();
         this.initializeLabelHistoryStore();
@@ -600,13 +1064,16 @@ export class ChannelRegistry {
                 // channel decided open (or tuned out) is opened at its new target.
                 if (!sameChannelTarget(existing.descriptor, channel)) {
                     this.invalidateTransportConfirmation(existing);
+                    this.untargetedPushEntries.delete(existing);
                     // An operation queued or running for this channel reads its target
                     // again before it confirms anything, and after a failed RPC, so it
-                    // opens the new one. With none, a channel decided open (or tuned
-                    // out) is reconciled here.
+                    // opens the new one, unless it was queued before its server's
+                    // registrations were last removed: that one cancels when it would
+                    // run. So a channel decided open (or tuned out) is reconciled here
+                    // unless work queued since then is outstanding.
                     const desired = this.getDesiredState(serverId, channel.id);
                     if ((desired === 'open' || desired === 'tuned-out') &&
-                        !this.lifecycleOutstanding.has(this.lifecycleKey(serverId, channel.id))) {
+                        !this.outstandingWorkCarriesOut(serverId, this.lifecycleKey(serverId, channel.id))) {
                         retargeted.push(channel);
                     }
                 }
@@ -689,6 +1156,9 @@ export class ChannelRegistry {
      */
     async handleIncoming(serverId, params, responder) {
         const results = [];
+        // The batch came on the transport open now: a close after this point
+        // (transportClosed) leaves its traffic nothing to confirm.
+        const closesAtArrival = this.transportCloses.get(serverId) ?? 0;
         for (const message of params.messages) {
             if (!message || typeof message.channelId !== 'string' || !message.channelId
                 || typeof message.messageId !== 'string' || !message.messageId) {
@@ -714,17 +1184,6 @@ export class ChannelRegistry {
             // conversion — decoding an unregistered sender's payload (including
             // inline base64) is allocation and parsing work done for a message
             // that must be rejected (Sol, PR #79 re-review blocker 2).
-            // Lazy-register the channel if we've never seen it. A channel can deliver
-            // an incoming message before its channels/register (boot enumeration) or
-            // channels/changed (post-boot create / View-permission grant) round-trip
-            // lands — or the registration event can be missed entirely (e.g. the bot
-            // gains visibility in a way that fires neither `channelCreate` nor a
-            // View-permission transition). Without a registry entry, routeSpeech()
-            // can't resolve this channel as an outbound locus and the agent's reply
-            // is silently dropped, even though this very message proves the channel
-            // is reachable. The inbound message carries enough to make it publishable,
-            // so register it here; a later authoritative channels/register or
-            // channels/changed will overwrite this descriptor with the richer one.
             // §14.5: channels/incoming is validated against the ACTUALLY
             // REGISTERED channel. An unknown claimed channelId is rejected
             // per-message with an itemized result — never minted by its first
@@ -732,8 +1191,8 @@ export class ChannelRegistry {
             // self-attest a channel identity without ever passing
             // channels/register authorization). A server whose channel genuinely
             // exists registers it first; discord's DM case goes through
-            // ensureChannelRegistered on push/event, which creates a CLOSED
-            // routable entry rather than an open self-attested one.
+            // ensureChannelRegistered on push/event, which creates a routable
+            // entry that isn't open, rather than an open self-attested one.
             const incomingKey = `${serverId}:${message.channelId}`;
             if (!this.channels.has(incomingKey)) {
                 // Loud, coalesced or not, like every other refusal of a message, but
@@ -809,32 +1268,50 @@ export class ChannelRegistry {
             // A coalesced item is "accepted" only once the coalescer admits it, so
             // for those this runs after the hook (below).
             const incomingEntry = this.channels.get(incomingKey);
-            const markAccepted = () => {
-                this.defaultPublishChannel = message.channelId;
-                this.defaultPublishMessageId = message.messageId;
-                this.defaultPublishThreadId = message.threadId;
-                // Where the host directs this server's lifecycle, only a receipt for
-                // the current target confirms it: traffic shows the transport open
-                // only for a confirmed target, and only for a channel still decided
-                // open or tuned out. After a retarget, traffic for this id may still
-                // come from the old subscription, and a close receipt that landed
-                // first (or during the coalescer's await) stands. Where the host
-                // doesn't direct it, the server opens its own channels and its
-                // traffic is the only evidence the host gets, so it marks the
+            const markAccepted = (firstView = false) => {
+                // Non-conversational markers (a reaction added or removed, an edit, a
+                // deletion) are ABOUT a message, not one the agent replies to: they
+                // must not retarget the default publish locus or become
+                // `context.incoming`'s reply anchor. An edit the coalescer delivered
+                // as the agent's first view counts as the message it replaced.
+                if (!isMarkerTagged(message.tags, firstView)) {
+                    this.defaultPublishChannel = message.channelId;
+                    this.defaultPublishMessageId = message.messageId;
+                    this.defaultPublishThreadId = message.threadId;
+                }
+                // Where the host directs this server's lifecycle, traffic shows the
+                // transport open only for a channel still decided open or tuned out,
+                // and, but for one exception, only for a confirmed target: after a
+                // retarget, traffic for this id may still come from the old
+                // subscription, and a close receipt that landed first (or during the
+                // coalescer's await) stands. The exception is an entry made from a
+                // push that no update has given a target (untargetedPushEntries):
+                // there's no earlier target its traffic could come from, so for the
+                // receipt rule's own reason its traffic shows the transport open. It
+                // stops being one when a registration replaces it (registerEntry) or
+                // a channels/changed update gives it a target (handleChanged's
+                // retarget), and the receipt rule holds from then. Where the host
+                // doesn't direct the lifecycle, the server opens its own channels and
+                // its traffic is the only evidence the host gets, so it marks the
                 // channel open, as it always has. The entry is the one the message
                 // was accepted for: one a re-registration put in its place meanwhile
-                // waits for its own evidence. Durable desired state still changes
-                // exclusively through lifecycle operations.
+                // waits for its own evidence. Traffic from a transport that has closed
+                // since its batch arrived (here after the coalescer's await, or behind
+                // a sibling's) is no evidence either: the close withdrew what that
+                // transport confirmed, and its connection's grant is empty until the
+                // next one's. Durable desired state still changes exclusively through
+                // lifecycle operations. A marker is evidence like any other message.
+                if ((this.transportCloses.get(serverId) ?? 0) !== closesAtArrival)
+                    return;
                 if (this.directsLifecycle(serverId)) {
-                    if (this.unconfirmedChannelTargets.has(incomingEntry))
+                    if (this.unconfirmedChannelTargets.has(incomingEntry) && !this.untargetedPushEntries.has(incomingEntry))
                         return;
                     const desired = this.getDesiredState(serverId, message.channelId);
                     if (desired !== 'open' && desired !== 'tuned-out')
                         return;
                 }
-                else {
-                    this.unconfirmedChannelTargets.delete(incomingEntry);
-                }
+                this.unconfirmedChannelTargets.delete(incomingEntry);
+                this.failedCloseTargets.delete(incomingEntry);
                 incomingEntry.open = true;
             };
             if (!coalesced)
@@ -881,9 +1358,9 @@ export class ChannelRegistry {
                 // the coalescer, which replaces, appends or withdraws. Malformed
                 // `coalesce` is a per-message failure; siblings are unaffected.
                 try {
-                    const result = await this.handleCoalescedIncoming(serverId, message, event);
+                    const { firstView, ...result } = await this.handleCoalescedIncoming(serverId, message, event);
                     if (result.accepted)
-                        markAccepted();
+                        markAccepted(firstView === true);
                     results.push(result);
                 }
                 catch (error) {
@@ -929,15 +1406,17 @@ export class ChannelRegistry {
      * locus. A push event from a closed channel must never mutate lifecycle
      * state: direct-address events are intentionally usable without subscribing.
      *
-     * Mirrors the lazy-registration inside handleIncoming(), but for channels
-     * that only ever arrive as push/events rather than channels/incoming — the
-     * motivating case is Discord DMs, which discord-mcpl forwards via push/event
-     * with the channel closed (`channelIsOpen:false`). Such a channel is never
-     * registered, so routeSpeech() can't resolve it and the agent's reply is
-     * silently dropped even though the inbound message proves the channel is
-     * reachable (item-3 redux, DM sub-case). Idempotent: a later authoritative
-     * channels/register or channels/changed overwrites this descriptor with the
-     * richer one.
+     * For channels that only ever arrive as push/events rather than
+     * channels/incoming — the motivating case is Discord DMs, which
+     * discord-mcpl forwards via push/event with the channel closed
+     * (`channelIsOpen:false`). Such a channel is never registered, so
+     * routeSpeech() can't resolve it and the agent's reply is silently dropped
+     * even though the inbound message proves the channel is reachable (item-3
+     * redux, DM sub-case). Its entry starts with its transport unknown, as a
+     * registration's does. Its traffic shows it open, for a channel decided
+     * open or tuned out, until an update gives it a target (handleIncoming).
+     * Idempotent: a later authoritative channels/register or channels/changed
+     * overwrites this descriptor with the richer one.
      */
     ensureChannelRegistered(serverId, channelId, label, extraMetadata) {
         const existing = this.findChannelEntry(channelId);
@@ -945,7 +1424,7 @@ export class ChannelRegistry {
             // Backfill identity onto a bare lazy registration: a DM that first
             // arrived with no label/recipient info gets a usable name the next
             // time a message reveals it (labels must show people, not ids).
-            if (existing.descriptor.metadata?.lazyRegistered &&
+            if (pushPlaceholder(existing) &&
                 label && existing.descriptor.label === channelId) {
                 const metadata = extraMetadata
                     ? { ...existing.descriptor.metadata, ...extraMetadata }
@@ -975,18 +1454,19 @@ export class ChannelRegistry {
         // an append that throws registers nothing, so the next push tries again.
         if (label)
             this.appendLabelSighting(channelId, label, extractDmMeta(extraMetadata));
-        const key = `${serverId}:${channelId}`;
-        this.channels.set(key, {
-            serverId,
-            descriptor: {
-                id: channelId,
-                type: serverId,
-                label: label ?? channelId,
-                direction: 'bidirectional',
-                metadata: { lazyRegistered: true, ...(extraMetadata ?? {}) },
-            },
-            open: false,
+        // Its transport is as unknown as a registration's (registerEntry). After
+        // a restart, a push for a channel no registration has comes here, and
+        // the server may still hold a channel an earlier process opened. Counting
+        // it confirmed closed would answer a close or a decline as already done
+        // and send nothing, even where the server still delivers.
+        const entry = this.registerEntry(`${serverId}:${channelId}`, serverId, {
+            id: channelId,
+            type: serverId,
+            label: label ?? channelId,
+            direction: 'bidirectional',
+            metadata: { lazyRegistered: true, ...(extraMetadata ?? {}) },
         });
+        this.untargetedPushEntries.add(entry);
         this.emitTraceFn({
             type: 'mcpl:channel-lazy-registered',
             serverId,
@@ -1086,7 +1566,10 @@ export class ChannelRegistry {
     // Accessors
     // ==========================================================================
     /**
-     * Get the default publish channel ID (most recent incoming channel).
+     * Get the default publish channel ID: the channel of the most recent
+     * incoming message that isn't a reaction, reaction removal, edit or
+     * deletion marker, apart from an edit the coalescer delivers on acceptance
+     * as the agent's first view.
      */
     getDefaultPublishChannel() {
         return this.defaultPublishChannel;
@@ -1104,7 +1587,7 @@ export class ChannelRegistry {
      */
     isDeclaredChannel(serverId, channelId) {
         const entry = this.channels.get(`${serverId}:${channelId}`);
-        return !!entry && !entry.descriptor.metadata?.lazyRegistered;
+        return !!entry && !pushPlaceholder(entry);
     }
     getDescriptor(channelId) {
         return this.findChannelEntry(channelId)?.descriptor;
@@ -1115,8 +1598,16 @@ export class ChannelRegistry {
         const label = this.channels.get(`${serverId}:${channelId}`)?.descriptor.label;
         return typeof label === 'string' && label.length > 0 ? label : undefined;
     }
-    isChannelOpen(channelId) {
-        return this.findChannelEntry(channelId)?.open === true;
+    /** Whether `channelId`'s transport is open: on `serverId` where the caller
+     *  knows the channel's server, and otherwise on the first server found to
+     *  register that id (findChannelEntry). The map's key joins the two ids
+     *  with a colon, so another server's entry can sit under a key: it has to
+     *  be this server's (as in streamingServerAt). */
+    isChannelOpen(channelId, serverId) {
+        if (serverId === undefined)
+            return this.findChannelEntry(channelId)?.open === true;
+        const entry = this.channels.get(`${serverId}:${channelId}`);
+        return entry?.serverId === serverId && entry.open === true;
     }
     getDesiredState(serverId, channelId) {
         return this.desiredStates.get(this.lifecycleKey(serverId, channelId))?.state;
@@ -1173,7 +1664,13 @@ export class ChannelRegistry {
             case 'skip_reply':
                 return this.handleToolSkipReply(input);
             default:
-                return { success: false, error: `Unknown channel tool: ${toolName}`, isError: true };
+                // Not every agent is given every channel tool, so the refusal points
+                // to the ones this agent has rather than listing them all.
+                return {
+                    success: false,
+                    error: `There's no channel tool "${toolName}", so nothing ran. Use one of the channel tools you were given.`,
+                    isError: true,
+                };
         }
     }
     // ==========================================================================
@@ -1187,8 +1684,9 @@ export class ChannelRegistry {
     buildChannelContext(agentName) {
         const openChannels = this.getOpenChannels();
         // Resolve the outbound locus the SAME way routeSpeech does, so the agent is
-        // told the channel its speech will actually land in: a conversation fork's
-        // home channel, else this turn's channel (single trunk agent — item-3
+        // told the channel its speech will actually land in (none, when its server
+        // declared it inbound-only, since speech isn't posted there): a conversation
+        // fork's home channel, else this turn's channel (single trunk agent — item-3
         // redux: its locus, else its triggering channel), else the global default
         // (heartbeats). Without this, a fork
         // was advertised the global locus but published somewhere else; and a trunk
@@ -1206,7 +1704,10 @@ export class ChannelRegistry {
             return undefined;
         }
         const context = {};
-        // Incoming: the most-recent inbound message (what the agent is replying to).
+        // Incoming: the most recent inbound message that isn't a reaction,
+        // reaction removal, edit or deletion marker, apart from an edit the
+        // coalescer delivers on acceptance as the agent's first view (what the
+        // agent is replying to).
         // Left process-global — per-channel inbound tracking (the right messageId for
         // a fork's own channel) is a separate concern from the outbound routing fix.
         if (fallback && this.defaultPublishMessageId) {
@@ -1216,8 +1717,10 @@ export class ChannelRegistry {
                 threadId: this.defaultPublishThreadId,
             };
         }
-        // Default outgoing: the resolved outbound locus (home channel for forks).
-        if (outgoing) {
+        // Default outgoing: the resolved outbound locus (home channel for forks),
+        // unless its server declared it inbound-only: routeSpeech publishes nothing
+        // there, so it isn't where the agent's speech goes.
+        if (outgoing && !this.inboundOnlyServer(outgoing)) {
             context.defaultOutgoing = {
                 channelId: outgoing,
             };
@@ -1238,7 +1741,7 @@ export class ChannelRegistry {
      */
     removeServer(serverId) {
         // Every lifecycle operation queued for this server is cancelled when it
-        // would run (ChannelLifecycleCancelledError), so none acts on a closing
+        // would run (a ChannelLifecycleError of kind `cancelled`), so none acts on a closing
         // connection or on a later re-registration's entries.
         this.serverRemovals.set(serverId, (this.serverRemovals.get(serverId) ?? 0) + 1);
         for (const [key, entry] of this.channels) {
@@ -1254,6 +1757,42 @@ export class ChannelRegistry {
         }
         // Desired state and migration markers deliberately survive disconnects.
     }
+    /**
+     * The server's transport closed. Whatever it confirmed about a channel,
+     * open or closed, held for that transport only, so each of the server's
+     * channels reads as a registration's does: not open, and not confirmed
+     * closed. Where the host directs the server's lifecycle, a receipt
+     * confirms it again: a `channel_open` asks the server, and delivery opens
+     * before it publishes (an untargeted push entry's traffic confirms it, as
+     * before). Where the host doesn't, its traffic does, as after a
+     * registration. The entries, their desired state, labels and tune-out
+     * state stay, since the server is expected back (`removeServer` is for one
+     * that isn't).
+     *
+     * What was under way here at the close confirms nothing afterwards
+     * (transportCloses). Traffic that arrived before the close and is admitted
+     * after it, behind the coalescer's await, marks nothing open
+     * (handleIncoming). A lifecycle request sent before the close is answered
+     * for an older transport: its failure withdraws the open flag, and its
+     * receipt confirms nothing, and the operation tries again, which on the
+     * closed connection is refused as unreachable, so the decision waits for
+     * the next registration (runLifecycleOperation's sameTarget). What the
+     * connection holds across the boundary is another matter: it reaches
+     * handleIncoming after the next transport's grant, as that transport's
+     * traffic (resetPolicyForTransportBoundary), as it does after a
+     * registration.
+     *
+     * The framework calls this first in its handler for the connection's
+     * `close`, so a registration on the next transport, whose entries are new,
+     * can't come first and lose its confirmations to it.
+     */
+    transportClosed(serverId) {
+        this.transportCloses.set(serverId, (this.transportCloses.get(serverId) ?? 0) + 1);
+        for (const entry of this.channels.values()) {
+            if (entry.serverId === serverId)
+                this.invalidateTransportConfirmation(entry);
+        }
+    }
     /**
      * Stop all typing intervals and clear all channel registrations.
      */
@@ -1289,16 +1828,9 @@ export class ChannelRegistry {
             const event = item;
             if (typeof event.serverId !== 'string')
                 continue;
-            if (event.kind === 'desired-state' &&
-                typeof event.channelId === 'string' &&
-                (event.desired === 'open' || event.desired === 'closed' ||
-                    (event.desired === 'tuned-out' && event.tuneOut))) {
-                this.desiredStates.set(this.lifecycleKey(event.serverId, event.channelId), {
-                    state: event.desired,
-                    source: typeof event.source === "string" ? event.source : "unknown",
-                    tuneOut: event.desired === 'tuned-out' ? event.tuneOut : undefined,
-                    wakeCount: 0,
-                });
+            const decision = desiredStateRecord(item);
+            if (decision) {
+                this.desiredStates.set(this.lifecycleKey(decision.serverId, decision.channelId), { state: decision.state, source: decision.source, tuneOut: decision.tuneOut, wakeCount: 0 });
             }
             else if (event.kind === 'tune-out-wake' &&
                 typeof event.channelId === 'string' &&
@@ -1320,7 +1852,9 @@ export class ChannelRegistry {
     /**
      * Each writer appends its record here before it changes memory for it, so
      * an append that throws, as on a full disk, fails the operation with that
-     * change unmade, and memory and the log still agree. A retry then records
+     * change unmade, and memory and the log still agree. A record that changes
+     * no memory, as a decline's of the invitation it declined, is its
+     * caller's to handle (handleToolDecline). A retry then records
      * the change rather than finding it in memory already, where
      * setDesiredState's same-state return would record nothing, and a restart
      * replays what memory held. appendLabelSighting keeps the same order for
@@ -1660,8 +2194,20 @@ export class ChannelRegistry {
     }
     setDesiredState(serverId, channelId, desired, source) {
         const key = this.lifecycleKey(serverId, channelId);
-        if (this.desiredStates.get(key)?.state === desired)
+        const current = this.desiredStates.get(key);
+        // A decision that records the state already on record changes nothing,
+        // so it writes nothing, unless it's the agent's own (channel_open,
+        // channel_close or channel_decline) and the record isn't. The record
+        // then says the agent decided, which is all handleToolClose's
+        // explicit-open guard and ensureInitialDesiredState's lift of a default
+        // ask of it. openChannelNow depends on it too: a failed open by speech
+        // or a reply tells a decision made during its round-trip by the record
+        // no longer being the object it wrote, and the agent's channel_open,
+        // the only decision of the same state that can be made then, gets a new
+        // record here.
+        if (current?.state === desired && !(AGENT_DECISION_SOURCES.has(source) && !AGENT_DECISION_SOURCES.has(current.source))) {
             return;
+        }
         this.appendLifecycleEvent({
             kind: 'desired-state',
             serverId,
@@ -1679,7 +2225,9 @@ export class ChannelRegistry {
      * Enter (or re-enter with fresh params) the tuned-out state for a channel.
      * Re-entering under a new epochId replaces the active epoch; the previous
      * epoch's stamped messages stay excluded (stamps are permanent) and its
-     * wake count is superseded. Transport stays open (see reconcile).
+     * wake count is superseded. Its transport is kept open: tune_out opens a
+     * closed one (openForTuneOut), and reconcile opens it at the channel's
+     * registration.
      */
     enterTuneOut(serverId, channelId, params, source) {
         const key = this.lifecycleKey(serverId, channelId);
@@ -1699,6 +2247,179 @@ export class ChannelRegistry {
             wakeCount: 0,
         });
     }
+    /**
+     * Make a tuned-out channel's transport match its tune-out, which keeps it
+     * open so its traffic reaches the subconscious (TuneOutParams). The
+     * tune-out is recorded first (enterTuneOut), and this writes no decision,
+     * so the tune-out stands whatever becomes of the open. Lifecycle work
+     * queued for the channel goes first, until none is left, since each
+     * operation reads the decision when it runs and so opens a channel tuned
+     * out meanwhile; its own failure, such as a close the server refused,
+     * isn't this open's. Then the state is read. Where this host directs the
+     * lifecycle and the transport isn't confirmed open, the channel's
+     * lifecycle queue opens it once (applyDesiredChannelState reads a
+     * tune-out as open), and the answer waits for the work queued after it
+     * too, such as a registration that came back, and comes from the state
+     * that work leaves. Returns nothing where the transport is open, or, for
+     * tune_out's answer, why the channel's messages don't or may not reach the
+     * subconscious yet and when they will, or that the tune-out isn't in
+     * effect any more. A call while this tune-out's open is in flight, as a
+     * repeated tune_out makes, gets that open's answer rather than send
+     * another.
+     */
+    async openForTuneOut(serverId, channelId) {
+        // The tune-out this answer is for, by its epoch: one that ended, or that
+        // a later decision or a later tune-out replaced, isn't this one.
+        const epochId = this.getTuneOutState(serverId, channelId)?.params.epochId;
+        const key = `${this.lifecycleKey(serverId, channelId)}\u0000${epochId ?? ''}`;
+        let opening = this.tuneOutOpens.get(key);
+        if (!opening) {
+            const started = this.openTuneOutTransport(serverId, channelId, epochId);
+            this.tuneOutOpens.set(key, started);
+            const release = () => {
+                if (this.tuneOutOpens.get(key) === started)
+                    this.tuneOutOpens.delete(key);
+            };
+            void started.then(release, release);
+            opening = started;
+        }
+        return opening;
+    }
+    /**
+     * Whether a tune_out repeated now has nothing to wait for and finds its
+     * channel's transport open, as the tune-out reads it: no lifecycle work
+     * queued for the channel, since the tune-out's own call may still be
+     * waiting for the work queued after its open; its server up; and an open
+     * flag the tune-out takes as open (tuneOutReadsOpen). Where it doesn't,
+     * the repeat goes through openForTuneOut, which joins this tune-out's open
+     * in flight, or waits for the queued work and, where this host can open
+     * the channel, tries the open again.
+     */
+    tuneOutTransportOpen(serverId, channelId) {
+        return this.getTuneOutState(serverId, channelId) !== null &&
+            !this.channelLifecycleTails.has(this.lifecycleKey(serverId, channelId)) &&
+            this.serverReach(serverId) === 'up' &&
+            this.tuneOutReadsOpen(this.channels.get(`${serverId}:${channelId}`));
+    }
+    /**
+     * Whether a tune-out takes an entry's transport as open: its open flag,
+     * unless a close for it failed since it was confirmed (failedCloseTargets),
+     * since that close may have taken effect. The other readers take any flag
+     * a failed request left as it was (runLifecycleOperation), since a send
+     * through it fails where it can be seen, and channel_open sends an open
+     * after a failed close anyway, its decision having been closed. A
+     * tune-out's success says traffic will arrive, nothing would show it
+     * doesn't, and the decision it replaced isn't known here. An open that
+     * failed, as a redundant one queued behind a confirming one may, can't
+     * have closed the channel: one for the current target leaves the flag as
+     * it was, so an open flag stays open (one for a target no longer current
+     * withdraws it).
+     */
+    tuneOutReadsOpen(entry) {
+        // A flag is set open only where both marks are cleared, so a failed
+        // close on an open flag is one since its confirmation.
+        return entry !== undefined && entry.open && !this.failedCloseTargets.has(entry);
+    }
+    async openTuneOutTransport(serverId, channelId, epochId) {
+        const channelKey = `${serverId}:${channelId}`;
+        const lifecycleKey = this.lifecycleKey(serverId, channelId);
+        const inEffect = () => epochId !== undefined && this.getTuneOutState(serverId, channelId)?.params.epochId === epochId;
+        // "May not": a failed request leaves its outcome unknown, and an open
+        // that took effect would have its traffic diverted. `again` where calling
+        // tune_out again tries the open now: the channel is registered here and
+        // its server up.
+        const notYet = (later, why, again = false) => withStop(`The tune-out is recorded, but its messages may not reach the subconscious until this host opens the channel, ` +
+            `which it does ${later}${again ? ', or now if you call tune_out again' : ''}; ${why}`);
+        const nextRegistration = `when the "${serverId}" server next registers this channel, if this host may open and ` +
+            'close its channels then';
+        // The work queued for the channel as it stands: its tail, waited for,
+        // and its failure returned, if it failed. Each wait below takes it until
+        // no work is left, as a delivery's wait does (waitForOpenChannel), so
+        // work queued while earlier work ran, such as a registration that came
+        // back, goes first too.
+        let awaited;
+        const settle = async () => {
+            const pending = this.channelLifecycleTails.get(lifecycleKey);
+            if (!pending)
+                return undefined;
+            awaited = pending;
+            try {
+                await pending;
+                return undefined;
+            }
+            catch (error) {
+                return error;
+            }
+        };
+        // What the state answers now, or null where this host is to open the
+        // transport itself. `missing` answers for a channel that isn't
+        // registered here, where this host directs the lifecycle.
+        const answered = (entry, missing) => {
+            if (!inEffect())
+                return TUNE_OUT_REPLACED;
+            // A connection that dropped keeps its entries' open flags, and whether
+            // this host or the server opens the channel isn't known until it's
+            // back, since a reconnect empties the grant until the new one is
+            // established.
+            const reach = this.serverReach(serverId);
+            if (reach !== 'up') {
+                return withStop(`The tune-out is recorded, but its messages don't reach the subconscious until the "${serverId}" server is ` +
+                    `connected and the channel is open; it can't be opened now: ${unreachableClause(serverId, reach)}` +
+                    (reach === 'gone' ? unreachableRemedy(reach) : ''));
+            }
+            const transportOpen = this.tuneOutReadsOpen(entry);
+            if (!this.directsLifecycle(serverId)) {
+                return transportOpen ? undefined
+                    : `The tune-out is recorded, but ${this.lifecycleRefusal(serverId).message}, so its messages reach the ` +
+                        'subconscious only as that server sends them, and calling tune_out again won\'t change that. If you need ' +
+                        'this host to open it, ask whoever runs this host.';
+            }
+            if (!entry)
+                return missing;
+            // A flag a close that may have taken effect left gets an open.
+            return transportOpen ? undefined : null;
+        };
+        // Whether work is queued that settle hasn't waited for. It's looked at
+        // in the turn that reads the state and queues the open, or answers, so
+        // work queued after settle's look is waited for too. A settled tail
+        // releases its own key before this runs, since its cleanup was
+        // registered first (applyDesiredChannelState); one still standing isn't
+        // waited for again, so the wait can't spin on it should that order ever
+        // change, as waitForOpenChannel's guard keeps its own from doing.
+        const queuedSince = () => {
+            const tail = this.channelLifecycleTails.get(lifecycleKey);
+            return tail !== undefined && tail !== awaited;
+        };
+        do
+            await settle();
+        while (queuedSince());
+        const before = answered(this.channels.get(channelKey), notYet(nextRegistration, "it isn't registered here now"));
+        if (before !== null)
+            return before;
+        let failure;
+        try {
+            await this.applyDesiredChannelState(serverId, channelId);
+        }
+        catch (error) {
+            failure = error;
+        }
+        // A registration that came back while the open was out queued its own
+        // reconcile, which the answer waits for too. The answer says why the
+        // channel isn't open now, so where the last work failed, its failure,
+        // the last attempt's, is the reason: this open's may concern a
+        // registration that work replaced.
+        let later;
+        do
+            later = await settle();
+        while (queuedSince());
+        failure = later ?? failure;
+        const clause = failure !== undefined ? `: ${lifecycleClause(failure)}` : '';
+        const after = this.channels.get(channelKey);
+        const settled = answered(after, notYet(nextRegistration, `it isn't registered here any more${clause}`));
+        if (settled !== null)
+            return settled;
+        return notYet(laterClause(after), failure !== undefined ? `opening it now didn't complete${clause}` : "it isn't open now", true);
+    }
     /**
      * End the active tune-out, returning the channel to `nextState`.
      * The caller (tune-out coordinator) owns the dump/notice flow; this is
@@ -1779,12 +2500,49 @@ export class ChannelRegistry {
     }
     /**
      * Publish into a channel on behalf of a named non-resident agent (the
-     * subconscious's speak_in_channel). Same delivery path as the
-     * channel_publish tool; the agent name rides the speech-routed trace.
+     * subconscious's speak_in_channel). Same delivery path, and the same result
+     * as the channel_publish tool apart from `reason` below. Its traces carry the agent's name and follow
+     * the publish's outcome as deliverSpeech's do: speech-routed after a
+     * confirmed delivery, and speech-route-failed otherwise, `unknown` when the
+     * words may have been posted and `failed` when nothing was, a refusal before
+     * the publish included. The routed trace carries no message id, as before:
+     * nothing here reads one, and a consumer that edits the newest traced
+     * message in a channel would have this post to edit when an interruption of
+     * the resident matches none. A refusal of the destination before anything
+     * went out carries its `reason` (PublishRefusalReason), so a caller can act
+     * on why nothing was posted without reading the words.
      */
     async publishForAgent(channelId, text, agentName) {
-        this.emitTraceFn({ type: 'mcpl:speech-routed', conversationId: agentName, channelId, text });
-        return this.handleToolPublish({ channelId, content: text });
+        // The server the publish goes to, as handleToolPublish finds it before
+        // it awaits: the channel may be removed while the reply is pending.
+        const serverId = this.findChannelEntry(channelId)?.serverId ?? '';
+        const seen = {};
+        const result = await this.handleToolPublish({ channelId, content: text }, undefined, seen, 'speak_in_channel');
+        if (seen.outcome?.status === 'delivered') {
+            this.emitTraceFn({
+                type: 'mcpl:speech-routed',
+                conversationId: agentName,
+                serverId,
+                channelId,
+                delivered: true,
+                textLen: text.length,
+                text,
+            });
+        }
+        else {
+            this.emitTraceFn({
+                type: 'mcpl:speech-route-failed',
+                conversationId: agentName,
+                channelId,
+                // The publish's own reason and the connector's detail, as
+                // deliverSpeech's trace gives them, or the refusal before any publish.
+                reason: seen.outcome?.reason ?? result.error ?? 'the publish failed',
+                textLen: text.length,
+                outcome: seen.outcome?.status === 'unknown' ? 'unknown' : 'failed',
+                ...(seen.outcome?.detail !== undefined ? { detail: connectorText(seen.outcome.detail) } : {}),
+            });
+        }
+        return seen.refusal !== undefined ? { ...result, reason: seen.refusal } : result;
     }
     /**
      * Consume the old recipe policy exactly once. It seeds Chronicle for
@@ -1869,6 +2627,7 @@ export class ChannelRegistry {
         const removals = this.serverRemovals.get(serverId) ?? 0;
         const previous = this.channelLifecycleTails.get(lifecycleKey) ?? Promise.resolve();
         this.lifecycleOutstanding.set(lifecycleKey, (this.lifecycleOutstanding.get(lifecycleKey) ?? 0) + 1);
+        this.lifecycleQueuedRemovals.set(lifecycleKey, removals);
         const operation = previous.catch(() => { }).then(() => this.runLifecycleOperation(serverId, channelId, removals, options));
         // Keep the rejection visible to existing joiners, while observing it
         // immediately and letting each queued successor start after either result.
@@ -1890,17 +2649,14 @@ export class ChannelRegistry {
             let attempts = 0;
             for (;;) {
                 if ((this.serverRemovals.get(serverId) ?? 0) !== removals) {
-                    throw new ChannelLifecycleCancelledError(`Channel ${channelId}: its server's registrations were removed while this operation was queued`);
+                    throw new ChannelLifecycleError(`this host disconnected the "${serverId}" server while the change was being made`, 'cancelled');
                 }
                 const entry = this.channels.get(channelKey);
                 if (!entry)
-                    throw new Error(`Channel is no longer registered: ${channelId}`);
+                    throw new ChannelLifecycleError(`the "${serverId}" server no longer lists the channel`, 'unlisted');
                 const server = this.serverRegistry.getServer(serverId);
-                if (!server)
-                    throw new Error(`Server not found: ${serverId}`);
-                if (!CapabilityGrant.of(server).has('channels.lifecycle')) {
-                    throw new Error(`channels.lifecycle not in "${serverId}"'s effective grant (§14.1)`);
-                }
+                if (!server || !CapabilityGrant.of(server).has('channels.lifecycle'))
+                    throw this.lifecycleRefusal(serverId);
                 const descriptor = entry.descriptor;
                 const desired = this.getDesiredState(serverId, channelId);
                 const open = desired === 'open' || desired === 'tuned-out';
@@ -1909,10 +2665,12 @@ export class ChannelRegistry {
                 // release its queue slot and surface the failure to delivery joiners.
                 // Its open flag needs no change here: every retry follows a replaced
                 // registration, a retarget (already invalidated, whether the old
-                // target's RPC was answered or failed), or a receipt for this very
-                // target.
+                // target's RPC was answered or failed), a receipt from before a
+                // transport's close (invalidated by the close), or a receipt for this
+                // very target.
                 if (attempts >= MAX_CHANNEL_LIFECYCLE_ATTEMPTS) {
-                    const error = new ChannelLifecycleConvergenceError(`Channel ${channelId} did not converge after ${attempts} lifecycle attempts; its target or desired state kept changing`);
+                    const error = new ChannelLifecycleError(`the channel's address at the "${serverId}" server, or the decision about it, kept changing, and ${attempts} tries ` +
+                        "didn't settle it", 'converge');
                     this.emitTraceFn({
                         type: 'mcpl:channel-reconcile-failed',
                         serverId, channelId, desired, attempts, error: error.message,
@@ -1920,7 +2678,14 @@ export class ChannelRegistry {
                     throw error;
                 }
                 attempts++;
+                // A reconnect keeps the connection object, so the count of its
+                // transport's closes (transportClosed) is what tells an answer from
+                // the transport it was sent on apart from one on its successor: an
+                // answer applied after a close it was sent before is from an older
+                // transport, and confirms nothing.
+                const closesAtSend = this.transportCloses.get(serverId) ?? 0;
                 const sameTarget = () => this.serverRegistry.getServer(serverId) === server &&
+                    (this.transportCloses.get(serverId) ?? 0) === closesAtSend &&
                     sameChannelTarget(entry.descriptor, descriptor);
                 let result;
                 try {
@@ -1942,8 +2707,11 @@ export class ChannelRegistry {
                     // while not open). A failure from an older connection or target
                     // also withdraws the open flag.
                     if (this.channels.get(channelKey) === entry) {
-                        if (sameTarget())
+                        if (sameTarget()) {
                             this.unconfirmedChannelTargets.add(entry);
+                            if (!open)
+                                this.failedCloseTargets.add(entry);
+                        }
                         else
                             this.invalidateTransportConfirmation(entry);
                     }
@@ -1991,12 +2759,15 @@ export class ChannelRegistry {
                 // its sends either.
                 if (substitute !== undefined) {
                     this.invalidateTransportConfirmation(entry);
-                    throw new ChannelOpenSubstitutionError(`Server "${serverId}" answered channels/open for ${channelId} with ` +
-                        (substitute.kind === 'other' ? 'a different channel' : 'a channel id that is not a string') +
-                        `; ${channelId} is not marked open, and nothing in the answer is used`);
+                    throw new ChannelLifecycleError(`the "${serverId}" server answered for ` +
+                        (substitute.kind === 'other' ? 'a different channel' : 'a channel whose id isn\'t a string') +
+                        ', so nothing in its answer is used', 'substituted');
                 }
+                if (open)
+                    this.applyOpenDeclaration(entry, result);
                 entry.open = open;
                 this.unconfirmedChannelTargets.delete(entry);
+                this.failedCloseTargets.delete(entry);
                 const now = this.getDesiredState(serverId, channelId);
                 if (open !== (now === 'open' || now === 'tuned-out'))
                     continue;
@@ -2009,10 +2780,34 @@ export class ChannelRegistry {
             const left = (this.lifecycleOutstanding.get(lifecycleKey) ?? 1) - 1;
             if (left > 0)
                 this.lifecycleOutstanding.set(lifecycleKey, left);
-            else
+            else {
                 this.lifecycleOutstanding.delete(lifecycleKey);
+                this.lifecycleQueuedRemovals.delete(lifecycleKey);
+            }
         }
     }
+    /** Whether lifecycle work already outstanding for the channel will carry out
+     *  its current decision: some is, and the newest was queued since its
+     *  server's registrations were last removed, so it won't cancel when it
+     *  would run. Each operation reads the decision when it runs. It answers for
+     *  now: a removal after it cancels that work too, and takes the channel's
+     *  entry with it, so the channel's next registration by channels/register,
+     *  or as added by channels/changed, carries the decision out, where this
+     *  host directs the lifecycle then. A push's registration
+     *  (ensureChannelRegistered) queues no lifecycle work. So where a push
+     *  re-makes an entry that a channels/changed removal took while an RPC for
+     *  the old entry was out, the operation running that RPC carries the
+     *  decision out for the push's entry only if the RPC is answered: a failed
+     *  one rethrows, since its retry covers only a retarget of its own entry.
+     *  This answers true meanwhile, so a channels/changed update that retargets
+     *  the push's entry is left to that operation, and stays undone after a
+     *  failed RPC until lifecycle work is queued for the channel again
+     *  (applyDesiredChannelState). No server we know of sends `updated` for a
+     *  channel it has removed. */
+    outstandingWorkCarriesOut(serverId, key) {
+        return this.lifecycleOutstanding.has(key) &&
+            this.lifecycleQueuedRemovals.get(key) === (this.serverRemovals.get(serverId) ?? 0);
+    }
     /**
      * A server that answered an open with another channel really opened that
      * one. When it's registered here and the host wants it closed, close it
@@ -2027,40 +2822,57 @@ export class ChannelRegistry {
             return;
         if (this.getDesiredState(serverId, channelId) !== 'closed')
             return;
+        this.applyThroughQueue(serverId, channelId);
+    }
+    /**
+     * Carry out a channel's decision through its lifecycle queue, for a
+     * transport the server may have opened without the host's knowing: one it
+     * opened for another channel's request (closeSubstitutedChannel), or one a
+     * failed open's request may have reached (openChannelNow). The decision is
+     * a closed one, except after a failed open whose put-back the server's
+     * latest announcement or the policy lifted. A failure is reported as a
+     * trace; the decision stands.
+     */
+    applyThroughQueue(serverId, channelId) {
         this.applyDesiredChannelState(serverId, channelId).catch((err) => {
             // Removal while queued is cancellation, as in reconcileChannels, and
             // exhausted convergence emitted its own diagnostic.
             if (!this.channels.has(`${serverId}:${channelId}`) ||
-                err instanceof ChannelLifecycleCancelledError ||
-                err instanceof ChannelLifecycleConvergenceError)
+                (err instanceof ChannelLifecycleError && (err.kind === 'cancelled' || err.kind === 'converge')))
                 return;
             this.emitTraceFn({
                 type: 'mcpl:channel-reconcile-failed',
-                serverId, channelId, desired: 'closed', error: err.message,
+                serverId, channelId, desired: this.getDesiredState(serverId, channelId), error: err.message,
             });
         });
     }
     /**
      * Join outstanding lifecycle work without recording new intent. Retargeting
      * may have invalidated open confirmation while the decision remains pending.
-     * A close that settles during the wait remains authoritative; waiting for
-     * it is not an instruction to open the channel again.
+     * A close that settles during the wait remains authoritative where the host
+     * directs the server's lifecycle (closeStands); waiting for it is not an
+     * instruction to open the channel again.
      */
     async waitForOpenChannel(entry) {
         const lifecycleKey = this.lifecycleKey(entry.serverId, entry.descriptor.id);
+        // The failure of the last work waited on, if it failed, which says why a
+        // channel it left unopened isn't open.
+        let failed;
         for (;;) {
             const pending = this.channelLifecycleTails.get(lifecycleKey);
             if (!pending)
                 break;
             try {
                 await pending;
+                failed = undefined;
             }
             catch (error) {
                 // A redundant backscroll failure can leave a known-open channel
                 // usable. Exhausted convergence is different: it never established
                 // the current target, so joined delivery must fail visibly.
-                if (error instanceof ChannelLifecycleConvergenceError)
+                if (error instanceof ChannelLifecycleError && error.kind === 'converge')
                     throw error;
+                failed = error;
             }
             // A settled tail releases its own key. One still current after it
             // settled would be awaited again without ever yielding to the event
@@ -2070,9 +2882,15 @@ export class ChannelRegistry {
         }
         const current = this.channels.get(`${entry.serverId}:${entry.descriptor.id}`);
         if (!current)
-            throw new Error('Channel registration was removed while delivery waited');
-        if (!current.open || this.getDesiredState(current.serverId, current.descriptor.id) === 'closed') {
-            throw new Error('Channel is not confirmed open for delivery, or was selected for closure while delivery waited');
+            throw new ChannelLifecycleError(CHANNEL_REMOVED_CLAUSE, 'removed');
+        // A close that stands is what the words met, whatever became of an open,
+        // and whether or not the close itself took: one that failed may have
+        // left the transport open.
+        if (this.closeStands(current)) {
+            throw new ChannelLifecycleError('a decision to close the channel came before these words went out', 'not-open');
+        }
+        if (!current.open) {
+            throw new ChannelLifecycleError("the channel isn't confirmed open" + (failed !== undefined ? `: ${lifecycleClause(failed)}${refusalRemedy(failed)}` : ''), 'not-open');
         }
         return current;
     }
@@ -2132,9 +2950,8 @@ export class ChannelRegistry {
                 // Exhausted convergence and a substituted answer already emitted
                 // their own diagnostics.
                 if (!this.channels.has(`${serverId}:${channel.id}`) ||
-                    err instanceof ChannelLifecycleCancelledError ||
-                    err instanceof ChannelLifecycleConvergenceError ||
-                    err instanceof ChannelOpenSubstitutionError)
+                    (err instanceof ChannelLifecycleError &&
+                        (err.kind === 'cancelled' || err.kind === 'converge' || err.kind === 'substituted')))
                     return;
                 this.emitTraceFn({
                     type: 'mcpl:channel-reconcile-failed',
@@ -2180,6 +2997,16 @@ export class ChannelRegistry {
     getChannelServerId(channelId) {
         return this.findChannelEntry(channelId)?.serverId ?? null;
     }
+    /**
+     * The server that declared this channel inbound-only (isInboundOnly), or
+     * undefined when it isn't one. The notices name that server. A caller that
+     * knows the channel's server passes it; otherwise the channel is found by
+     * its id alone (findChannelEntry).
+     */
+    inboundOnlyServer(channelId, serverId) {
+        const entry = serverId ? this.channels.get(`${serverId}:${channelId}`) : this.findChannelEntry(channelId);
+        return entry && isInboundOnly(entry) ? entry.serverId : undefined;
+    }
     /**
      * Find a channel entry by channelId (searches across all servers).
      * Returns the first match.
@@ -2193,17 +3020,28 @@ export class ChannelRegistry {
         return undefined;
     }
     resolveToolChannelEntry(channelId, serverId) {
-        const matches = [...this.channels.values()].filter((entry) => entry.descriptor.id === channelId && (!serverId || entry.serverId === serverId));
+        const withId = [...this.channels.values()].filter((entry) => entry.descriptor.id === channelId);
+        const matches = withId.filter((entry) => !serverId || entry.serverId === serverId);
         if (matches.length === 0) {
+            if (serverId && withId.length > 0) {
+                // Leaving serverId out works only when one server has the id.
+                const servers = withId.map((entry) => `"${entry.serverId}"`);
+                return {
+                    error: `No channel "${channelId}" is on server "${serverId}", so nothing ran. ` + (servers.length === 1
+                        ? `It's on server ${servers[0]}: call again with serverId ${servers[0]}, or leave serverId out.`
+                        : `It's on servers ${servers.join(', ')}: call again with serverId set to one of them.`),
+                };
+            }
             return {
                 error: serverId
-                    ? `Channel not found: ${channelId} on server ${serverId}`
-                    : `Channel not found: ${channelId}`,
+                    ? `No channel "${channelId}" is on server "${serverId}", so nothing ran. channel_list shows the channels and their servers.`
+                    : `No channel has the id "${channelId}", so nothing ran. channel_list shows the channel ids.`,
             };
         }
         if (matches.length > 1) {
             return {
-                error: `Channel id is ambiguous across MCPL servers: ${channelId}. Include serverId.`,
+                error: `Channel "${channelId}" is on more than one server (${matches.map((entry) => `"${entry.serverId}"`).join(', ')}), ` +
+                    'so nothing ran. Call again with serverId set to one of them.',
             };
         }
         return { entry: matches[0] };
@@ -2243,15 +3081,31 @@ export class ChannelRegistry {
     /**
      * Record durable desired-open intent, then queue the channel's lifecycle
      * work (applyDesiredChannelState), which tells the server to subscribe and
-     * marks the live entry open on a receipt for its current target. Every
-     * open the agent or its speech asks for — the channel_open tool, delivery
+     * marks the live entry open on a receipt for its current target, applying
+     * an inbound-only declaration the answer carries (applyOpenDeclaration).
+     * Every open the agent or its speech asks for — the channel_open tool, delivery
      * into a closed locus, an explicit send into a closed channel — comes
      * here. Reconciliation queues that work directly, as the closes do
      * (channel_close, a decline, and the close of a substituted channel).
-     * Desired state is recorded BEFORE the server round-trip: intent sticks
-     * even if the subscribe fails, and reconciliation retries later.
-     * Automatic delivery needs open transport, not a change of attention:
-     * preserve tune-out epochs both before and during the round-trip.
+     * Desired state is recorded BEFORE the server round-trip. The agent's own
+     * open is a decision about the channel: it sticks even if the subscribe
+     * fails, and reconciliation retries later. An open by speech or a reply is
+     * incidental to its words: when its round-trip fails, the decision it
+     * wrote goes back to the one it replaced, so the agent, told the channel
+     * is closed and the open failed, isn't later put into it by that decision.
+     * That holds only while the record is still the one it wrote: a decision
+     * made meanwhile stands, and the failure then comes as `overtaken`
+     * (ChannelLifecycleError). Where the decision put back is a pure default,
+     * nobody had decided, so the channel then follows its server's latest
+     * announcement and the policy: a re-announcement during the round-trip
+     * found the open's own record and lifted nothing. If they select it for
+     * opening, the failure says so (`selected-again`). And since
+     * a failed request may have reached the server, the decision that stands
+     * is carried out on the wire too. An open by speech or a reply that can't
+     * send its request, on a server without channels.lifecycle, writes
+     * nothing. Automatic delivery needs open transport, not a change of
+     * attention: preserve tune-out epochs both before and during the
+     * round-trip.
      *
      * `opened` says whether this call turned a closed channel open, which is
      * what the delivery and reply notices tell the resident. Reconfirming the
@@ -2259,17 +3113,126 @@ export class ChannelRegistry {
      */
     async openChannelNow(entry, source, history) {
         const transportOnly = source !== 'agent-tool';
+        const key = this.lifecycleKey(entry.serverId, entry.descriptor.id);
+        if (transportOnly) {
+            // Without channels.lifecycle the open fails before any request leaves
+            // (§14.1), as it does without the server, so an incidental open would
+            // only write a decision to put back. It writes none.
+            const server = this.serverRegistry.getServer(entry.serverId);
+            if (!server || !CapabilityGrant.of(server).has('channels.lifecycle'))
+                throw this.lifecycleRefusal(entry.serverId);
+        }
+        // The decision this open replaces. A channel with none on record, as one
+        // registered from a push, was closed by default: nobody had decided.
+        const replaced = this.desiredStates.get(key) ?? { state: 'closed', source: 'default-closed' };
         const before = this.getDesiredState(entry.serverId, entry.descriptor.id);
         const opened = before !== 'open' && before !== 'tuned-out';
         if (!transportOnly || before !== 'tuned-out') {
-            this.setDesiredState(entry.serverId, entry.descriptor.id, 'open', source);
+            // A decision the log refused changed nothing, and its words say so
+            // rather than read as one a later decision overtook.
+            try {
+                this.setDesiredState(entry.serverId, entry.descriptor.id, 'open', source);
+            }
+            catch (err) {
+                throw unrecordedDecision(err);
+            }
+        }
+        // The record an incidental open wrote, to put back if its round-trip fails.
+        const wrote = transportOnly && opened ? this.desiredStates.get(key) : undefined;
+        try {
+            const applied = await this.applyDesiredChannelState(entry.serverId, entry.descriptor.id, { history });
+            const desired = this.getDesiredState(entry.serverId, entry.descriptor.id);
+            if (!applied.open || (desired !== 'open' && !(transportOnly && desired === 'tuned-out'))) {
+                throw new ChannelLifecycleError(supersededClause('open', desired), 'superseded');
+            }
+            return { result: applied.result, opened };
+        }
+        catch (err) {
+            if (wrote && this.desiredStates.get(key) !== wrote) {
+                // That decision stands, and the failure says so where its own clause
+                // doesn't, as a superseded open's does. What helps turns on that
+                // decision, so no step is offered.
+                const own = lifecycleClause(err);
+                throw new ChannelLifecycleError(err instanceof ChannelLifecycleError && err.kind === 'superseded'
+                    ? own : afterClause(own, 'a decision about the channel made while the open was out stands'), 'overtaken', undefined, { cause: err });
+            }
+            if (wrote) {
+                try {
+                    this.setDesiredState(entry.serverId, entry.descriptor.id, replaced.state, replaced.source);
+                }
+                catch (putBackErr) {
+                    // The caller reports both: the channel isn't open, but it stays
+                    // selected for opening, so reconciliation may open it later.
+                    throw new ChannelLifecycleError(afterClause(lifecycleClause(err), 'the channel stays selected for opening, because this host couldn\'t record ' +
+                        `undoing that: ${requestErrorText(putBackErr)}`), 'put-back-unrecorded', undefined, { cause: err });
+                }
+                // The decision put back is a closed one: an open that turned the
+                // channel open replaced no open decision. Where it's a pure default,
+                // nobody had decided, so the channel follows its server's latest
+                // announcement and the policy, not the ones from before the open: a
+                // re-announcement during the round-trip found the open's own record
+                // and lifted nothing. The lift is ensureInitialDesiredState's own,
+                // which leaves every real decision alone. One that can't be recorded
+                // leaves the default, closed.
+                const current = this.channels.get(`${entry.serverId}:${entry.descriptor.id}`);
+                let selectedAgain;
+                if (current) {
+                    try {
+                        this.ensureInitialDesiredState(entry.serverId, current.descriptor);
+                    }
+                    catch (liftErr) {
+                        console.error(`[channel] ${entry.serverId}:${logValue(entry.descriptor.id)}: the lift after a failed open couldn't be recorded:`, liftErr);
+                    }
+                    const now = this.desiredStates.get(key);
+                    if (now?.state === 'open' && (now.source === 'server-bootstrap' || now.source === 'subscription-policy')) {
+                        selectedAgain = now.source;
+                    }
+                }
+                // The failed request may have reached the server, so the decision
+                // that stands is carried out through the queue, as a decline's close
+                // is, unless other lifecycle work for the channel is queued that will
+                // carry it out anyway: work queued before its server's registrations
+                // were removed cancels instead. (An incidental open gets here only
+                // where the host directed the lifecycle when it opened: see the grant
+                // check above. Where the grant has lost channels.lifecycle since, as a
+                // transport drop clears it, the queued work fails for it, and the
+                // channel's next registration by channels/register, or as added by
+                // channels/changed, carries the decision out, where this host directs
+                // the lifecycle then.)
+                if (current && !this.outstandingWorkCarriesOut(entry.serverId, key)) {
+                    this.applyThroughQueue(entry.serverId, entry.descriptor.id);
+                }
+                if (selectedAgain) {
+                    throw new ChannelLifecycleError(afterClause(lifecycleClause(err), 'the channel is selected for opening again, because ' +
+                        (selectedAgain === 'server-bootstrap' ? 'its server lists it as open by default' : 'the subscription policy admits it')), 'selected-again', undefined, { by: selectedAgain, cause: err });
+                }
+            }
+            throw err;
         }
-        const applied = await this.applyDesiredChannelState(entry.serverId, entry.descriptor.id, { history });
-        const desired = this.getDesiredState(entry.serverId, entry.descriptor.id);
-        if (!applied.open || (desired !== 'open' && !(transportOnly && desired === 'tuned-out'))) {
-            throw new Error('Channel open was superseded by a newer lifecycle decision');
+    }
+    /**
+     * An open's answer carries the server's descriptor for the channel
+     * (§14.3), the first place a lazily registered channel's own declaration
+     * can arrive. runLifecycleOperation hands it here, wherever the host opens
+     * a channel, once the answer is known to be for the channel's current
+     * entry and target. An answer that names another channel never arrives
+     * here: it's a substitution, which fails the open. One whose channel names
+     * no id is this channel's, as runLifecycleOperation takes it, so its
+     * declaration applies too.
+     *
+     * Only an inbound-only declaration is applied. The answer isn't always the
+     * server's latest word: a `channels/changed` that arrives in the same read
+     * as the answer is handled before the open's operation resumes, so the
+     * answer is applied over it. Applying only a refusal keeps that race
+     * fail-closed: a stale answer can keep a channel refused until the
+     * server's next update, but never lift a newer refusal. A server lifts its
+     * declaration by changing or registering the channel again.
+     */
+    applyOpenDeclaration(entry, answer) {
+        const declared = answer?.channel;
+        if (declared?.direction === 'inbound') {
+            entry.descriptor = { ...entry.descriptor, direction: 'inbound' };
         }
-        return { result: applied.result, opened };
     }
     /**
      * Resolve a `>>` prose-routing target (explicit prose routing —
@@ -2284,8 +3247,24 @@ export class ChannelRegistry {
      *
      * Ambiguity is an error carrying candidates — never a guess: this is the
      * mechanism that makes prose misdelivery structurally impossible.
+     *
+     * `forSpeech` is for a target the agent's speech will be posted to: a
+     * channel its server declared inbound-only (isInboundOnly) then resolves
+     * to an error that says so, since nothing is published there, and that
+     * names the channel as `refusedChannelId`, so a caller can tell a refused
+     * channel from a name that resolved to nothing. Without it, as for reading
+     * a channel's history, any registered channel resolves.
      */
-    resolveProseTarget(spec) {
+    resolveProseTarget(spec, opts) {
+        const resolved = this.resolveTargetByName(spec);
+        if (!opts?.forSpeech || 'error' in resolved)
+            return resolved;
+        const entry = this.findChannelEntry(resolved.channelId);
+        return entry && isInboundOnly(entry)
+            ? { error: `${resolved.channelId} is ${inboundOnlyReason(entry)}`, refusedChannelId: resolved.channelId }
+            : resolved;
+    }
+    resolveTargetByName(spec) {
         const entries = [...this.channels.values()];
         const trimmed = spec.trim();
         if (!trimmed)
@@ -2431,7 +3410,7 @@ export class ChannelRegistry {
         for (const c of candidates) {
             if (/\s/.test(c) || c === '#')
                 continue;
-            const r = this.resolveProseTarget(c);
+            const r = this.resolveProseTarget(c, { forSpeech: true });
             if ('channelId' in r && r.channelId === d.id)
                 return c;
         }
@@ -2443,7 +3422,17 @@ export class ChannelRegistry {
      * engaging a channel opens it, so typing indicators, reaction machinery,
      * and inbound forwarding all come alive with the first outbound message.
      * Accepts composite MCPL ids or raw server-internal ids (explicit send
-     * tools receive whatever the agent typed).
+     * tools receive whatever the agent typed). An `open-failed` answer says
+     * whether the open that failed was one that would have opened a channel
+     * not selected open (`opening`), as opposed to one reconfirming the
+     * transport of a channel already selected open or tuned out. It isn't one
+     * either where a decision made during its round-trip replaced it
+     * (`overtaken`), or where queued lifecycle work left the
+     * channel closed before any open was sent. `selectedForOpening` says the
+     * channel is selected for opening after the failure, and why: the put-back
+     * couldn't be recorded (`put-back-unrecorded`), or the server's latest
+     * announcement or the policy lifted the default it restored
+     * (`selected-again`).
      */
     async openIfClosedForSend(rawChannelId, serverId) {
         let matches = [...this.channels.values()].filter((e) => e.descriptor.id === rawChannelId && (!serverId || e.serverId === serverId));
@@ -2456,6 +3445,7 @@ export class ChannelRegistry {
         if (matches.length > 1)
             return { status: 'ambiguous' };
         let entry = matches[0];
+        let opening = false;
         try {
             if (this.hasPendingLifecycle(entry)) {
                 entry = await this.waitForOpenChannel(entry);
@@ -2464,6 +3454,7 @@ export class ChannelRegistry {
             if (entry.open && (desired === 'open' || desired === 'tuned-out')) {
                 return { status: 'already-open', channelId: entry.descriptor.id, label: entry.descriptor.label };
             }
+            opening = desired !== 'open' && desired !== 'tuned-out';
             const { opened } = await this.openChannelNow(entry, 'opened-by-reply');
             entry = await this.waitForOpenChannel(entry);
             if (opened) {
@@ -2476,6 +3467,11 @@ export class ChannelRegistry {
             return { status: opened ? 'opened' : 'already-open', channelId: entry.descriptor.id, label: entry.descriptor.label };
         }
         catch (err) {
+            // Where a decision made during the open's round-trip replaced it, such
+            // as the agent's own close or channel_open, the channel is as that
+            // decision left it, and the agent isn't told the open failed.
+            if (err instanceof ChannelLifecycleError && err.kind === 'overtaken')
+                opening = false;
             this.emitTraceFn({
                 type: 'mcpl:channel-open-failed',
                 serverId: entry.serverId,
@@ -2483,7 +3479,11 @@ export class ChannelRegistry {
                 error: err.message,
             });
             const current = this.channels.get(`${entry.serverId}:${entry.descriptor.id}`);
-            return { status: 'open-failed', channelId: entry.descriptor.id,
+            return { status: 'open-failed', channelId: entry.descriptor.id, opening,
+                // Where the channel is selected for opening after the failure, the
+                // agent is told so and why, as speech's failure says.
+                ...(err instanceof ChannelLifecycleError && err.kind === 'put-back-unrecorded' ? { selectedForOpening: 'unrecorded' } : {}),
+                ...(err instanceof ChannelLifecycleError && err.kind === 'selected-again' ? { selectedForOpening: err.by } : {}),
                 ...(current ? { label: current.descriptor.label } : {}) };
         }
     }
@@ -2500,21 +3500,26 @@ export class ChannelRegistry {
         // A tuned-out channel is transport-open but attention-diverted; a plain
         // open would silently discard the epoch (and its pending backlog dump).
         // Cancelling is the tune-out coordinator's flow, reached via its own
-        // tool — refuse with the pointer rather than eat the state. As an error
-        // result, the agent reads the pointer itself; `data` names the refusal
-        // for an in-process caller.
+        // tool — refuse with the pointer rather than eat the state.
         if (this.getDesiredState(entry.serverId, input.channelId) === 'tuned-out') {
-            return {
-                success: false,
-                isError: true,
-                error: `Channel ${input.channelId} is tuned out. Cancel the tune-out ` +
-                    `(tune_out with mode: 'cancel') to resume normal attention — ` +
-                    `cancelling delivers the diverted backlog.`,
-                data: { refusal: 'tuned-out', channelId: input.channelId },
-            };
+            return tunedOutRefusal('channel_open', input.channelId);
         }
         const alreadyDesiredOpen = this.getDesiredState(entry.serverId, input.channelId) === 'open';
         if (entry.open && alreadyDesiredOpen && !input.backscroll && !this.hasPendingLifecycle(entry)) {
+            // Open already, perhaps because speech, a reply, the server or a
+            // policy opened it: the agent's open is still its decision, and is
+            // recorded as one (setDesiredState), so the explicit-open guard of
+            // handleToolClose reads it.
+            try {
+                this.setDesiredState(entry.serverId, input.channelId, 'open', 'agent-tool');
+            }
+            catch (err) {
+                return {
+                    success: false,
+                    error: `Channel ${input.channelId} is already open, but recording your decision to open it failed: ${err.message}`,
+                    isError: true,
+                };
+            }
             return {
                 success: true,
                 data: { channelId: input.channelId, status: 'already open' },
@@ -2540,17 +3545,12 @@ export class ChannelRegistry {
         }
         catch (err) {
             // The decision was recorded before the round-trip and outlives its
-            // failure. Say so: otherwise a later delivery that opens the channel
-            // would be the resident's first sign that it was still wanted open.
-            const current = this.channels.get(`${entry.serverId}:${input.channelId}`);
-            const stillSelected = current !== undefined && !current.open &&
-                this.getDesiredState(entry.serverId, input.channelId) === 'open';
+            // failure. The text says so where it stands: otherwise a later
+            // delivery that opens the channel would be the resident's first sign
+            // that it was still wanted open.
             return {
                 success: false,
-                error: `Failed to open channel: ${err.message}` +
-                    (stillSelected
-                        ? ' (it stays selected for opening: a later delivery or reconnect tries again, and channel_close withdraws that)'
-                        : ''),
+                error: this.lifecycleFailureText('open', entry, err, { history: !!input.backscroll }),
                 isError: true,
             };
         }
@@ -2565,14 +3565,6 @@ export class ChannelRegistry {
                 isError: true,
             };
         }
-        const alreadyDesiredClosed = this.getDesiredState(entry.serverId, input.channelId) === 'closed';
-        if (!entry.open && alreadyDesiredClosed && !this.hasPendingLifecycle(entry) &&
-            !this.unconfirmedChannelTargets.has(entry)) {
-            return {
-                success: true,
-                data: { channelId: input.channelId, status: 'already closed' },
-            };
-        }
         // Provenance comes from trusted dispatch, not from self-description:
         // only module-origin calls may record a machine source, and only from
         // the closed vocabulary. Agent-origin (or origin-less — the safe
@@ -2591,6 +3583,27 @@ export class ChannelRegistry {
             }
             closeSource = input.source;
         }
+        const alreadyDesiredClosed = this.getDesiredState(entry.serverId, input.channelId) === 'closed';
+        if (!entry.open && alreadyDesiredClosed && !this.hasPendingLifecycle(entry) &&
+            !this.unconfirmedChannelTargets.has(entry)) {
+            // Closed already, perhaps only by default: the agent's close is still
+            // its decision, and is recorded as one (setDesiredState), so a later
+            // registration's lift of a default leaves the channel closed.
+            try {
+                this.setDesiredState(entry.serverId, input.channelId, 'closed', closeSource);
+            }
+            catch (err) {
+                return {
+                    success: false,
+                    error: `Channel ${input.channelId} is already closed, but recording the decision to close it failed: ${err.message}`,
+                    isError: true,
+                };
+            }
+            return {
+                success: true,
+                data: { channelId: input.channelId, status: 'already closed' },
+            };
+        }
         // Housekeeping must not override stated intent (issue #5: GC closes wore
         // the agent's badge and reset explicitly-opened doors). A machine-sourced
         // close of a channel whose current desired state is an agent/operator
@@ -2611,39 +3624,31 @@ export class ChannelRegistry {
                 };
             }
         }
-        this.setDesiredState(entry.serverId, input.channelId, 'closed', closeSource);
+        // A decision the log refused changed nothing, and the answer says so.
+        try {
+            this.setDesiredState(entry.serverId, input.channelId, 'closed', closeSource);
+        }
+        catch (err) {
+            return { success: false, error: this.lifecycleFailureText('close', entry, unrecordedDecision(err)), isError: true };
+        }
         this.stopTyping(input.channelId);
-        const server = this.serverRegistry.getServer(entry.serverId);
-        if (!server) {
-            return {
-                success: false,
-                error: `Server not found: ${entry.serverId}`,
-                isError: true,
-            };
+        // Refused now, the close stays recorded for the server's next
+        // registration, and the text says so.
+        if (!this.directsLifecycle(entry.serverId)) {
+            return { success: false, error: this.lifecycleFailureText('close', entry, this.lifecycleRefusal(entry.serverId)), isError: true };
         }
         try {
-            if (!CapabilityGrant.of(server).has('channels.lifecycle')) {
-                return {
-                    success: false,
-                    error: `channels.lifecycle not in "${entry.serverId}"'s effective grant (§14.1)`,
-                    isError: true,
-                };
-            }
             const applied = await this.applyDesiredChannelState(entry.serverId, input.channelId);
-            if (applied.open || this.getDesiredState(entry.serverId, input.channelId) !== 'closed') {
-                throw new Error('Channel close was superseded by a newer lifecycle decision');
-            }
+            const now = this.getDesiredState(entry.serverId, input.channelId);
+            if (applied.open || now !== 'closed')
+                throw new ChannelLifecycleError(supersededClause('close', now), 'superseded');
             return {
                 success: true,
                 data: { channelId: input.channelId, status: 'closed' },
             };
         }
         catch (err) {
-            return {
-                success: false,
-                error: `Failed to close channel: ${err.message}`,
-                isError: true,
-            };
+            return { success: false, error: this.lifecycleFailureText('close', entry, err), isError: true };
         }
     }
     async handleToolDecline(input) {
@@ -2652,28 +3657,54 @@ export class ChannelRegistry {
         if (!entry) {
             return { success: false, error: resolved.error, isError: true };
         }
+        // A tuned-out channel's decision is the tune-out, whatever its transport,
+        // and a decline recorded over it would end it without its cancel, so the
+        // backlog it diverted would never reach the agent. Its cancel is what ends
+        // it, as channel_open's refusal of a tuned-out channel says.
+        if (this.getDesiredState(entry.serverId, input.channelId) === 'tuned-out') {
+            return tunedOutRefusal('channel_decline', input.channelId);
+        }
         if (entry.open || this.getDesiredState(entry.serverId, input.channelId) === 'open') {
+            // channel_close is the call that closes it: its own answer says when,
+            // as for a server that isn't up. A server that's up without that grant
+            // keeps its channels as it chooses, so the text says so, and whom to
+            // ask.
+            const refusal = this.serverReach(entry.serverId) === 'up' && !this.directsLifecycle(entry.serverId)
+                ? this.lifecycleRefusal(entry.serverId) : undefined;
             return {
                 success: false,
-                error: `Channel is already open: ${input.channelId}. Use channel_close to close it.`,
+                error: `Channel "${input.channelId}" is open, or set to open, so there's nothing to decline` +
+                    (refusal ? `, and ${refusal.message}; if you need it closed, ask whoever runs this host.`
+                        : '. If you need it closed, call channel_close.'),
                 isError: true,
             };
         }
         // The lifecycle decision is authoritative even if the optional public
-        // acknowledgment cannot be rendered by the surface.
-        this.setDesiredState(entry.serverId, input.channelId, 'closed', 'invitation-declined');
+        // acknowledgment cannot be rendered by the surface. One the log refused
+        // changed nothing, and nothing after it runs.
+        try {
+            this.setDesiredState(entry.serverId, input.channelId, 'closed', 'invitation-declined');
+        }
+        catch (err) {
+            return {
+                success: false,
+                error: `Nothing changed for channel "${input.channelId}": ${unrecordedDecision(err).message}, so no acknowledgment ` +
+                    'was posted and nothing was sent to the server. Calling channel_decline again tries again; if it fails the same ' +
+                    'way, ask whoever runs this host.',
+                isError: true,
+            };
+        }
         let acknowledged = false;
         let representation;
-        let acknowledgmentError;
+        // What became of an acknowledgment that wasn't posted, worded once the
+        // decline's own outcome is known: each says the decline is recorded,
+        // since it is whatever becomes of the acknowledgment, and a repeated
+        // decline records it again and posts, but only where another decline
+        // would be taken (`retry`).
+        let ackFailure;
         if (input.acknowledge) {
             const server = this.serverRegistry.getServer(entry.serverId);
-            if (!server) {
-                acknowledgmentError = `Server not found: ${entry.serverId}`;
-            }
-            else if (!CapabilityGrant.of(server).has('channels.acknowledge')) {
-                acknowledgmentError = `channels.acknowledge not in "${entry.serverId}"'s effective grant (§14.1)`;
-            }
-            else {
+            if (server && CapabilityGrant.of(server).has('channels.acknowledge')) {
                 try {
                     const result = await server.sendChannelsAcknowledge({
                         channelId: input.channelId,
@@ -2681,53 +3712,200 @@ export class ChannelRegistry {
                         intent: 'seen-not-opening',
                         value: input.acknowledge,
                     });
-                    acknowledged = result.acknowledged;
-                    representation = result.representation;
-                    if (!acknowledged) {
-                        acknowledgmentError = result.reason ??
-                            'The channel integration could not post the acknowledgment.';
+                    // An answer counts by #163's rule, as a publish's does: only
+                    // acknowledged: true confirms a post, and only false denies one.
+                    const receipt = (result ?? {});
+                    if (receipt.acknowledged === true) {
+                        acknowledged = true;
+                        if (typeof receipt.representation === 'string')
+                            representation = receipt.representation;
+                    }
+                    else if (receipt.acknowledged === false) {
+                        // A reason that isn't a non-empty string is none.
+                        const reason = typeof receipt.reason === 'string' && receipt.reason !== '' ? connectorText(receipt.reason) : undefined;
+                        ackFailure = (retry) => reason !== undefined
+                            ? withStop(`The decline is recorded, but the "${entry.serverId}" server didn't post the acknowledgment: ${reason}`)
+                            : `The decline is recorded, but the "${entry.serverId}" server didn't post the acknowledgment, and gave no reason.` +
+                                (retry ? ` To try once more, ${retry}.` : '');
+                    }
+                    else {
+                        ackFailure = (retry) => `The decline is recorded, but the "${entry.serverId}" server's answer didn't say whether it ` +
+                            'posted the acknowledgment.' + (retry ? ' Calling channel_decline again with acknowledge could post it twice.' : '');
                     }
                 }
                 catch (error) {
-                    acknowledgmentError = error.message;
+                    // Only a request that never left the host proves nothing was
+                    // posted, as for a publish (publishErrorOutcome).
+                    const words = requestErrorText(error);
+                    ackFailure = error instanceof McplRequestError && error.outcome === 'not-sent'
+                        ? (retry) => withStop(`The decline is recorded, but the acknowledgment wasn't posted: ${words}`) +
+                            (retry ? ` To try again, ${retry}.` : '')
+                        : (retry) => withStop(`The decline is recorded, but whether the acknowledgment was posted isn't known: ${words}`) +
+                            (retry ? ' Calling channel_decline again with acknowledge could post it twice.' : '');
                 }
             }
+            else {
+                const reach = this.serverReach(entry.serverId);
+                // Read when the acknowledgment was attempted. Where the server is up,
+                // the decline's close can await past a change to its grant, so that
+                // text says what kept the acknowledgment back then.
+                ackFailure = (retry) => reach === 'up'
+                    ? `The decline is recorded, but this host wasn't permitted to post acknowledgments to the "${entry.serverId}" server, ` +
+                        'so none was posted. If you need it, ask whoever runs this host.'
+                    : `The decline is recorded, but the acknowledgment wasn't posted: ${unreachableClause(entry.serverId, reach)}.` +
+                        (reach === 'gone' ? ' If you need it, ask whoever runs this host.'
+                            : retry ? ` To post it, ${retry} ${reach === 'connecting' ? 'in a moment' : "once it's back"}.` : '');
+            }
         }
         // Where the host directs the lifecycle, a decline goes through the
         // lifecycle queue like any closed decision, unless a receipt confirmed
-        // the transport closed with nothing pending: an unconfirmed transport may
-        // be open, and pending work must settle on this decision. A failed close
-        // is reported; the decision stands.
-        let closeError;
+        // the transport closed with nothing pending: an open or unconfirmed
+        // transport may be open, and pending work must settle on this decision.
+        // The decline refused an open channel before its acknowledgment, but
+        // traffic can show one open meanwhile where this host didn't direct the
+        // server's channels, before a grant that now lets it. A decline acts
+        // only on its own decision: one made meanwhile, to open the channel or
+        // tune it out, isn't the decline's to apply. A failed close is reported
+        // below; the decision stands.
+        let closeFailure;
+        let closeFailed = false;
         const current = this.channels.get(`${entry.serverId}:${input.channelId}`);
         if (current && this.directsLifecycle(entry.serverId) &&
-            (this.unconfirmedChannelTargets.has(current) || this.hasPendingLifecycle(current))) {
+            this.getDesiredState(entry.serverId, input.channelId) === 'closed' &&
+            (current.open || this.unconfirmedChannelTargets.has(current) || this.hasPendingLifecycle(current))) {
             try {
-                const applied = await this.applyDesiredChannelState(entry.serverId, input.channelId);
-                if (applied.open)
-                    closeError = 'the close was superseded by a newer lifecycle decision';
+                await this.applyDesiredChannelState(entry.serverId, input.channelId);
             }
             catch (error) {
-                closeError = error.message;
+                closeFailure = error;
+                closeFailed = true;
             }
         }
-        this.appendLifecycleEvent({
-            kind: 'invitation-declined',
-            serverId: entry.serverId,
-            channelId: input.channelId,
-            messageId: input.messageId,
-            acknowledgment: representation ?? input.acknowledge,
-            timestamp: new Date().toISOString(),
-        });
+        // A decision made while the decline ran, to open the channel or tune it
+        // out, replaced it, and that is what stands.
+        const decided = this.getDesiredState(entry.serverId, input.channelId);
+        const stands = decided === 'closed';
+        // The channel as the decline leaves it: closed for certain only where
+        // it is registered, not open, its target confirmed, and no lifecycle
+        // work for it outstanding, as the in-effect texts read it. A close that
+        // didn't complete, a channel this host never confirmed closed, or a
+        // registration that went leaves that unknown. A server without
+        // channels.lifecycle keeps its channels as it chooses, and this host
+        // asks it to open or close none of them, so a channel there is confirmed
+        // closed only by the receipt of a request sent while the server had the
+        // grant, whether the channel was registered or known only from a push.
+        const after = this.channels.get(`${entry.serverId}:${input.channelId}`);
+        const closed = after !== undefined && !after.open && !this.unconfirmedChannelTargets.has(after) &&
+            !this.lifecycleOutstanding.has(this.lifecycleKey(entry.serverId, input.channelId));
+        // `closeError` is the result's sentence for the agent: what became of
+        // the channel, and what follows. Every status but `remained closed`
+        // carries one, and that one none, by this tree; `status` is the word a
+        // caller's code reads. Reconciling closes a channel decided closed when
+        // the server next registers it (for a push's placeholder, if it ever
+        // does), if this host directs their lifecycle then (§14.1), which
+        // laterClause says.
+        let closeError;
+        const reach = this.serverReach(entry.serverId);
+        const serverBack = reach === 'gone' ? ' If you need the server back, ask whoever runs this host.' : '';
+        // What helps now with a registered channel the decline didn't leave
+        // closed for certain, read from the state the reads above found, not
+        // from how it came to be: whom to ask where this host doesn't direct the
+        // server's channels, work still under way where some will carry the
+        // decision out (outstandingWorkCarriesOut, not work a removal cancels),
+        // and otherwise channel_close, which asks for the close now.
+        const stepNow = () => !this.directsLifecycle(entry.serverId)
+            ? (reach === 'up' ? ' If you need it closed sooner, ask whoever runs this host.' : serverBack)
+            : this.outstandingWorkCarriesOut(entry.serverId, this.lifecycleKey(entry.serverId, input.channelId))
+                ? ' Other work for it that\'s still under way applies the decline when its turn comes, so there\'s no need to ' +
+                    'decline again to close it.'
+                : ' If you need it closed now, call channel_close.';
+        if (!stands) {
+            // channel_close closes it after all, whichever decision it was, while
+            // the channel is registered; a server that's up without the grant
+            // keeps its channels as it chooses, as the decline's refusal says.
+            const step = after === undefined
+                ? `. It isn't registered here any more, so no channel tool can reach it until it's registered here again.${serverBack}`
+                : reach === 'up' && !this.directsLifecycle(entry.serverId)
+                    ? `, and ${this.lifecycleRefusal(entry.serverId).message}; if you need it closed, ask whoever runs this host.`
+                    : `. If you still want it closed, call channel_close.${serverBack}`;
+            closeError = decided === 'tuned-out'
+                ? `The decline is recorded, but the channel was tuned out meanwhile, and that decision stands: its messages go to ` +
+                    `the subconscious${step}`
+                : `The decline is recorded, but a later decision to open the channel replaced it, and that decision stands${step}`;
+        }
+        else if (closed) {
+            // Closed for certain, whatever became of the decline's own close: one
+            // refused for a grant that went after an earlier operation confirmed
+            // the close changes nothing the agent needs.
+        }
+        else if (closeFailed) {
+            // What happened comes from the failure: a registration that went
+            // while the close was out says so, since the server may have closed it
+            // first, and one that came back since says that; a request that failed
+            // while the registration went says both. What helps comes from the
+            // state now.
+            const failure = closeFailure instanceof ChannelLifecycleError ? closeFailure : undefined;
+            const went = failure?.kind === 'cancelled' || failure?.kind === 'unlisted';
+            closeError = withStop(`The decline is recorded, and this host closes the channel ${laterClause(entry)}; ` +
+                (!went ? `closing it now didn't complete: ${lifecycleClause(closeFailure)}`
+                    : after !== undefined
+                        ? 'its registration went and came back while the close was out'
+                        : `it isn't registered here any more: ${failure.message}`)) + (after === undefined ? (went ? '' : ' It isn\'t registered here any more.') + serverBack : stepNow());
+        }
+        else if (after === undefined) {
+            // The registration went while the acknowledgment was out, so no close
+            // was tried.
+            closeError = withStop(`The decline is recorded, and this host closes the channel ${laterClause(entry)}; it isn't registered here any more` +
+                (reach !== 'up' ? `: ${unreachableClause(entry.serverId, reach)}` : '')) + serverBack;
+        }
+        else if (!this.directsLifecycle(entry.serverId)) {
+            closeError = reach === 'up'
+                ? `The decline is recorded, but ${this.lifecycleRefusal(entry.serverId).message}, so the server keeps this one open ` +
+                    `or closed as it chooses, and declining again won't change that. This host closes it ${laterClause(entry)}. If you ` +
+                    'need it closed sooner, ask whoever runs this host.'
+                : `The decline is recorded, but ${unreachableClause(entry.serverId, reach)}, so the channel may not be closed there ` +
+                    `yet. This host closes it ${laterClause(entry)}, so there's no need to decline again to close it.` + serverBack;
+        }
+        else {
+            // This host directs the channel's lifecycle and its close didn't fail,
+            // so what remains is other work for it, or a change since that close's
+            // receipt that left it unconfirmed; the step says which.
+            closeError = 'The decline is recorded, but the channel isn\'t closed for certain yet.' + stepNow();
+        }
+        // Another decline is taken only where this one was: the channel
+        // registered, not open, and not decided open.
+        const again = stands && after !== undefined && !after.open;
+        const acknowledgmentError = ackFailure?.(again ? 'call channel_decline again with the same arguments' : undefined);
+        // What the decline found, in a word: the channel remained closed, the
+        // decline stands though the channel may not be closed, or a later
+        // decision replaced it.
+        const status = !stands ? 'replaced' : closed ? 'remained closed' : 'declined';
+        // An audit record nothing reads back: the decline took effect above, so
+        // a log that refuses it is the operator's to hear about, not a failure
+        // of the decline.
+        try {
+            this.appendLifecycleEvent({
+                kind: 'invitation-declined',
+                serverId: entry.serverId,
+                channelId: input.channelId,
+                messageId: input.messageId,
+                acknowledgment: representation ?? input.acknowledge,
+                timestamp: new Date().toISOString(),
+            });
+        }
+        catch (err) {
+            console.error(`[channel-decline] server=${entry.serverId} channel=${logValue(input.channelId)}: the declined invitation wasn't ` +
+                `recorded: ${err instanceof Error ? err.message : String(err)}`);
+        }
         return {
             success: true,
             data: {
                 channelId: input.channelId,
-                status: 'remained closed',
+                status,
                 acknowledged,
                 ...(representation ? { representation } : {}),
                 ...(acknowledgmentError ? { acknowledgmentError } : {}),
-                ...(closeError ? { closeError: `Failed to close the channel's transport: ${closeError}` } : {}),
+                ...(closeError ? { closeError } : {}),
             },
         };
     }
@@ -2810,44 +3988,79 @@ export class ChannelRegistry {
         };
     }
     /**
-     * Host-owned output routing (see forking-knowledge-miner LOCUS-ROUTING-DESIGN).
-     * Publish the agent's plain-text speech to the current conversational locus
-     * (the most recent incoming channel, tracked cross-surface here in the host).
-     * Called by the framework on a text-only turn — replaces the per-surface
-     * sticky auto-post that used to live in discord-mcpl. Returns null when there
-     * is no locus / the channel or its server can't be resolved (in which case
-     * the speech simply stays in chronicle + module surfaces).
-     */
-    /** Resolve the outbound locus (fork HOME → this-turn's TRIGGERING channel →
-     *  process-global default). Public so a multi-segment caller can snapshot it
-     *  ONCE and pin every segment to it via routeSpeech's `overrideChannelId`. */
-    /**
-     * MCPL Spec 14.3 outgoing streaming: forward a moderated text delta to the
-     * server owning the channel, AS THE MODEL GENERATES. Emitted only when that
-     * server declared `channels.streaming` in its initialize capabilities —
-     * servers that never opted in (the whole existing fleet) receive nothing.
-     * Fire-and-forget and never throws: streaming is an observer surface; the
-     * authoritative delivery is the eventual channels/publish.
+     * MCPL Spec 14.3 outgoing streaming: forward a text delta to the server
+     * owning the channel. The framework sends each piece of prose once its
+     * publish succeeds, so a stream carries only what was published.
+     * Emitted only when that server's grant has `channels.streaming` —
+     * servers that never opted in receive nothing. Fire-and-forget and never
+     * throws: streaming is an observer surface; the authoritative delivery is
+     * channels/publish.
+     *
+     * `to` is the destination the publish went to, its server and channel.
+     * The chunk goes there while that server registers that channel (Spec
+     * 14.3: the recipient is "the server that registered the target
+     * channel"). A stream doesn't start in a channel its server has declared
+     * inbound-only (#350's rule), not even for a publish delivered there just
+     * before the declaration. One that started there before it goes on, since
+     * the declaration doesn't unregister the channel: a later chunk is for a
+     * publish delivered before it. A bare channel id is resolved as before, to
+     * the one server that registers it, at each call (streamingServerFor), and
+     * keeps no record: a stream sent by destination ends by destination, since
+     * only a destination's `complete` removes its record.
      */
-    sendOutgoingChunk(channelId, conversationId, inferenceId, index, delta) {
-        const server = this.streamingServerFor(channelId);
+    sendOutgoingChunk(to, conversationId, inferenceId, index, delta) {
+        let server;
+        if (typeof to === 'string') {
+            server = this.streamingServerFor(to);
+        }
+        else {
+            const key = destinationKey(to);
+            let started = this.takenStreams.get(inferenceId);
+            const continuing = started?.has(key) ?? false;
+            server = this.streamingServerAt(to, !continuing);
+            if (server && !continuing) {
+                if (!started)
+                    this.takenStreams.set(inferenceId, started = new Set());
+                started.add(key);
+            }
+        }
         if (!server)
             return;
+        const channelId = typeof to === 'string' ? to : to.channelId;
         try {
             server.sendChannelsOutgoingChunk({ inferenceId, conversationId, channelId, index, delta });
         }
         catch { /* observer surface — never disturb the turn */ }
     }
-    /** Spec 14.3 companion: final moderated content per channel at stream end. */
-    sendOutgoingComplete(channelId, conversationId, inferenceId, text) {
-        const server = this.streamingServerFor(channelId);
+    /**
+     * Spec 14.3 companion: final moderated content per channel at stream end.
+     * Given a destination, it goes only where the stream started
+     * (sendOutgoingChunk), while that server still registers that channel,
+     * inbound-only or not, and its grant has `channels.streaming`: once per
+     * destination, whose consumer, such as a TTS utterance, finalizes on it
+     * and reconciles any chunk it missed. A bare channel id is resolved as
+     * before (streamingServerFor).
+     */
+    sendOutgoingComplete(to, conversationId, inferenceId, text) {
+        let server;
+        if (typeof to === 'string') {
+            server = this.streamingServerFor(to);
+        }
+        else {
+            const started = this.takenStreams.get(inferenceId);
+            if (!started?.delete(destinationKey(to)))
+                return;
+            if (started.size === 0)
+                this.takenStreams.delete(inferenceId);
+            server = this.streamingServerAt(to, false);
+        }
         if (!server)
             return;
         try {
             server.sendChannelsOutgoingComplete({
                 inferenceId,
                 conversationId,
-                channelId,
+                channelId: typeof to === 'string' ? to : to.channelId,
                 content: [{ type: 'text', text }],
             });
         }
@@ -2861,6 +4074,10 @@ export class ChannelRegistry {
         const matches = [...this.channels.values()].filter((e) => e.descriptor.id === channelId);
         if (matches.length !== 1)
             return null;
+        // Nothing is published into an inbound-only channel, so nothing is
+        // streamed there either.
+        if (isInboundOnly(matches[0]))
+            return null;
         const server = this.serverRegistry.getServer(matches[0].serverId);
         // §5.4: the GRANT gates streaming, not the raw advertisement. The old
         // `capabilities?.channels?.streaming` check was doubly wrong: undefined
@@ -2871,6 +4088,25 @@ export class ChannelRegistry {
             return null;
         return server;
     }
+    /**
+     * A destination's server, for a stream message: while that server
+     * registers that channel, and its grant has `channels.streaming` (as in
+     * streamingServerFor). A stream doesn't start in an inbound-only channel.
+     */
+    streamingServerAt(to, starting) {
+        // The map's key joins the two ids with a colon, so another server's
+        // entry can sit under a destination's key: it has to be this server's.
+        const entry = this.channels.get(`${to.serverId}:${to.channelId}`);
+        if (!entry || entry.serverId !== to.serverId)
+            return null;
+        if (starting && isInboundOnly(entry))
+            return null;
+        const server = this.serverRegistry.getServer(to.serverId);
+        return CapabilityGrant.of(server).has('channels.streaming') ? server : null;
+    }
+    /** Resolve the outbound locus (fork HOME → this-turn's TRIGGERING channel →
+     *  process-global default). Public so a multi-segment caller can snapshot it
+     *  ONCE and pin every segment to it via routeSpeech's `overrideChannelId`. */
     resolveLocus(conversationId) {
         const home = this.homeChannelResolver?.(conversationId);
         return home ?? this.activeChannelResolver?.(conversationId) ?? this.globalFallbackFor(conversationId);
@@ -2910,13 +4146,17 @@ export class ChannelRegistry {
         if (matches.length === 0) {
             return {
                 error: target.serverId
-                    ? `no registered channel "${target.channelId}" on server "${target.serverId}"`
-                    : `no registered channel "${target.channelId}"`,
+                    ? `the "${target.serverId}" server has no channel "${target.channelId}" registered here`
+                    : `no channel "${target.channelId}" is registered here`,
             };
         }
         if (matches.length > 1) {
             return {
-                error: `channel id "${target.channelId}" is registered by more than one MCPL server; the destination must name its server`,
+                // Speech names no server, and neither its >> prefix nor
+                // channel_publish can: whoever runs this host can. A caller that
+                // can name one reads that none was.
+                error: `channel id "${target.channelId}" is on more than one server, and no server was named for these words; ` +
+                    'if you need them there, ask whoever runs this host',
             };
         }
         return { entry: matches[0] };
@@ -2938,7 +4178,33 @@ export class ChannelRegistry {
      * possible to send into a closed channel: a closed but registered
      * destination is opened first (`openSource` names why), once its server
      * and that server's channels.publish grant are known to take the send, so
-     * a refused send opens nothing; and a failed open sends nothing.
+     * a send refused before the open opens nothing; and a failed open sends
+     * nothing.
+     *
+     * A channel its server declared inbound-only (isInboundOnly) takes nothing
+     * the host would post, whichever path the words took, a drafts resend
+     * included: it's refused before anything opens. The channel's queued
+     * lifecycle work and the open await the server, and a channels/changed
+     * update, a re-register or the open's own answer (applyOpenDeclaration)
+     * may declare the channel inbound-only meanwhile, or a removal take it
+     * away. So the check just before the publish, after every await, reads
+     * the channel's registration as it is then, and refuses one that is gone
+     * or inbound-only, or whose server's grant no longer has channels.publish.
+     * A removal during a wait already fails it there (waitForOpenChannel); the
+     * check also catches one made after the last wait, as the opening's notice
+     * can. A registration nothing has confirmed open, such as one that
+     * replaced the one waited for or a retarget of it, or one whose close now
+     * stands (where the host directs the server's lifecycle), is treated as at
+     * the first wait: the words wait for its queued lifecycle work, and the
+     * check runs again on the registration that work leaves. Words refused
+     * after an open for a declaration leave the channel open, and the agent
+     * gets the failure for the words. An open by delivery (`openSource`
+     * 'opened-by-delivery', the default) that turned a closed channel open
+     * also gives the notice that it's open, which says how to close it to a
+     * reader that can.
+     * One that only reconfirmed the transport of a channel already decided
+     * open or tuned out changes no decision, and gives none. When the
+     * registration is gone, the failure says the channel was removed.
      *
      * Only the connector's `delivered: true` confirms a post. `failed` means
      * nothing was posted: the attempt stopped before the request was written,
@@ -2963,20 +4229,19 @@ export class ChannelRegistry {
         };
         // A send that would be refused is refused before anything opens: a
         // closed channel opens only for words that can go out.
-        const server = this.serverRegistry.getServer(entry.serverId);
-        if (!server) {
-            return { status: 'failed', destination, reason: `server "${entry.serverId}" not found`, at: at() };
+        if (isInboundOnly(entry)) {
+            return { status: 'failed', destination, reason: inboundOnlyReason(entry), at: at() };
         }
+        const server = this.serverRegistry.getServer(entry.serverId);
         // §14.1: channels/publish requires channels.publish in the grant. The
-        // host not sending is the enforcement.
-        if (!CapabilityGrant.of(server).has('channels.publish')) {
-            return {
-                status: 'failed',
-                destination,
-                reason: `channels.publish not in "${entry.serverId}"'s effective grant (§14.1)`,
-                at: at(),
-            };
-        }
+        // host not sending is the enforcement, here and at the last check, and
+        // the server's state words the refusal (sendRefusal).
+        const ungranted = () => ({ status: 'failed', destination, reason: this.sendRefusal(entry.serverId), at: at() });
+        if (!server || !CapabilityGrant.of(server).has('channels.publish'))
+            return ungranted();
+        const prevented = (err) => ({
+            status: 'failed', destination, reason: lifecycleClause(err) + refusalRemedy(err), at: at(),
+        });
         // Lifecycle work already queued for the channel settles first: words go
         // out only into the channel it leaves, and fail visibly if it leaves
         // none open.
@@ -2985,12 +4250,7 @@ export class ChannelRegistry {
                 entry = await this.waitForOpenChannel(entry);
             }
             catch (err) {
-                return {
-                    status: 'failed',
-                    destination,
-                    reason: `lifecycle work prevented delivery: ${connectorText(err instanceof Error ? err.message : String(err))}`,
-                    at: at(),
-                };
+                return prevented(err);
             }
         }
         // INVARIANT: it is not possible to send into a closed channel. A send
@@ -3034,13 +4294,44 @@ export class ChannelRegistry {
                 }
             }
             catch (err) {
-                return {
-                    status: 'failed',
-                    destination,
-                    reason: `channel is closed and open failed: ${connectorText(err instanceof Error ? err.message : String(err))}`,
-                    at: at(),
-                };
+                return { status: 'failed', destination, reason: openFailedReason(err), at: at() };
+            }
+        }
+        // Checked again here, after every await above, the lifecycle work's, the
+        // open's or any other: a registration that is gone, or inbound-only, at
+        // this moment takes nothing. The entry is read from the map rather than
+        // taken from the last wait: the opening's notice runs in between, and
+        // publish() resumes a microtask after the wait. A registration nothing
+        // has confirmed open, such as one that replaced the one waited for
+        // (registered with open: false) or a retarget of it (marked unconfirmed),
+        // or one whose close now stands (closeStands), is treated as at the
+        // first wait: the words wait for its queued lifecycle work, and
+        // waitForOpenChannel refuses what that work leaves unconfirmed or with
+        // its close standing. The loop opens nothing itself. The check then runs
+        // again on the registration that stands. waitForOpenChannel returns
+        // only a registration it found open and whose close doesn't stand, or
+        // throws, so the loop ends unless the channel keeps changing.
+        const key = `${entry.serverId}:${entry.descriptor.id}`;
+        let current = this.channels.get(key);
+        while (current && !isInboundOnly(current) && (!current.open || this.closeStands(current))) {
+            try {
+                entry = await this.waitForOpenChannel(current);
             }
+            catch (err) {
+                return prevented(err);
+            }
+            current = this.channels.get(key);
+        }
+        if (!current)
+            return { status: 'failed', destination, reason: CHANNEL_REMOVED_CLAUSE, at: at() };
+        if (isInboundOnly(current)) {
+            return { status: 'failed', destination, reason: inboundOnlyReason(current), at: at() };
+        }
+        // A grant reduced during any of the waits holds at once (§6.7): the
+        // words already on their way take it too. Its refusal is worded for the
+        // connection that refused (sendRefusal's `checked`).
+        if (!CapabilityGrant.of(server).has('channels.publish')) {
+            return { status: 'failed', destination, reason: this.sendRefusal(entry.serverId, server), at: at() };
         }
         let result;
         try {
@@ -3059,9 +4350,13 @@ export class ChannelRegistry {
      * Plain speech for one turn segment: publish `text` to the turn's frozen
      * locus and report the PublishOutcome. A failure (or an uncertain outcome)
      * is surfaced as a trace and through onRouteFailure, so the agent learns
-     * its words did not (or may not have) reached anyone. An ephemeral run's
-     * speech with no locus is the exception: it is its caller's result, so it
-     * returns as not delivered and surfaces nothing.
+     * its words did not (or may not have) reached anyone. A `failed` one whose
+     * caller holds its words with a notice of its own (`heldOnFailure`) gets
+     * the trace but not onRouteFailure. An ephemeral run's speech with no locus
+     * (null) is its caller's result: it returns as not delivered and surfaces
+     * nothing. This is host-owned output routing (see forking-knowledge-miner
+     * LOCUS-ROUTING-DESIGN), which replaced the per-surface sticky auto-post
+     * that used to live in discord-mcpl.
      */
     async deliverSpeech(conversationId, text, 
     /** The turn's FROZEN locus, snapshotted once by the caller (resolveLocus
@@ -3078,16 +4373,18 @@ export class ChannelRegistry {
      *  draft with its own notice, so no failure marker is written for it.
      *  An `unknown` outcome still gets its marker. */
     opts) {
-        const fail = (channelId, reason, outcome) => {
+        // `logged` is what the log line and the trace say, where it isn't the
+        // agent's reason (the two no-locus reasons below).
+        const fail = (channelId, reason, outcome, logged = reason) => {
             const status = outcome.status === 'unknown' ? 'unknown' : 'failed';
             const detail = outcome.detail !== undefined ? connectorText(outcome.detail) : undefined;
             const detailText = detail !== undefined ? `; connector detail: ${detail}` : '';
-            console.error(`[routeSpeech] ${conversationId}: ${reason}${detailText} — speech ${status === 'unknown' ? 'delivery NOT confirmed' : 'NOT routed'} (${text.length} chars stay in chronicle)`);
+            console.error(`[routeSpeech] ${conversationId}: ${logged}${detailText} — speech ${status === 'unknown' ? 'delivery NOT confirmed' : 'NOT routed'} (${text.length} chars stay in chronicle)`);
             this.emitTraceFn({
                 type: 'mcpl:speech-route-failed',
                 conversationId,
                 channelId: channelId ?? '',
-                reason,
+                reason: logged,
                 textLen: text.length,
                 outcome: status,
                 ...(detail !== undefined ? { detail } : {}),
@@ -3097,12 +4394,18 @@ export class ChannelRegistry {
             }
             return outcome;
         };
+        // These two reasons are the only ones whose log line and trace keep the
+        // operator's words rather than the agent's: connectome-host's
+        // connectome-doctor reads the last [routeSpeech] line for "no locus". Keep
+        // "no locus" in both logged texts. Each names no tool: whether one the
+        // agent may call could post the words isn't known here, and the notice
+        // calls it a routing or configuration situation.
         // Runtime backstop for JS callers the compiler can't see: an omitted
         // locus is a routing bug at the call site, never something to paper over
         // with a live re-resolution.
         if (locusChannelId === undefined) {
-            const reason = 'caller passed no locus (routing bug: every speech path must snapshot the turn locus)';
-            return fail(null, reason, { status: 'failed', reason, at: Date.now() });
+            const reason = 'the host lost track of which channel this reply was for; if this keeps happening, ask whoever runs this host';
+            return fail(null, reason, { status: 'failed', reason, at: Date.now() }, 'caller passed no locus (routing bug: every speech path must snapshot the turn locus)');
         }
         if (!locusChannelId) {
             // An ephemeral run with no channel of its own: its plain speech is its
@@ -3114,8 +4417,10 @@ export class ChannelRegistry {
             // The turn froze with no locus (no home, no triggering channel, no
             // global inbound ever seen) — the agent was told its prose stays in
             // the archive; honor that.
-            const reason = 'turn has no locus (no home/trigger channel; nothing to deliver into)';
-            return fail(null, reason, { status: 'failed', reason, at: Date.now() });
+            // The locus froze at the turn's start, so this says what the turn had.
+            const reason = 'this turn came from no channel, and it had no home or recent channel to reply in; if it should have ' +
+                'had one, ask whoever runs this host';
+            return fail(null, reason, { status: 'failed', reason, at: Date.now() }, 'turn has no locus (no home/trigger channel; nothing to deliver into)');
         }
         const outcome = await this.publish(conversationId, text, { channelId: locusChannelId, routed: true });
         const channelId = outcome.destination?.channelId ?? locusChannelId;
@@ -3145,56 +4450,81 @@ export class ChannelRegistry {
             return null;
         return {
             delivered: true,
+            serverId: outcome.destination.serverId,
             channelId: outcome.destination.channelId,
             ...(outcome.messageId !== undefined ? { messageId: outcome.messageId } : {}),
         };
     }
-    async handleToolPublish(input, origin) {
-        // Resolve content: accept both `content` and `text` (backward compat)
+    /**
+     * channel_publish, and the subconscious's speak_in_channel
+     * (publishForAgent), which shares its delivery. Where an agent finds a
+     * channel id differs: the subconscious isn't offered channel_list, and is
+     * given speak_in_channel for the tuned-out channels whose messages it reads.
+     */
+    async handleToolPublish(input, origin, 
+    /** Filled for publishForAgent: the publish's outcome once a request is
+     *  attempted, for its trace, or which check of the destination refused
+     *  it before anything went out, for its answer. */
+    seen, tool = 'channel_publish') {
+        const findIds = tool === 'channel_publish'
+            ? 'channel_list shows the channel ids.'
+            : 'Use the id of a tuned-out channel whose messages you are reading.';
+        // Resolve content: accept both `content` and `text` (backward compat).
+        // speak_in_channel checks its own text first, so only channel_publish
+        // reads this refusal.
         const messageText = input.content ?? input.text;
         if (!messageText) {
-            return {
-                success: false,
-                error: 'Either content or text parameter is required',
-                isError: true,
-            };
+            return { success: false, error: 'Nothing was posted: channel_publish needs the message in `content`.', isError: true };
+        }
+        // An empty channelId names nothing, and isn't read as one left out.
+        // speak_in_channel's caller passes one left out as empty, so there it
+        // gets the refusal for one left out, as speak_in_channel has no default.
+        if (input.channelId === '' && tool === 'channel_publish') {
+            return { success: false, error: `Nothing was posted: channelId is empty. ${findIds}`, isError: true };
         }
-        // Resolve channelId: default to the most recent incoming channel, which an
-        // ephemeral run never takes (takesGlobalFallback), so it names one.
+        // Resolve channelId: default to the channel of the most recent incoming
+        // message that isn't a reaction, reaction removal, edit or deletion
+        // marker, apart from an edit the coalescer delivers on acceptance as the
+        // agent's first view. An ephemeral run never takes that default
+        // (takesGlobalFallback), so it names one.
         const caller = origin?.kind === 'agent' ? origin.agentName : undefined;
         const channelId = input.channelId ?? (caller !== undefined ? this.globalFallbackFor(caller) : this.defaultPublishChannel);
         if (!channelId) {
             return {
                 success: false,
-                error: caller !== undefined && this.takesGlobalFallback?.(caller) === false
-                    ? 'Nothing was published: name the channel with channelId. A subagent has no default channel, since its plain '
-                        + 'speech is returned to whoever called it, so channel_publish sends only to a channel it names.'
-                    : 'No channelId specified and no default channel available',
+                error: tool === 'speak_in_channel'
+                    ? `Nothing was posted: speak_in_channel needs a \`channelId\`. ${findIds}`
+                    : caller !== undefined && this.takesGlobalFallback?.(caller) === false
+                        ? 'Nothing was posted: name the channel with channelId. A subagent has no default channel, since its plain '
+                            + 'speech is returned to whoever called it, so channel_publish sends only to a channel it names.'
+                        : `Nothing was posted: channel_publish needs a \`channelId\`, and there's no channel to default to yet. ${findIds}`,
                 isError: true,
             };
         }
         const entry = this.findChannelEntry(channelId);
         if (!entry) {
-            return {
-                success: false,
-                error: `Channel not found: ${channelId}`,
-                isError: true,
-            };
+            if (seen)
+                seen.refusal = 'channel-not-registered';
+            return { success: false, error: `No channel has the id "${channelId}", so nothing was posted. ${findIds}`, isError: true };
         }
-        const server = this.serverRegistry.getServer(entry.serverId);
-        if (!server) {
+        if (isInboundOnly(entry)) {
+            if (seen)
+                seen.refusal = 'inbound-only';
             return {
                 success: false,
-                error: `Server not found: ${entry.serverId}`,
+                error: `Channel ${channelId} is ${inboundOnlyReason(entry)}`,
                 isError: true,
             };
         }
-        if (!CapabilityGrant.of(server).has('channels.publish')) {
-            return {
-                success: false,
-                error: `channels.publish not in "${server.id}"'s effective grant (§14.1)`,
-                isError: true,
-            };
+        // The same refusal, in the same words, as plain speech's (sendRefusal),
+        // whose server state is the reason's: nothing awaits between the two.
+        const server = this.serverRegistry.getServer(entry.serverId);
+        if (!server || !CapabilityGrant.of(server).has('channels.publish')) {
+            if (seen) {
+                const reach = this.serverReach(entry.serverId);
+                seen.refusal = reach === 'up' ? 'not-permitted' : `server-${reach}`;
+            }
+            return { success: false, error: `Nothing was posted to channel "${channelId}": ${this.sendRefusal(entry.serverId)}.`, isError: true };
         }
         const publishParams = {
             conversationId: '', // Framework will fill this when wired
@@ -3216,7 +4546,13 @@ export class ChannelRegistry {
         }
         catch (err) {
             outcome = publishErrorOutcome(err, destination, Date.now());
+            // Refused before anything was written: nothing went out, as its words
+            // say, so it's a refusal of the destination like the checks above.
+            if (seen && err instanceof McplRequestError && err.outcome === 'not-sent')
+                seen.refusal = 'not-sent';
         }
+        if (seen)
+            seen.outcome = outcome;
         if (outcome.status === 'delivered')
             return { success: true, data: result };
         // The connector's data may say what a multi-part send already posted.
@@ -3224,8 +4560,8 @@ export class ChannelRegistry {
         return {
             success: false,
             error: (outcome.status === 'failed'
-                ? `Publish to ${channelId} failed: ${outcome.reason}. Nothing was posted.`
-                : `Publish to ${channelId} wasn't confirmed: ${outcome.reason}. ` +
+                ? `Nothing was posted to channel "${channelId}": ${outcome.reason}.`
+                : `Posting to channel "${channelId}" wasn't confirmed: ${outcome.reason}. ` +
                     'It may or may not have been posted, so sending it again could post it twice.') + detail,
             isError: true,
         };