@animalabs/agent-framework 0.26.2 → 0.27.0

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

@@ -23,6 +23,7 @@ import { RefusalLines } from './refusal-lines.js';
 import { CapabilityGrant } from './capability-grant.js';
 import { McplRequestError } from './server-connection.js';
 import { readSkipReplyWake } from './skip-reply-wake.js';
+import { isProseTargetToken } from './prose-grammar.js';
 // ============================================================================
 // Typing indicator interval (Discord typing lasts ~10s, so 7s keeps it alive)
 // ============================================================================
@@ -70,6 +71,20 @@ class ChannelLifecycleError extends Error {
         this.by = options?.by;
     }
 }
+/** Whether a lifecycle failure, or one it wraps (an overtaken open's
+ *  `cause`), is convergence that never established the channel's target.
+ *  Words don't go into such a channel on the strength of a close the agent
+ *  decided meanwhile (refusalGivesWay): the address they'd go to is the one
+ *  that kept changing. A later operation that settles on the current target
+ *  establishes it, so this is the failure's, not the channel's (compare
+ *  answeredElsewhere). */
+function convergeFailure(err) {
+    for (let e = err; e instanceof Error; e = e.cause) {
+        if (e instanceof ChannelLifecycleError && e.kind === 'converge')
+            return true;
+    }
+    return false;
+}
 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. */
@@ -194,6 +209,10 @@ function shallowEqualRecord(a, b) {
     }
     return true;
 }
+/** The ref naming a registered channel's entry. */
+function refOf(entry) {
+    return { serverId: entry.serverId, channelId: entry.descriptor.id };
+}
 /**
  * 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
@@ -305,7 +324,8 @@ const CHANNEL_TOOL_DEFINITIONS = [
     {
         name: 'channel_close',
         description: 'Close a channel. Messages that address you still reach you; what else stops reaching you ' +
-            'depends on its server.',
+            'depends on its server. You can still speak there. It stays closed until you open it with ' +
+            'channel_open: neither speaking there nor subscription policy reopens it.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -405,11 +425,33 @@ 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. */
+/** One key per channel, its server and id: unlike joining the two with a
+ *  separator, no two channels share one, whatever their ids hold. */
 export function destinationKey(to) {
     return JSON.stringify([to.serverId, to.channelId]);
 }
+/** Whether two refs name the same channel. Two absent refs are the same:
+ *  neither names a channel. */
+export function sameChannel(a, b) {
+    if (!a || !b)
+        return !a && !b;
+    return a.serverId === b.serverId && a.channelId === b.channelId;
+}
+/**
+ * A channel's server-qualified name, `serverId:channelId`. A name given as a
+ * string (a tool's channelId, a `>>` target, a host's call) may take this
+ * form to pick one server's channel where several servers register the id.
+ * It is looked up among the registered pairs, never split at a colon, since
+ * ids hold colons (ChannelRegistry.entriesNamed).
+ */
+export function qualifiedChannelName(ref) {
+    return `${ref.serverId}:${ref.channelId}`;
+}
+/** A channel told apart by its id and its server, for one no string picks
+ *  alone: `"b:room" on server "a"`. No input takes it for a name. */
+function channelOnServer(ref) {
+    return `${JSON.stringify(ref.channelId)} on server ${JSON.stringify(ref.serverId)}`;
+}
 /**
  * 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
@@ -516,27 +558,6 @@ function supersededClause(action, now) {
         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';
 }
-/** What ends a tune-out, for a channel tool's answer about a tuned-out
- *  channel (`channel` as the answer shows it, quoted): its cancel, with the
- *  backlog it delivers, and, for a close, that channel_close closes the
- *  channel once the cancel has ended the tune-out. */
-function tunedOutPointer(tool, channel) {
-    return `Call tune_out with channelId ${channel} and mode "cancel" for it to resume normal attention; cancelling ` +
-        'delivers the diverted backlog' + (tool === 'channel_close' ? ', and channel_close closes it after that.' : '.');
-}
-/** 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. ` +
-            tunedOutPointer(tool, `"${channelId}"`),
-        data: { refusal: 'tuned-out', channelId },
-    };
-}
 /** A clause as the start of a sentence. */
 function sentenceStart(clause) {
     return clause.charAt(0).toUpperCase() + clause.slice(1);
@@ -609,6 +630,19 @@ function publishReceiptOutcome(result, destination, at) {
  *  Closed on purpose: honest provenance means a small, auditable vocabulary,
  *  not arbitrary self-description. */
 export const MACHINE_CLOSE_SOURCES = new Set(['subscription-gc', 'housekeeping']);
+/** A close a module made through its own tool call (ctx.callTool) without a
+ *  machine source, such as connectome-host's mentions mode: a decision the
+ *  module owns, with its own way back. Speech leaves it closed, as it does a
+ *  channel the agent closed (speechOpens), but the agent isn't told how to
+ *  open it, since channel_open alone would undo only part of what the
+ *  module did. */
+export const MODULE_CLOSE_SOURCE = 'module-tool';
+/** Whether a closed record is a close the agent or a module decided
+ *  (channel_close, channel_decline, or a module's own close), which speech
+ *  never undoes. */
+function isCloseDecision(source) {
+    return AGENT_DECISION_SOURCES.has(source) || source === MODULE_CLOSE_SOURCE;
+}
 export class ChannelRegistry {
     serverRegistry;
     featureSetManager;
@@ -623,7 +657,11 @@ export class ChannelRegistry {
     takesGlobalFallback;
     serverConnecting;
     store;
-    /** Registered channels, keyed by `{serverId}:{channelId}`. */
+    /**
+     * Registered channels, keyed by their server and id (destinationKey): a
+     * key that joined the two with a separator would let server `a`'s channel
+     * `b:room` and server `a:b`'s channel `room` share one entry.
+     */
     channels = new Map();
     /**
      * Each outgoing stream, by `inferenceId`, with the destinations it has
@@ -688,10 +726,12 @@ export class ChannelRegistry {
     /** The same message's id and thread, used for buildChannelContext. */
     defaultPublishMessageId = null;
     defaultPublishThreadId = undefined;
-    /** Per-channel typing indicator timers. */
+    /** Per-channel typing indicator timers, by destinationKey, with the
+     *  channel each one types in. */
     typingIntervals = new Map();
-    /** Per-channel typing metadata — carried on the 7s refresh so the target
-     *  server keeps getting the same routing hints (e.g. Zulip topic). */
+    /** Per-channel typing metadata, by destinationKey — carried on the 7s
+     *  refresh so the target server keeps getting the same routing hints (e.g.
+     *  Zulip topic). */
     typingMetadata = new Map();
     /** Chronicle-projected desired lifecycle state, keyed by server + channel.
      *  Provenance is kept so reconcile can tell a pure default (nobody ever
@@ -719,6 +759,16 @@ export class ChannelRegistry {
     // Losing an open receipt does not confirm closure. Keep that distinction
     // private while preserving the public open:boolean availability projection.
     unconfirmedChannelTargets = new WeakSet();
+    // Registrations whose last open the server answered for another channel,
+    // until an open is answered for this one, or the server registers the
+    // channel again, which makes a new registration: a server that doesn't
+    // resolve this id may not resolve a publish by it either. A close's answer
+    // names no channel, so it doesn't clear the mark, and a retarget keeps the
+    // registration and its mark. Read where speech would put words into such a
+    // channel without an open (publish). Where the grant loses
+    // channels.lifecycle while the connection stays (§6.7), no open can clear
+    // the mark until the server reconnects and registers the channel again.
+    answeredElsewhere = 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,
@@ -750,7 +800,7 @@ export class ChannelRegistry {
     /** 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. */
+     *  as the open step reads it too (speechOpens). */
     closeStands(entry) {
         return this.getDesiredState(entry.serverId, entry.descriptor.id) === 'closed' &&
             this.directsLifecycle(entry.serverId);
@@ -823,7 +873,8 @@ export class ChannelRegistry {
      * is in the connection's words.
      */
     lifecycleFailureText(action, entry, err, opts) {
-        const channel = `"${entry.descriptor.id}"`;
+        // As the agent names it back (nameShown), where another server shares its id.
+        const channel = this.quotedShown(refOf(entry));
         const tool = action === 'open' ? 'channel_open' : 'channel_close';
         const done = action === 'open' ? 'opened' : 'closed';
         const later = laterClause(entry);
@@ -835,7 +886,7 @@ export class ChannelRegistry {
         }
         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}`);
+        const current = this.entryAt(refOf(entry));
         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,
@@ -858,13 +909,13 @@ export class ChannelRegistry {
         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.`;
+                    `change that. ${this.tuneOutEndText(current)}`;
             }
             // channel_close refuses a tuned-out channel too, so calling it again
             // isn't the way: the tune-out's cancel is, and it delivers the backlog.
             if (action === 'close' && now === 'tuned-out') {
                 return `Channel ${channel} was tuned out meanwhile: its messages go to the subconscious, and channel_close doesn't ` +
-                    `change that. ${tunedOutPointer('channel_close', channel)}`;
+                    `change that. ${this.tuneOutEndText(current, 'channel_close')}`;
             }
             // 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
@@ -1009,7 +1060,7 @@ export class ChannelRegistry {
                 results.push({ id: String(channel?.id ?? ''), accepted: false, reason: 'invalid descriptor: missing id' });
                 continue;
             }
-            const key = `${serverId}:${channel.id}`;
+            const key = destinationKey({ serverId, channelId: channel.id });
             this.registerEntry(key, serverId, channel);
             this.appendLabelSighting(channel.id, channel.label, extractDmMeta(channel.metadata));
             registeredIds.push(channel.id);
@@ -1048,9 +1099,11 @@ export class ChannelRegistry {
         // we never had is reported, not silently accepted.
         if (params.removed) {
             for (const channelId of params.removed) {
-                const key = `${serverId}:${channelId}`;
-                const existed = this.channels.delete(key);
-                this.stopTyping(channelId);
+                // A server may name the channel by a number: it means the channel
+                // whose id is that number as a string, as it always has.
+                const ref = { serverId, channelId: String(channelId) };
+                const existed = this.channels.delete(destinationKey(ref));
+                this.stopTyping(ref);
                 addedResults.push({ id: channelId, accepted: existed, reason: existed ? undefined : 'not registered' });
             }
         }
@@ -1065,7 +1118,7 @@ export class ChannelRegistry {
                     this.emitTraceFn({ type: 'mcpl:channel-descriptor-rejected', serverId, reason: 'missing id (update)' });
                     continue;
                 }
-                const key = `${serverId}:${channel.id}`;
+                const key = destinationKey({ serverId, channelId: channel.id });
                 const existing = this.channels.get(key);
                 if (!existing) {
                     addedResults.push({ id: channel.id, accepted: false, reason: 'not registered — update rejected (§14.5)' });
@@ -1105,7 +1158,7 @@ export class ChannelRegistry {
                     this.emitTraceFn({ type: 'mcpl:channel-descriptor-rejected', serverId, reason: 'missing id' });
                     continue;
                 }
-                const key = `${serverId}:${channel.id}`;
+                const key = destinationKey({ serverId, channelId: channel.id });
                 this.registerEntry(key, serverId, channel);
                 this.appendLabelSighting(channel.id, channel.label, extractDmMeta(channel.metadata));
                 addedResults.push({ id: channel.id, accepted: true });
@@ -1175,6 +1228,9 @@ export class ChannelRegistry {
         // 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;
+        // And came from a server registered now: one removed since (removeServer)
+        // gives no message the agent replies to (markAccepted).
+        const removalsAtArrival = this.serverRemovals.get(serverId) ?? 0;
         for (const message of params.messages) {
             if (!message || typeof message.channelId !== 'string' || !message.channelId
                 || typeof message.messageId !== 'string' || !message.messageId) {
@@ -1209,7 +1265,7 @@ export class ChannelRegistry {
             // exists registers it first; discord's DM case goes through
             // 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}`;
+            const incomingKey = destinationKey({ serverId, channelId: message.channelId });
             if (!this.channels.has(incomingKey)) {
                 // Loud, coalesced or not, like every other refusal of a message, but
                 // at most once a minute per channel (RefusalLines): a server that
@@ -1290,8 +1346,11 @@ export class ChannelRegistry {
                 // 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;
+                // A message the coalescer admits after its server was removed sets no
+                // default: the removal cleared that server's message, and a server
+                // that's gone mustn't displace a live one's default.
+                if (!isMarkerTagged(message.tags, firstView) && (this.serverRemovals.get(serverId) ?? 0) === removalsAtArrival) {
+                    this.defaultPublishChannel = { serverId, channelId: message.channelId };
                     this.defaultPublishMessageId = message.messageId;
                     this.defaultPublishThreadId = message.threadId;
                 }
@@ -1453,7 +1512,9 @@ export class ChannelRegistry {
      * overwrites this descriptor with the richer one.
      */
     ensureChannelRegistered(serverId, channelId, label, extraMetadata) {
-        const existing = this.findChannelEntry(channelId);
+        // This server's own registration: another server's channel with the same
+        // id is another channel (ChannelRef), which this one doesn't make.
+        const existing = this.entryAt({ serverId, channelId });
         if (existing) {
             // Backfill identity onto a bare lazy registration: a DM that first
             // arrived with no label/recipient info gets a usable name the next
@@ -1493,7 +1554,7 @@ export class ChannelRegistry {
         // 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, {
+        const entry = this.registerEntry(destinationKey({ serverId, channelId }), serverId, {
             id: channelId,
             type: serverId,
             label: label ?? channelId,
@@ -1512,88 +1573,101 @@ export class ChannelRegistry {
     // Typing Indicator Management
     // ==========================================================================
     /**
-     * Start sending typing indicators for a channel.
+     * Start sending typing indicators for a channel: the channel a ref names,
+     * or each channel a name given as a string means (entriesNamed). A host
+     * names channels by the ids it keeps (connectome-host's activity module),
+     * and typing posts nothing, so a name two servers' channels answer to
+     * shows typing in both, rather than in neither or in whichever registered
+     * first. Where two servers reach one platform channel, two bots can then
+     * show typing there.
      *
      * Sends a typing notification immediately and every 7 seconds thereafter.
      * Discord typing indicators last ~10s, so 7s keeps them alive.
      *
-     * No-op if already typing on this channel.
+     * No-op for a channel already typing, or not registered.
      */
-    startTyping(channelId, metadata) {
+    startTyping(channel, metadata) {
+        const refs = typeof channel === 'string' ? this.entriesNamed(channel).map(refOf) : [channel];
+        for (const ref of refs)
+            this.startTypingAt(ref, metadata);
+    }
+    startTypingAt(ref, metadata) {
+        // A channel types only while it's registered, and keeps no metadata
+        // otherwise: each removal of a channel or a server stops its typing
+        // (stopTyping), which drops the metadata too, and stopAll clears both.
+        if (!this.entryAt(ref))
+            return;
+        const key = destinationKey(ref);
         const metadataChanged = metadata !== undefined &&
-            !shallowEqualRecord(this.typingMetadata.get(channelId), metadata);
+            !shallowEqualRecord(this.typingMetadata.get(key), metadata);
         if (metadata) {
-            this.typingMetadata.set(channelId, metadata);
+            this.typingMetadata.set(key, metadata);
         }
-        if (this.typingIntervals.has(channelId)) {
+        if (this.typingIntervals.has(key)) {
             // Already typing. If the caller supplied new routing metadata (e.g. the
             // relevant Zulip topic just moved because a newer message arrived),
             // dispatch an immediate refresh so the server sees the new routing
             // within this request instead of waiting up to TYPING_INTERVAL_MS for
             // the next tick.
-            if (metadataChanged) {
-                const entry = this.findChannelEntry(channelId);
-                if (entry) {
-                    this.sendTypingNotification(entry.serverId, channelId);
-                }
-            }
-            return;
-        }
-        // Find the channel entry and its server
-        const entry = this.findChannelEntry(channelId);
-        if (!entry) {
+            if (metadataChanged)
+                this.sendTypingNotification(ref);
             return;
         }
         // Send typing immediately
-        this.sendTypingNotification(entry.serverId, channelId);
+        this.sendTypingNotification(ref);
         // Set up interval — pulls the latest metadata on each tick so mid-stream
         // updates (e.g. a newer incoming message switching the relevant topic)
         // take effect on the next refresh.
         const interval = setInterval(() => {
-            this.sendTypingNotification(entry.serverId, channelId);
+            this.sendTypingNotification(ref);
         }, TYPING_INTERVAL_MS);
-        this.typingIntervals.set(channelId, interval);
+        this.typingIntervals.set(key, { ref, interval });
     }
     /**
      * Stop sending typing indicators.
      *
-     * If channelId is specified, stops typing on that channel only.
-     * If no channelId, stops all typing indicators.
+     * Given a ref, stops typing in that channel. Given a name as a string,
+     * stops typing in each channel the name means, by its id or its
+     * server-qualified name (entriesNamed), as startTyping started it: a
+     * channel types only while it's registered, since startTypingAt starts
+     * none that isn't and each removal stops its channel's typing. Given
+     * nothing, stops all typing indicators.
      */
-    stopTyping(channelId) {
-        if (channelId !== undefined) {
-            const interval = this.typingIntervals.get(channelId);
-            if (interval) {
+    stopTyping(channel) {
+        if (channel === undefined) {
+            // Clear all typing intervals and dispatch stop for each known channel
+            const running = [...this.typingIntervals.values()];
+            for (const { interval } of running)
                 clearInterval(interval);
-                this.typingIntervals.delete(channelId);
+            this.typingIntervals.clear();
+            for (const { ref } of running)
+                this.sendTypingStop(ref);
+            this.typingMetadata.clear();
+            return;
+        }
+        const refs = typeof channel === 'string' ? this.entriesNamed(channel).map(refOf) : [channel];
+        for (const ref of refs) {
+            const key = destinationKey(ref);
+            const typing = this.typingIntervals.get(key);
+            if (typing) {
+                clearInterval(typing.interval);
+                this.typingIntervals.delete(key);
                 // Dispatch an explicit 'stop' so servers that support it (e.g. Zulip)
                 // clear the indicator immediately rather than waiting for auto-expire.
                 // Metadata still carries the routing hint so the stop hits the same
-                // topic/thread as the start. Guarded by `interval`: matches the
+                // topic/thread as the start. Guarded by the interval: matches the
                 // global-clear branch's semantics, and keeps defensive stopTyping(ch)
                 // calls from spamming stops at a server that never saw a start.
-                const entry = this.findChannelEntry(channelId);
-                if (entry && this.sendTypingFn) {
-                    this.sendTypingFn(entry.serverId, channelId, this.typingMetadata.get(channelId), 'stop');
-                }
+                this.sendTypingStop(ref);
             }
-            this.typingMetadata.delete(channelId);
+            this.typingMetadata.delete(key);
         }
-        else {
-            // Clear all typing intervals and dispatch stop for each known channel
-            const channels = Array.from(this.typingIntervals.keys());
-            for (const interval of this.typingIntervals.values()) {
-                clearInterval(interval);
-            }
-            this.typingIntervals.clear();
-            if (this.sendTypingFn) {
-                for (const id of channels) {
-                    const entry = this.findChannelEntry(id);
-                    if (entry)
-                        this.sendTypingFn(entry.serverId, id, this.typingMetadata.get(id), 'stop');
-                }
-            }
-            this.typingMetadata.clear();
+    }
+    /** The explicit 'stop' for a channel whose typing ended, while its
+     *  server still registers it. */
+    sendTypingStop(ref) {
+        if (this.sendTypingFn && this.entryAt(ref)) {
+            this.sendTypingFn(ref.serverId, ref.channelId, this.typingMetadata.get(destinationKey(ref)), 'stop');
         }
     }
     // ==========================================================================
@@ -1608,10 +1682,6 @@ export class ChannelRegistry {
     getDefaultPublishChannel() {
         return this.defaultPublishChannel;
     }
-    /**
-     * Get the descriptor for a channel by its channelId (first match across
-     * servers). Used by the conversation router for DM classification.
-     */
     /**
      * RFC-006 §3.2: is `channelId` registered BY `serverId` through a server
      * declaration (channels/register, channels/changed) or an authorized open?
@@ -1620,28 +1690,22 @@ export class ChannelRegistry {
      * registration.
      */
     isDeclaredChannel(serverId, channelId) {
-        const entry = this.channels.get(`${serverId}:${channelId}`);
+        const entry = this.entryAt({ serverId, channelId });
         return !!entry && !pushPlaceholder(entry);
     }
-    getDescriptor(channelId) {
-        return this.findChannelEntry(channelId)?.descriptor;
+    /** A registered channel's descriptor. Used by the conversation router for
+     *  DM classification. */
+    getDescriptor(ref) {
+        return this.entryAt(ref)?.descriptor;
     }
     /** The registered label of `channelId` on exactly `serverId` (no
      *  cross-server first match), or undefined when it has none. */
     getChannelLabel(serverId, channelId) {
-        const label = this.channels.get(`${serverId}:${channelId}`)?.descriptor.label;
+        const label = this.entryAt({ serverId, channelId })?.descriptor.label;
         return typeof label === 'string' && label.length > 0 ? label : undefined;
     }
-    /** 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;
+    isChannelOpen(ref) {
+        return this.entryAt(ref)?.open === true;
     }
     getDesiredState(serverId, channelId) {
         return this.desiredStates.get(this.lifecycleKey(serverId, channelId))?.state;
@@ -1679,18 +1743,21 @@ export class ChannelRegistry {
      * decision it actually is. Absent origin is treated as agent-origin (the
      * untrusted-safe default).
      */
-    async handleChannelToolCall(toolName, input, origin) {
+    async handleChannelToolCall(toolName, input, origin, 
+    /** Filled with a channel_publish's outcome once its request is
+     *  attempted, so the caller learns where it was delivered. */
+    seen) {
         switch (toolName) {
             case 'channel_list':
                 return this.handleToolList();
             case 'channel_open':
-                return this.handleToolOpen(input);
+                return this.handleToolOpen(input, origin?.kind === 'agent' ? origin.own : undefined);
             case 'channel_close':
                 return this.handleToolClose(input, origin);
             case 'channel_decline':
-                return this.handleToolDecline(input);
+                return this.handleToolDecline(input, origin?.kind === 'agent' ? origin.own : undefined);
             case 'channel_publish':
-                return this.handleToolPublish(input, origin);
+                return this.handleToolPublish(input, origin, seen);
             case 'think':
                 return this.handleToolThink(input);
             case 'journal':
@@ -1711,12 +1778,39 @@ export class ChannelRegistry {
     // Channel Context for beforeInference
     // ==========================================================================
     /**
-     * Build channel context for inclusion in beforeInference params.
-     *
-     * Returns undefined if no channels are active.
+     * The message the agent is replying to, with its channel: 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. 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. An ephemeral run has none (takesGlobalFallback),
+     * so a subagent's refusal marks no one else's channel. Nor has a turn that
+     * deliberately has no channel (activeChannelResolver's null): woken for a
+     * channel id two servers register, it isn't replying to the latest inbound
+     * message, which may be anywhere. A fork's turn always has a channel, its
+     * home, so it's taken to be replying to the latest inbound message as every
+     * fork's turn is, in explicit mode as in locus mode, where its locus is
+     * its home.
      */
-    buildChannelContext(agentName) {
-        const openChannels = this.getOpenChannels();
+    incomingFor(agentName) {
+        if (agentName !== undefined && this.activeChannelResolver?.(agentName) === null && !this.homeChannelResolver?.(agentName)) {
+            return undefined;
+        }
+        const fallback = agentName !== undefined ? this.globalFallbackFor(agentName) : this.defaultPublishChannel;
+        if (!fallback || !this.defaultPublishMessageId)
+            return undefined;
+        return { channel: fallback, messageId: this.defaultPublishMessageId, threadId: this.defaultPublishThreadId };
+    }
+    /**
+     * The channel context one server is told for an agent's inference
+     * (context/beforeInference, §14.4). Each server is told only of its own
+     * channels: ids are unique only within one server's connection (§14.2), so
+     * another server's channel named by its id alone could read as this
+     * server's own, and §14.4 leaves the field to the host. So `incoming` and
+     * `defaultOutgoing` appear only where that channel is `serverId`'s, and
+     * `candidates` lists only its open channels. Undefined when none applies.
+     */
+    buildChannelContext(agentName, serverId) {
         // Resolve the outbound locus the SAME way routeSpeech does, so the agent is
         // 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
@@ -1733,37 +1827,32 @@ export class ChannelRegistry {
         // the latest inbound message's channel as its outgoing one, nor that
         // message as the one it is replying to.
         const fallback = agentName !== undefined ? this.globalFallbackFor(agentName) : this.defaultPublishChannel;
-        const outgoing = home ?? active ?? fallback;
-        if (openChannels.length === 0 && !outgoing) {
-            return undefined;
-        }
+        // A turn that deliberately has no channel (null) takes no fallback.
+        const outgoing = home ?? (active !== undefined ? active : fallback);
         const context = {};
-        // 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) {
+        // Incoming: the message the agent is replying to (incomingFor).
+        const incoming = this.incomingFor(agentName);
+        if (incoming && incoming.channel.serverId === serverId) {
             context.incoming = {
-                channelId: fallback,
-                messageId: this.defaultPublishMessageId,
-                threadId: this.defaultPublishThreadId,
+                channelId: incoming.channel.channelId,
+                messageId: incoming.messageId,
+                threadId: incoming.threadId,
             };
         }
         // 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)) {
+        if (outgoing && outgoing.serverId === serverId && !this.inboundOnlyServer(outgoing)) {
             context.defaultOutgoing = {
-                channelId: outgoing,
+                channelId: outgoing.channelId,
             };
         }
-        // Candidates: all open channel IDs
-        if (openChannels.length > 0) {
-            context.candidates = openChannels.map((e) => e.descriptor.id);
+        // Candidates: this server's open channels.
+        const candidates = this.getOpenChannels().filter((e) => e.serverId === serverId).map((e) => e.descriptor.id);
+        if (candidates.length > 0) {
+            context.candidates = candidates;
         }
-        return context;
+        return Object.keys(context).length > 0 ? context : undefined;
     }
     // ==========================================================================
     // Lifecycle
@@ -1782,12 +1871,18 @@ export class ChannelRegistry {
             if (entry.serverId !== serverId)
                 continue;
             this.channels.delete(key);
-            this.stopTyping(entry.descriptor.id);
-            if (this.defaultPublishChannel === entry.descriptor.id) {
-                this.defaultPublishChannel = null;
-                this.defaultPublishMessageId = null;
-                this.defaultPublishThreadId = undefined;
-            }
+            this.stopTyping(refOf(entry));
+        }
+        // The default channel's ref stays, as a channels/changed removal leaves
+        // it: a call that would default to it is refused as the default gone,
+        // naming it, rather than told there's no default yet, and another
+        // server's channel with its id isn't taken for it. Its message and
+        // thread go, as on main, so no message on a server that's gone is given
+        // as the one an agent replies to (incomingFor), to that server added
+        // back or to a refusal's reaction.
+        if (this.defaultPublishChannel?.serverId === serverId) {
+            this.defaultPublishMessageId = null;
+            this.defaultPublishThreadId = undefined;
         }
         // Desired state and migration markers deliberately survive disconnects.
     }
@@ -1831,11 +1926,13 @@ export class ChannelRegistry {
      * Stop all typing intervals and clear all channel registrations.
      */
     stopAll() {
-        // Clear all typing intervals
-        for (const interval of this.typingIntervals.values()) {
+        // Clear all typing intervals, and their metadata, which a channel
+        // registered again later would otherwise send
+        for (const { interval } of this.typingIntervals.values()) {
             clearInterval(interval);
         }
         this.typingIntervals.clear();
+        this.typingMetadata.clear();
         // Clear channels map
         this.channels.clear();
         // Reset default publish tracking
@@ -2229,17 +2326,30 @@ export class ChannelRegistry {
     setDesiredState(serverId, channelId, desired, source) {
         const key = this.lifecycleKey(serverId, channelId);
         const current = this.desiredStates.get(key);
+        // A machine's close isn't a decision: of a channel with no record (one
+        // registered lazily, or on a server whose grant lacks channels.lifecycle),
+        // it records the default that channel already had, so policy and
+        // bootstrap can still lift it (#417).
+        const recorded = !current && desired === 'closed' && MACHINE_CLOSE_SOURCES.has(source) ? 'default-closed' : source;
         // 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))) {
+        // so it writes nothing, with two exceptions. The agent's own decision
+        // (channel_open, channel_close or channel_decline) records itself over a
+        // record that isn't the agent's. 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. And the latest
+        // deliberate close wins: the agent's close or decline, or a module's
+        // close, records itself over any closed record from another source,
+        // another deliberate close included, so a decline after a close is the
+        // decision on record. Speech opens no channel whose close was decided
+        // (speechOpens). A machine's close never replaces a closed record, so
+        // what nobody decided stays liftable.
+        const agentOverOther = AGENT_DECISION_SOURCES.has(source) && !AGENT_DECISION_SOURCES.has(current?.source ?? '');
+        const latestClose = desired === 'closed' && isCloseDecision(source) && current?.source !== source;
+        if (current?.state === desired && !agentOverOther && !latestClose) {
             return;
         }
         this.appendLifecycleEvent({
@@ -2247,10 +2357,10 @@ export class ChannelRegistry {
             serverId,
             channelId,
             desired,
-            source,
+            source: recorded,
             timestamp: new Date().toISOString(),
         });
-        this.desiredStates.set(key, { state: desired, source });
+        this.desiredStates.set(key, { state: desired, source: recorded });
     }
     // ==========================================================================
     // Tune-out state (issue #77) — durable in the lifecycle log
@@ -2333,7 +2443,7 @@ export class ChannelRegistry {
         return this.getTuneOutState(serverId, channelId) !== null &&
             !this.channelLifecycleTails.has(this.lifecycleKey(serverId, channelId)) &&
             this.serverReach(serverId) === 'up' &&
-            this.tuneOutReadsOpen(this.channels.get(`${serverId}:${channelId}`));
+            this.tuneOutReadsOpen(this.channels.get(destinationKey({ serverId, channelId })));
     }
     /**
      * Whether a tune-out takes an entry's transport as open: its open flag,
@@ -2355,7 +2465,7 @@ export class ChannelRegistry {
         return entry !== undefined && entry.open && !this.failedCloseTargets.has(entry);
     }
     async openTuneOutTransport(serverId, channelId, epochId) {
-        const channelKey = `${serverId}:${channelId}`;
+        const channelKey = destinationKey({ 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
@@ -2558,29 +2668,45 @@ export class ChannelRegistry {
      * 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.
+     *
+     * The channel is a ref, or a name given as a string, which resolves as
+     * channel_publish's channelId does: one channel the name means, which may
+     * be server-qualified, and a name two servers' channels answer to is
+     * refused with them as candidates (`shared-id`). A host keeps channels by
+     * their ids (connectome-host's notices module). Where several servers
+     * register an id, a ref picks one server's channel, as a qualified name does
+     * where it names one channel alone.
      */
-    async publishForAgent(channelId, text, agentName) {
-        // 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 ?? '';
+    async publishForAgent(channel, text, agentName) {
+        const input = typeof channel === 'string'
+            ? { channelId: channel, content: text }
+            : { channelId: channel.channelId, serverId: channel.serverId, content: text };
         const seen = {};
-        const result = await this.handleToolPublish({ channelId, content: text }, undefined, seen, 'speak_in_channel');
-        if (seen.outcome?.status === 'delivered') {
+        const result = await this.handleToolPublish(input, undefined, seen, 'speak_in_channel');
+        // The destination the publish resolved before it awaited, which the
+        // outcome carries: the channel may be removed while the reply is pending.
+        const destination = seen.outcome?.destination;
+        if (seen.outcome?.status === 'delivered' && destination) {
             this.emitTraceFn({
                 type: 'mcpl:speech-routed',
                 conversationId: agentName,
-                serverId,
-                channelId,
+                serverId: destination.serverId,
+                channelId: destination.channelId,
                 delivered: true,
                 textLen: text.length,
                 text,
             });
         }
         else {
+            // The channel the publish went to, or that the call named before a
+            // refusal, or, where nothing resolved, the server the caller gave, with
+            // the name it gave.
+            const named = destination ?? seen.resolved;
             this.emitTraceFn({
                 type: 'mcpl:speech-route-failed',
                 conversationId: agentName,
-                channelId,
+                ...(named ? { serverId: named.serverId } : 'serverId' in input ? { serverId: input.serverId } : {}),
+                channelId: named?.channelId ?? input.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',
@@ -2690,7 +2816,7 @@ export class ChannelRegistry {
     }
     /** One queued lifecycle operation, run when its turn in the queue comes. */
     async runLifecycleOperation(serverId, channelId, removals, options) {
-        const channelKey = `${serverId}:${channelId}`;
+        const channelKey = destinationKey({ serverId, channelId });
         const lifecycleKey = this.lifecycleKey(serverId, channelId);
         try {
             let attempts = 0;
@@ -2806,6 +2932,7 @@ export class ChannelRegistry {
                 // its sends either.
                 if (substitute !== undefined) {
                     this.invalidateTransportConfirmation(entry);
+                    this.answeredElsewhere.add(entry);
                     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');
@@ -2813,6 +2940,8 @@ export class ChannelRegistry {
                 if (open)
                     this.applyOpenDeclaration(entry, result);
                 entry.open = open;
+                if (open)
+                    this.answeredElsewhere.delete(entry);
                 this.unconfirmedChannelTargets.delete(entry);
                 this.failedCloseTargets.delete(entry);
                 const now = this.getDesiredState(serverId, channelId);
@@ -2865,7 +2994,7 @@ export class ChannelRegistry {
      * doesn't know needs nothing: §14.5 refuses its traffic.
      */
     closeSubstitutedChannel(serverId, channelId) {
-        if (!this.channels.has(`${serverId}:${channelId}`))
+        if (!this.channels.has(destinationKey({ serverId, channelId })))
             return;
         if (this.getDesiredState(serverId, channelId) !== 'closed')
             return;
@@ -2884,7 +3013,7 @@ export class ChannelRegistry {
         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}`) ||
+            if (!this.channels.has(destinationKey({ serverId, channelId })) ||
                 (err instanceof ChannelLifecycleError && (err.kind === 'cancelled' || err.kind === 'converge')))
                 return;
             this.emitTraceFn({
@@ -2927,7 +3056,7 @@ export class ChannelRegistry {
             if (this.channelLifecycleTails.get(lifecycleKey) === pending)
                 break;
         }
-        const current = this.channels.get(`${entry.serverId}:${entry.descriptor.id}`);
+        const current = this.entryAt({ serverId: entry.serverId, channelId: entry.descriptor.id });
         if (!current)
             throw new ChannelLifecycleError(CHANNEL_REMOVED_CLAUSE, 'removed');
         // A close that stands is what the words met, whatever became of an open,
@@ -2964,7 +3093,7 @@ export class ChannelRegistry {
         // Record all admissions before waiting on any channel. A slow first RPC
         // must not delay intent for the rest of this registration batch.
         for (const channel of channels) {
-            const entry = this.channels.get(`${serverId}:${channel.id}`);
+            const entry = this.entryAt({ serverId, channelId: channel.id });
             if (entry && this.ensureInitialDesiredState(serverId, entry.descriptor)) {
                 policyOpened.push({ channelId: channel.id, label: entry.descriptor.label });
             }
@@ -2987,7 +3116,7 @@ export class ChannelRegistry {
         // Each channel has its own lifecycle queue, so a held RPC for one (up to
         // its timeout, times its attempts) doesn't delay its siblings.
         await Promise.allSettled(channels.map(async (channel) => {
-            if (!this.channels.has(`${serverId}:${channel.id}`))
+            if (!this.channels.has(destinationKey({ serverId, channelId: channel.id })))
                 return;
             try {
                 await this.applyDesiredChannelState(serverId, channel.id);
@@ -2996,7 +3125,7 @@ export class ChannelRegistry {
                 // Removal while queued is cancellation, not a failed subscription.
                 // Exhausted convergence and a substituted answer already emitted
                 // their own diagnostics.
-                if (!this.channels.has(`${serverId}:${channel.id}`) ||
+                if (!this.channels.has(destinationKey({ serverId, channelId: channel.id })) ||
                     (err instanceof ChannelLifecycleError &&
                         (err.kind === 'cancelled' || err.kind === 'converge' || err.kind === 'substituted')))
                     return;
@@ -3019,14 +3148,14 @@ export class ChannelRegistry {
      * Uses the sendTypingFn callback if provided. If not, this is a no-op
      * (typing timer lifecycle is still managed for when the callback is wired).
      */
-    sendTypingNotification(serverId, channelId) {
+    sendTypingNotification(ref) {
         // §14.1: channels/typing requires channels.typing in the grant. Silent
         // skip — a typing indicator is cosmetic and per-7s, so a diagnostic per
         // tick would be noise.
-        if (!CapabilityGrant.of(this.serverRegistry.getServer(serverId)).has('channels.typing'))
+        if (!CapabilityGrant.of(this.serverRegistry.getServer(ref.serverId)).has('channels.typing'))
             return;
         if (this.sendTypingFn) {
-            this.sendTypingFn(serverId, channelId, this.typingMetadata.get(channelId));
+            this.sendTypingFn(ref.serverId, ref.channelId, this.typingMetadata.get(destinationKey(ref)));
         }
         // TODO: When server-connection exposes a public sendNotification or
         // sendTyping method, wire it here directly instead of using a callback.
@@ -3040,78 +3169,277 @@ export class ChannelRegistry {
             .filter((e) => e.serverId === serverId)
             .map((e) => e.descriptor);
     }
-    /** Server id owning a registered channel (by descriptor id), or null. */
-    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).
+     * undefined when it isn't one, or isn't registered. The notices name that
+     * server.
      */
-    inboundOnlyServer(channelId, serverId) {
-        const entry = serverId ? this.channels.get(`${serverId}:${channelId}`) : this.findChannelEntry(channelId);
+    inboundOnlyServer(ref) {
+        const entry = this.entryAt(ref);
         return entry && isInboundOnly(entry) ? entry.serverId : undefined;
     }
+    /** A channel's entry, by its server and id: the map is keyed by destinationKey. */
+    entryAt(ref) {
+        return this.channels.get(destinationKey(ref));
+    }
     /**
-     * Find a channel entry by channelId (searches across all servers).
-     * Returns the first match.
+     * The registered channels a name given as a string can mean (a tool's
+     * channelId, a `>>` target, a host's call): those whose id is the name and
+     * those whose server-qualified name (qualifiedChannelName) is the name,
+     * taken together. The qualified form is matched against the registered
+     * pairs, never split at a colon, since ids hold colons (discord-mcpl's are
+     * `discord:<guild>:<channel>`). So a name that two entries answer to, in
+     * either form, means both of them, and a caller that has to pick one
+     * refuses it with both as candidates rather than taking the first.
      */
-    findChannelEntry(channelId) {
-        for (const [key, entry] of this.channels) {
-            if (entry.descriptor.id === channelId) {
-                return entry;
-            }
+    entriesNamed(name) {
+        return [...this.channels.values()].filter((e) => e.descriptor.id === name || qualifiedChannelName(refOf(e)) === name);
+    }
+    /** The channels a name given as a string means (entriesNamed), by ref:
+     *  for a caller that has to settle a host's or a tool's name itself. */
+    channelsNamed(name) {
+        return this.entriesNamed(name).map(refOf);
+    }
+    /**
+     * The name to show an agent for a channel: one that picks it alone, which
+     * a channel tool's channelId takes back, and a `>>` target too where the
+     * name is one (isProseTargetToken: a single token other than `skip_reply`,
+     * which a `>>` line reads as private speech); proseTargetFor gives the
+     * target to write. A registered
+     * channel's is nameFor's: its id, or, where another server registers the
+     * same id, its server-qualified name. A channel no string picks alone, as
+     * where qualified names collide too, is shown by its id and its server, as
+     * the refusals show it (channelOnServer), which no input takes for a name.
+     * A channel no longer registered is shown by its id, or by its qualified
+     * name, only where no registered channel takes that name, as a channel
+     * tool reads it or a `>>` target does (by label or raw id too), so the
+     * name can't send anything to another channel; else by its id and server.
+     */
+    nameShown(ref) {
+        const entry = this.entryAt(ref);
+        if (entry)
+            return this.nameFor(entry) ?? channelOnServer(ref);
+        for (const name of [ref.channelId, qualifiedChannelName(ref)]) {
+            if (this.entriesNamed(name).length === 0 && !('channelId' in this.resolveProseTarget(name)))
+                return name;
+        }
+        return channelOnServer(ref);
+    }
+    /**
+     * A tool's refusal of a tuned-out channel, whose decision is the tune-out:
+     * its cancel is what ends it (tuneOutEndText), and a decision recorded over
+     * it would end it without that cancel, so the backlog it diverted would
+     * never reach the agent.
+     */
+    tunedOutRefusal(tool, entry) {
+        return {
+            success: false,
+            isError: true,
+            error: `Channel ${this.quotedShown(refOf(entry))} is tuned out: its messages go to the subconscious, and ${tool} ` +
+                `doesn't change that. ${this.tuneOutEndText(entry, tool)}`,
+            data: { refusal: 'tuned-out', channelId: entry.descriptor.id, serverId: entry.serverId },
+        };
+    }
+    /**
+     * How a tuned-out channel's tune-out ends, for the texts that tell an agent
+     * channel_open doesn't change it: a tune_out cancel, by the name that
+     * picks the channel (nameFor), or, where no name picks it alone, its own
+     * end, since tune_out takes a name.
+     * For channel_close, which refuses a tuned-out channel too, it adds that
+     * the close comes after that.
+     */
+    /** How this channel's tune-out ends, as tune_out's own refusals say it
+     *  (tuneOutEndText), or undefined for a channel no longer registered. */
+    tuneOutEnd(ref) {
+        const entry = this.entryAt(ref);
+        return entry ? this.tuneOutEndText(entry) : undefined;
+    }
+    tuneOutEndText(entry, tool) {
+        const close = tool === 'channel_close';
+        return this.nameFor(entry) !== undefined
+            ? `Call tune_out with channelId ${this.quotedShown(refOf(entry))} and mode "cancel" for it to resume normal ` +
+                `attention; cancelling delivers the diverted backlog${close ? ', and channel_close closes it after that.' : '.'}`
+            : 'No channelId names it alone, so tune_out can\'t cancel it: its tune-out ends by itself when its duration ' +
+                'runs out, or at the first wake past its wake budget, and its backlog is delivered then.' +
+                (close ? ' Once it has ended, channel_close can close it.' : '');
+    }
+    /**
+     * A channel's name as nameShown gives it, quoted for a sentence: the name
+     * in quotes, or the id-and-server form, whose parts are quoted already.
+     */
+    quotedShown(ref) {
+        const shown = this.nameShown(ref);
+        return shown === channelOnServer(ref) ? shown : JSON.stringify(shown);
+    }
+    /**
+     * The string that names exactly this entry by entriesNamed: its id when no
+     * other entry answers to that (the id is unique), else its server-qualified
+     * name when no other entry answers to that, else undefined. The last can
+     * happen only where qualified names collide, as server `a`'s channel
+     * `b:room` and server `a:b`'s channel `room` do; such a channel is named
+     * only by its server and id apart.
+     */
+    nameFor(entry) {
+        for (const name of [entry.descriptor.id, qualifiedChannelName(refOf(entry))]) {
+            const named = this.entriesNamed(name);
+            if (named.length === 1 && named[0] === entry)
+                return name;
         }
         return undefined;
     }
-    resolveToolChannelEntry(channelId, 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.`),
-                };
+    /**
+     * The refusal for a name that more than one registered channel answers
+     * to (entriesNamed). Where each one has a name that picks it alone
+     * (nameFor), as two servers' channels with one id do, it lists those.
+     * Where one has none, the name reads two ways, as server `a`'s `b:room`
+     * and server `a:b`'s `room` both answer to `a:b:room`, and the refusal
+     * gives a line per channel, each with its own route, or, where the tool
+     * has none to it, saying that no channelId reaches it alone.
+     * `takesServerId` says whether the tool also takes a serverId to pick
+     * with; `nothing` says what didn't happen, "nothing ran" unless given.
+     */
+    sharedNameRefusal(name, entries, opts) {
+        const nothing = opts.nothing ?? 'nothing ran';
+        const names = entries.map((e) => this.nameFor(e));
+        if (names.every((n) => n !== undefined)) {
+            const listed = names.map((n) => JSON.stringify(n)).join(', ');
+            const servers = [...new Set(entries.map((e) => JSON.stringify(e.serverId)))];
+            // One server's two channels can answer to one name too, as `s`'s
+            // `s:room` and `room` both do to `s:room`; its server picks neither.
+            if (servers.length === 1) {
+                return `Channel ${JSON.stringify(name)} could mean more than one channel on server ${servers[0]} ` +
+                    `(${listed}), so ${nothing}. Call again with channelId set to one of them.`;
             }
-            return {
-                error: serverId
-                    ? `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 "${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.',
-            };
+            // A serverId goes with the channel's own id, so it's offered only
+            // where the name is every candidate's own id.
+            const byServer = opts.takesServerId && entries.every((e) => e.descriptor.id === name)
+                ? `, or with serverId set to ${servers.join(' or ')}`
+                : '';
+            return `Channel ${JSON.stringify(name)} is on more than one server (${listed}), so ${nothing}.` +
+                ` Call again with channelId set to one of them${byServer}.`;
+        }
+        const lines = entries.map((e, i) => {
+            const where = channelOnServer(refOf(e));
+            const own = names[i];
+            if (own === undefined && !opts.takesServerId)
+                return `- ${where}: no channelId reaches it alone.`;
+            return own !== undefined
+                ? `- ${where}: call again with channelId ${JSON.stringify(own)}.`
+                : `- ${where}: call again with channelId ${JSON.stringify(e.descriptor.id)} and serverId ${JSON.stringify(e.serverId)}.`;
+        });
+        const count = entries.length === 2 ? 'either of two channels' : `any of ${entries.length} channels`;
+        return `Channel ${JSON.stringify(name)} could mean ${count}, so ${nothing}:\n${lines.join('\n')}`;
+    }
+    /**
+     * The refusal for a name more than one registered channel answers to, for
+     * a tool outside the registry whose schema has no serverId (tune_out, the
+     * subconscious's cancel_tuneout and deliver_summary), or undefined when the
+     * name means one channel or none. `nothing` says what didn't happen,
+     * "nothing ran" unless given.
+     */
+    sharedNameRefusalFor(name, nothing) {
+        const entries = this.entriesNamed(name);
+        return entries.length > 1 ? this.sharedNameRefusal(name, entries, { takesServerId: false, nothing }) : undefined;
+    }
+    /**
+     * Where a channel id given with a server that doesn't have it is, for that
+     * refusal: the servers that register the id, each a serverId to call again
+     * with, and leaving serverId out only where the id alone then names one
+     * channel (entriesNamed), since another channel's qualified name can be
+     * the same string. For a publish, whose schema has no serverId
+     * (`takesServerId` false: a channel_publish given one the agent added, or
+     * a host's publishForAgent given a ref), where the id is, by the names its
+     * channelId takes (nameFor), and no advice to post there, since each is
+     * another destination, perhaps another community's.
+     */
+    elsewhereText(channelId, takesServerId = true) {
+        const elsewhere = [...this.channels.values()].filter((e) => e.descriptor.id === channelId);
+        const named = this.entriesNamed(channelId);
+        const alone = named.length === 1;
+        if (elsewhere.length === 0) {
+            // Such as a server-qualified name given with serverId too: alone, it
+            // names its channel, which may be another server's than the one given,
+            // so the text says whose.
+            if (!alone)
+                return 'channel_list shows the channels and their servers.';
+            const one = named[0];
+            const names = `${JSON.stringify(channelId)} alone names channel ${JSON.stringify(one.descriptor.id)} on server `
+                + JSON.stringify(one.serverId);
+            return takesServerId ? `${names}: for that one, call again with serverId left out.` : `${names}.`;
+        }
+        if (!takesServerId) {
+            // Each is another destination, perhaps another community's, so the
+            // text names where the id is, each place by the name its channelId
+            // takes, and leaves the choice to the caller. A place no channelId
+            // reaches alone says so.
+            const places = elsewhere.map((e) => {
+                const at = `on server ${JSON.stringify(e.serverId)}`;
+                const name = this.nameFor(e);
+                return name === undefined ? `${at} (no channelId reaches it alone)` : `${at} as ${JSON.stringify(name)}`;
+            });
+            return `It's ${places.length === 1 ? places[0] : `${places.slice(0, -1).join(', ')} and ${places.at(-1)}`}.`;
         }
-        return { entry: matches[0] };
+        const servers = elsewhere.map((e) => JSON.stringify(e.serverId));
+        const leaveOut = alone ? ', or leave serverId out' : '';
+        return servers.length === 1
+            ? `It's on server ${servers[0]}: call again with serverId ${servers[0]}${leaveOut}.`
+            : `It's on servers ${servers.join(', ')}: call again with serverId set to one of them.`;
     }
     /**
-     * Find the composite key for a channel by its channelId.
+     * The channel a channel tool names: the channel with id `channelId` on
+     * `serverId` when the call gives a serverId, the exact pair, as every
+     * selector that gives a server reads it; otherwise the one channel its
+     * name means (entriesNamed), which may be server-qualified. A name more
+     * than one channel answers to is refused with them as candidates, never
+     * resolved to the first. Its callers are the tools that take a serverId
+     * (channel_open, channel_close, channel_decline), so the refusal offers
+     * one. `own` is the calling turn's own channels, for an agent's call made
+     * inside it (ChannelToolOrigin.own).
      */
-    findChannelKey(channelId) {
-        for (const [key, entry] of this.channels) {
-            if (entry.descriptor.id === channelId) {
-                return key;
-            }
+    resolveToolChannelEntry(channelId, serverId, own) {
+        // Inside the calling turn, a name one of the turn's own channels answers
+        // to by its id means that channel, as a `>>` target does (ownChannelNamed):
+        // once its server no longer registers it, the call is refused, with no
+        // route to another server's channel with the id.
+        const mine = serverId ? undefined : this.ownChannelNamed(channelId, own);
+        if (mine && 'neither' in mine)
+            return { error: this.ownNeitherRefusal(channelId, mine.neither, 'ran') };
+        if (mine) {
+            const entry = this.entryAt(mine.channel);
+            return entry ? { entry } : { error: this.ownChannelGoneRefusal(channelId, mine.channel, 'other') };
+        }
+        if (serverId) {
+            const entry = this.entryAt({ serverId, channelId });
+            if (entry)
+                return { entry };
+            return { error: `No channel "${channelId}" is on server "${serverId}", so nothing ran. ${this.elsewhereText(channelId)}` };
+        }
+        const matches = this.entriesNamed(channelId);
+        if (matches.length === 0) {
+            return { error: `No channel has the id "${channelId}", so nothing ran. channel_list shows the channel ids.` };
         }
-        return undefined;
+        if (matches.length > 1)
+            return { error: this.sharedNameRefusal(channelId, matches, { takesServerId: true }) };
+        return { entry: matches[0] };
     }
     // ==========================================================================
     // Private: Tool Handlers
     // ==========================================================================
     handleToolList() {
         const allChannels = [];
+        // How many registered channels answer to each id and server-qualified
+        // id, in one pass, so each entry's name is nameFor's (the one of those
+        // that picks it alone) without a scan of every channel per entry.
+        const answering = new Map();
+        for (const e of this.channels.values()) {
+            for (const n of [e.descriptor.id, qualifiedChannelName(refOf(e))])
+                answering.set(n, (answering.get(n) ?? 0) + 1);
+        }
         for (const entry of this.channels.values()) {
+            const name = [entry.descriptor.id, qualifiedChannelName(refOf(entry))].find((n) => answering.get(n) === 1);
             allChannels.push({
                 id: entry.descriptor.id,
+                ...(name !== undefined && name !== entry.descriptor.id ? { name } : {}),
                 type: entry.descriptor.type,
                 label: entry.descriptor.label,
                 direction: entry.descriptor.direction,
@@ -3221,7 +3549,7 @@ export class ChannelRegistry {
                 // 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}`);
+                const current = this.entryAt(refOf(entry));
                 let selectedAgain;
                 if (current) {
                     try {
@@ -3286,7 +3614,10 @@ export class ChannelRegistry {
      * docs/explicit-prose-routing.md) to a registered channel.
      *
      * Accepted spellings, tried in order:
-     *   1. exact descriptor id (`discord:guild:123`, always unambiguous)
+     *   1. exact descriptor id (`discord:guild:123`), or its server-qualified
+     *      name (`a:discord:guild:123`), as entriesNamed matches them; a name
+     *      two channels answer to, such as an id two servers register, is
+     *      refused with both as candidates
      *   2. exact raw server-internal id (`address.channelId`)
      *   3. `#label` / bare label — case-insensitive match on descriptor label
      *      with any leading '#' stripped from both sides
@@ -3301,39 +3632,170 @@ export class ChannelRegistry {
      * 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.
+     *
+     * `own` is the turn's own channels, for a target its speech names: a name
+     * one of them answers to by its id means that channel, on its server,
+     * before any other spelling (ownChannelNamed).
      */
     resolveProseTarget(spec, opts) {
-        const resolved = this.resolveTargetByName(spec);
+        const own = this.ownChannelNamed(spec.trim(), opts?.own);
+        let resolved;
+        if (own === undefined) {
+            resolved = this.resolveTargetByName(spec);
+        }
+        else if ('neither' in own) {
+            resolved = { error: `"${spec.trim()}" is the id of this turn's channels on more than one server`, candidates: this.ownCandidates(own.neither).map((c) => c.text) };
+        }
+        else {
+            const entry = this.entryAt(own.channel);
+            resolved = entry
+                ? { channelId: entry.descriptor.id, serverId: entry.serverId, label: entry.descriptor.label }
+                : { error: `${this.ownChannelGoneText(spec.trim(), own.channel)}, and nothing can be sent there until that server registers it again` };
+        }
         if (!opts?.forSpeech || 'error' in resolved)
             return resolved;
-        const entry = this.findChannelEntry(resolved.channelId);
+        const entry = this.entryAt(resolved);
         return entry && isInboundOnly(entry)
-            ? { error: `${resolved.channelId} is ${inboundOnlyReason(entry)}`, refusedChannelId: resolved.channelId }
+            ? { error: `${this.nameShown(resolved)} is ${inboundOnlyReason(entry)}`, refusedChannelId: resolved.channelId }
             : resolved;
     }
+    /**
+     * The turn's own channel a name means: where the name is the id of one of
+     * the turn's own channels, a channel that has been its trigger or its
+     * locus, that channel, on its server, whether or not that server still
+     * registers it. A message's
+     * reply goes where the message came from, so another server that
+     * registers the id, or takes it once the message's server withdrew it,
+     * isn't reached through the name. Where the turn's channels with that id
+     * are on more than one server, the name means neither. Undefined where no
+     * channel of the turn's has that id.
+     */
+    ownChannelNamed(name, own) {
+        const named = [];
+        for (const c of own ?? []) {
+            if (c.channelId === name && !named.some((n) => sameChannel(n, c)))
+                named.push(c);
+        }
+        if (named.length === 0)
+            return undefined;
+        return named.length === 1 ? { channel: named[0] } : { neither: named };
+    }
+    /** Why a name the turn's own channel answers to (ownChannelNamed) reaches
+     *  nothing once that channel's server no longer registers it. It offers no
+     *  other channel with the id, since that's another server's. */
+    ownChannelGoneText(name, channel) {
+        return `"${name}" is this turn's channel on server "${channel.serverId}", which no longer registers it`;
+    }
+    /**
+     * A name the calling turn's own channels answer to by their id, for a tool
+     * outside the registry that takes a channel's name (tune_out, and the
+     * subconscious's cancel_tuneout, speak_in_channel and deliver_summary),
+     * read as the registry's channel tools read it: the turn's channel, or a
+     * refusal where its server no longer registers it, or where the name is
+     * the id of the turn's channels on more than one server. Undefined where
+     * none of the turn's channels has that id. `tool` words the refusal for
+     * what the tool would have done: posted (speak_in_channel), delivered
+     * (deliver_summary) or run (the others).
+     */
+    ownChannelFor(name, own, tool = 'other') {
+        const mine = this.ownChannelNamed(name, own);
+        if (!mine)
+            return undefined;
+        if ('neither' in mine) {
+            const done = tool === 'publish' ? 'was posted' : tool === 'deliver' ? 'was delivered' : 'ran';
+            return { error: this.ownNeitherRefusal(name, mine.neither, done) };
+        }
+        return this.entryAt(mine.channel) ? { channel: mine.channel } : { error: this.ownChannelGoneRefusal(name, mine.channel, tool) };
+    }
+    /** A refusal of a name the turn's own channel answers to, once its server
+     *  no longer registers it: nothing was posted (channel_publish,
+     *  speak_in_channel), delivered (deliver_summary) or ran (the other channel
+     *  tools, tune_out, cancel_tuneout), and nothing can be until it does
+     *  again. */
+    ownChannelGoneRefusal(name, channel, tool) {
+        const outcome = tool === 'publish' ? 'nothing was posted, and nothing can be'
+            : tool === 'deliver' ? 'nothing was delivered, and nothing can be' : 'nothing ran, and nothing can run on it';
+        return `${this.ownChannelGoneText(name, channel)}, so ${outcome} until that server registers it again.`;
+    }
+    /**
+     * The turn's channels a name means neither of (ownChannelNamed), each by a
+     * string that reaches it outside the turn's rule: its server-qualified
+     * name, where that picks it alone, since its id is the name refused. One
+     * no string picks alone, and one its server no longer registers, is named
+     * by its id and server, saying so; `reaches` says which a name reaches.
+     */
+    ownCandidates(channels) {
+        return channels.map((c) => {
+            const entry = this.entryAt(c);
+            if (!entry)
+                return { text: `${channelOnServer(c)} (its server no longer registers it)`, reaches: false };
+            const qualified = qualifiedChannelName(c);
+            const picked = this.entriesNamed(qualified);
+            return picked.length === 1 && picked[0] === entry
+                ? { text: qualified, reaches: true }
+                : { text: `${channelOnServer(c)} (no channelId reaches it alone)`, reaches: false };
+        });
+    }
+    /** A tool's refusal of a name the turn's channels on more than one server
+     *  answer to by their id (ownChannelNamed's neither). */
+    ownNeitherRefusal(name, channels, done) {
+        const candidates = this.ownCandidates(channels);
+        const named = candidates.filter((c) => c.reaches).map((c) => JSON.stringify(c.text));
+        const pick = named.length === candidates.length ? ' Call again with channelId set to one of them.'
+            : named.length === 1 ? ` Call again with channelId ${named[0]}.`
+                : named.length > 1 ? ` Call again with channelId set to one of ${named.join(', ')}.` : '';
+        const listed = candidates.map((c) => (c.reaches ? JSON.stringify(c.text) : c.text)).join(', ');
+        return `"${name}" is the id of this turn's channels on more than one server (${listed}), so nothing ${done}.${pick}`;
+    }
     resolveTargetByName(spec) {
         const entries = [...this.channels.values()];
         const trimmed = spec.trim();
         if (!trimmed)
             return { error: 'empty target' };
-        const exact = entries.filter((e) => e.descriptor.id === trimmed);
+        const hit = (e) => ({ channelId: e.descriptor.id, serverId: e.serverId, label: e.descriptor.label });
+        // A candidate is named by the token that picks it alone (nameFor), so
+        // two servers' channels with one id or one label can be told apart, or,
+        // where no string picks it alone, by its id and its server.
+        const token = (e) => this.nameFor(e) ?? channelOnServer(refOf(e));
+        // A DM is shown by its label, the person, where that label, given as a
+        // target, picks that DM. It doesn't where another channel answers to that
+        // label too, as two servers' DMs with one person do (a label is matched
+        // ignoring case, so "DM: Antra" and "DM: antra" both answer), nor where
+        // an id, a raw id or another label outranks it, so a bounce's example or
+        // a resend's destination never names another channel. Those are shown by
+        // their tokens instead. A label read as a mention or an @name would come
+        // back here, so it's shown by its token too.
+        const labelPicks = (e, label) => {
+            if (/^@|^<@!?\d+>$/.test(label.trim()))
+                return false;
+            const r = this.resolveTargetByName(label);
+            return 'channelId' in r && sameChannel(r, refOf(e));
+        };
+        const dmShown = (list) => list.map((e) => {
+            const label = e.descriptor.label ?? e.descriptor.id;
+            return labelPicks(e, label) ? label : token(e);
+        });
+        // A channel id, or its server-qualified name (entriesNamed).
+        const exact = this.entriesNamed(trimmed);
         if (exact.length === 1) {
-            return { channelId: exact[0].descriptor.id, label: exact[0].descriptor.label };
+            return hit(exact[0]);
         }
         if (exact.length > 1) {
             return {
-                error: `channel id "${trimmed}" is ambiguous across servers`,
-                candidates: exact.map((e) => `${e.serverId}:${e.descriptor.id}`),
+                error: new Set(exact.map((e) => e.serverId)).size > 1
+                    ? `channel id "${trimmed}" is ambiguous across servers`
+                    : `channel id "${trimmed}" names more than one channel on server "${exact[0].serverId}"`,
+                candidates: exact.map(token),
             };
         }
         const raw = entries.filter((e) => e.descriptor.address?.channelId === trimmed);
         if (raw.length === 1) {
-            return { channelId: raw[0].descriptor.id, label: raw[0].descriptor.label };
+            return hit(raw[0]);
         }
         if (raw.length > 1) {
             return {
                 error: `raw id "${trimmed}" is ambiguous`,
-                candidates: raw.map((e) => e.descriptor.id),
+                candidates: raw.map(token),
             };
         }
         const norm = normalizeChannelLabel;
@@ -3360,11 +3822,15 @@ export class ChannelRegistry {
                 const id = mention[1];
                 const byId = dms.filter((e) => dmMeta(e)?.recipientId === id);
                 if (byId.length === 1) {
-                    return { channelId: byId[0].descriptor.id, label: byId[0].descriptor.label };
+                    return hit(byId[0]);
+                }
+                if (byId.length > 1) {
+                    // One person's DMs on more than one server.
+                    return { error: `"${trimmed}" matches several DMs`, candidates: dmShown(byId) };
                 }
                 return {
                     error: `no registered DM matches the mention <@${id}>`,
-                    candidates: dms.map((e) => e.descriptor.label ?? e.descriptor.id).slice(0, 6),
+                    candidates: dmShown(dms.slice(0, 6)),
                 };
             }
             const name = trimmed.slice(1).toLowerCase();
@@ -3376,27 +3842,27 @@ export class ChannelRegistry {
                     return n.length >= 3 && (n.startsWith(name) || name.startsWith(n) || n.includes(name));
                 });
             if (pool.length === 1) {
-                return { channelId: pool[0].descriptor.id, label: pool[0].descriptor.label };
+                return hit(pool[0]);
             }
             if (pool.length > 1) {
                 return {
                     error: `"${trimmed}" matches several DMs`,
-                    candidates: pool.map((e) => e.descriptor.label ?? e.descriptor.id),
+                    candidates: dmShown(pool),
                 };
             }
             return {
                 error: `no registered DM found for "${trimmed}" — for someone without a registered DM channel, use the send_dm tool`,
-                ...(dms.length ? { candidates: dms.map((e) => e.descriptor.label ?? e.descriptor.id).slice(0, 6) } : {}),
+                ...(dms.length ? { candidates: dmShown(dms.slice(0, 6)) } : {}),
             };
         }
         const byLabel = entries.filter((e) => norm(e.descriptor.label ?? '') === norm(trimmed));
         if (byLabel.length === 1) {
-            return { channelId: byLabel[0].descriptor.id, label: byLabel[0].descriptor.label };
+            return hit(byLabel[0]);
         }
         if (byLabel.length > 1) {
             return {
                 error: `label "${trimmed}" matches several channels`,
-                candidates: byLabel.map((e) => e.descriptor.id),
+                candidates: byLabel.map(token),
             };
         }
         // Name-segment match: server labels carry a disambiguating suffix
@@ -3407,12 +3873,12 @@ export class ChannelRegistry {
         const nameOf = normalizeChannelLabelName;
         const byName = entries.filter((e) => nameOf(e.descriptor.label ?? '') === norm(trimmed));
         if (byName.length === 1) {
-            return { channelId: byName[0].descriptor.id, label: byName[0].descriptor.label };
+            return hit(byName[0]);
         }
         if (byName.length > 1) {
             return {
                 error: `"${trimmed}" matches several channels`,
-                candidates: byName.map((e) => `${e.descriptor.label} = ${e.descriptor.id}`),
+                candidates: byName.map((e) => `${e.descriptor.label} = ${token(e)}`),
             };
         }
         // No match: offer near-candidates (labels containing the name) so the
@@ -3420,7 +3886,7 @@ export class ChannelRegistry {
         const near = entries
             .filter((e) => norm(e.descriptor.label ?? '').includes(norm(trimmed)))
             .slice(0, 5)
-            .map((e) => `${e.descriptor.label} = ${e.descriptor.id}`);
+            .map((e) => `${e.descriptor.label} = ${token(e)}`);
         return { error: `no channel matches "${trimmed}"`, ...(near.length ? { candidates: near } : {}) };
     }
     /**
@@ -3430,18 +3896,19 @@ export class ChannelRegistry {
      * a space can't be quoted verbatim: `>>#DM: alice` parses as target `#DM:`
      * plus body `alice …`, and `>>#fable (antra's server)` delivers
      * `(antra's server)` as text. Tried in order: `@name` for a DM, `#label`,
-     * `#name` (label without its server suffix), the descriptor id.
+     * `#name` (label without its server suffix), the name that picks the
+     * channel alone (nameFor): its id, or, where another server registers the
+     * same id, its server-qualified name; and last its server-qualified name,
+     * for a channel whose id is no target (isProseTargetToken), as
+     * `skip_reply` isn't.
      *
-     * Undefined when there is no safe token: the channel isn't registered (on
-     * `serverId`, when given), no candidate is whitespace-free and resolves back,
-     * or the id is registered by more than one server. A resolved target names a
-     * channel by id alone, and ids are unique only within a connection, so a
-     * shared id could route the reply through the wrong server.
+     * Undefined when there is no safe token: the channel isn't registered, or
+     * no candidate is whitespace-free and resolves back to this channel, on
+     * this server.
      */
-    proseTargetFor(channelId, serverId) {
-        const sameId = [...this.channels.values()].filter((e) => e.descriptor.id === channelId);
-        const entry = serverId ? sameId.find((e) => e.serverId === serverId) : sameId[0];
-        if (!entry || sameId.length > 1)
+    proseTargetFor(ref) {
+        const entry = this.entryAt(ref);
+        if (!entry)
             return undefined;
         const d = entry.descriptor;
         const label = d.label ?? '';
@@ -3452,24 +3919,136 @@ export class ChannelRegistry {
         const candidates = [
             ...(isDm && dmName ? [`@${dmName}`] : []),
             ...(bare ? [`#${bare}`, `#${bare.replace(/\s*\([^)]*\)\s*$/, '')}`] : []),
-            d.id,
+            ...(this.nameFor(entry) !== undefined ? [this.nameFor(entry)] : []),
+            qualifiedChannelName(ref),
         ];
         for (const c of candidates) {
-            if (/\s/.test(c) || c === '#')
+            if (!isProseTargetToken(c) || c === '#')
                 continue;
             const r = this.resolveProseTarget(c, { forSpeech: true });
-            if ('channelId' in r && r.channelId === d.id)
+            if ('channelId' in r && sameChannel(r, ref))
                 return c;
         }
         return undefined;
     }
+    /** Whether the decision on record is a close the agent or a module made
+     *  (isCloseDecision). */
+    closeDecided(ref) {
+        const current = this.desiredStates.get(this.lifecycleKey(ref.serverId, ref.channelId));
+        return current?.state === 'closed' && isCloseDecision(current.source);
+    }
+    /**
+     * Whether the agent's words delivered into this channel open it first, by
+     * publish() or after an explicit send (openIfClosedForSend): one that isn't
+     * open, or whose close stands (closeStands: a close that failed may have
+     * left its transport open), unless speech leaves it as it stands
+     * (speechLeavesAsItStands). Where nobody decided (no record, a pure
+     * default) or a machine closed the channel (subscription-gc,
+     * housekeeping), it opens, as it always did, and so does one decided open
+     * whose transport isn't confirmed. A tuned-out channel whose transport
+     * isn't open is opened for its traffic, and its tune-out stays
+     * (openChannelNow). A server that isn't up isn't one this host can't
+     * direct, though a drop empties its grant until its next exchange, so
+     * speech there is refused as it always was: by the open's failure, which
+     * says the server is connecting or reconnecting, or, where its grant is
+     * empty, by publish()'s grant check before any open.
+     */
+    speechOpens(ref) {
+        const entry = this.entryAt(ref);
+        return !!entry && (!entry.open || this.closeStands(entry)) && !this.speechLeavesAsItStands(entry);
+    }
+    /** Whether speech leaves this registration as it stands, never opening
+     *  it, and words go into it as it is: the decision on record is a close
+     *  the agent made itself (channel_close, channel_decline) or a module made
+     *  (MODULE_CLOSE_SOURCE), which stands against the agent's own speech
+     *  whatever the channel's transport is; or its server is up and this host
+     *  doesn't direct its lifecycle (lifecycleWithheld), so nothing opens
+     *  there. A wait or an open that failed gives way to such a registration,
+     *  as when the agent closed the channel while the words waited, since
+     *  there's nothing for the words to wait for (refusalGivesWay). */
+    speechLeavesAsItStands(entry) {
+        if (!entry)
+            return false;
+        return this.closeDecided(refOf(entry)) || this.lifecycleWithheld(entry.serverId);
+    }
+    /** Whether words a wait or an open refused go into the channel after all:
+     *  its registration `now` is one speech leaves as it stands
+     *  (speechLeavesAsItStands), such as one the agent closed or declined
+     *  while the words waited, and the failure isn't convergence that never
+     *  established its target (convergeFailure). A registration that went
+     *  still fails them, and publish() refuses one the server last answered
+     *  for another channel (answeredElsewhere), whenever that happened. */
+    refusalGivesWay(err, now) {
+        return this.speechLeavesAsItStands(now) && !convergeFailure(err);
+    }
+    /** Whether this host doesn't direct the server's channel lifecycle: the
+     *  server is up, and its grant lacks channels.lifecycle, so nothing opens
+     *  or closes its channels. A server that isn't up has an empty grant from
+     *  a drop until its next exchange, which says nothing yet of what it
+     *  grants, so it isn't counted. */
+    lifecycleWithheld(serverId) {
+        return !this.directsLifecycle(serverId) && this.serverReach(serverId) === 'up';
+    }
+    /** Whether the agent's words go into this channel and leave it closed: it
+     *  isn't open at the transport, and speech leaves it as it stands
+     *  (speechLeavesAsItStands: the agent's or a module's close, or a server
+     *  that's up without channels.lifecycle). False for a channel open at the
+     *  transport, whose traffic still flows, and for one speech opens. */
+    speechLeavesClosed(ref) {
+        const entry = this.entryAt(ref);
+        return !!entry && !entry.open && this.speechLeavesAsItStands(entry);
+    }
     /**
-     * Open a channel because something was DELIVERED into it (explicit send
-     * tool or routed speech). Sending into a closed channel is not a thing:
-     * 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). An `open-failed` answer says
+     * How the agent kept this registered channel closed itself, if it did:
+     * 'closed' for its channel_close, 'declined' for its channel_decline. Its
+     * speech there leaves such a channel as it stands (speechOpens). A
+     * channel no longer registered has nothing to keep closed, whatever its
+     * record says, so it answers undefined.
+     */
+    closedByAgent(ref) {
+        if (!this.entryAt(ref))
+            return undefined;
+        const current = this.desiredStates.get(this.lifecycleKey(ref.serverId, ref.channelId));
+        if (current?.state !== 'closed')
+            return undefined;
+        if (current.source === 'agent-tool')
+            return 'closed';
+        if (current.source === 'invitation-declined')
+            return 'declined';
+        return undefined;
+    }
+    /** The registered channels an explicit send tool may have delivered into,
+     *  from the id the tool reported or was given: a composite MCPL id, or the
+     *  raw server-internal id (`address.channelId`), since send tools receive
+     *  whatever the agent typed. Matches on `serverId` when it is given,
+     *  across every server otherwise. */
+    sendTargets(rawChannelId, serverId) {
+        const matches = [...this.channels.values()].filter((e) => e.descriptor.id === rawChannelId && (!serverId || e.serverId === serverId));
+        if (matches.length > 0)
+            return matches;
+        return [...this.channels.values()].filter((e) => e.descriptor.address?.channelId === rawChannelId &&
+            (!serverId || e.serverId === serverId));
+    }
+    /** The one registered channel an explicit send tool delivered into
+     *  (sendTargets), or undefined when none or more than one matches. A
+     *  lookup only, for what's said beside the send's answer before it's
+     *  queued; openIfClosedForSend decides whether the send opens it. */
+    resolveSendTarget(rawChannelId, serverId) {
+        const matches = this.sendTargets(rawChannelId, serverId);
+        return matches.length === 1 ? refOf(matches[0]) : undefined;
+    }
+    /**
+     * Open a channel because something was DELIVERED into it by an explicit
+     * send tool, so typing indicators, reaction machinery and inbound
+     * forwarding all come alive with the first outbound message, unless
+     * speech leaves it as it stands (speechLeavesAsItStands: the agent closed
+     * or declined it itself, a module closed it, or its server is up and this
+     * host doesn't direct its lifecycle). Such a channel opens nothing, and
+     * answers `stays-closed`, or `already-open` where its transport is open
+     * with no close standing, whether the send found it so or it became so
+     * while the send's wait or open was out.
+     * Accepts composite MCPL ids or raw server-internal ids (sendTargets). 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
@@ -3482,11 +4061,7 @@ export class ChannelRegistry {
      * (`selected-again`).
      */
     async openIfClosedForSend(rawChannelId, serverId) {
-        let matches = [...this.channels.values()].filter((e) => e.descriptor.id === rawChannelId && (!serverId || e.serverId === serverId));
-        if (matches.length === 0) {
-            matches = [...this.channels.values()].filter((e) => e.descriptor.address?.channelId === rawChannelId &&
-                (!serverId || e.serverId === serverId));
-        }
+        const matches = this.sendTargets(rawChannelId, serverId);
         if (matches.length === 0)
             return { status: 'unknown-channel' };
         if (matches.length > 1)
@@ -3499,8 +4074,14 @@ export class ChannelRegistry {
             }
             const desired = this.getDesiredState(entry.serverId, entry.descriptor.id);
             if (entry.open && (desired === 'open' || desired === 'tuned-out')) {
-                return { status: 'already-open', channelId: entry.descriptor.id, label: entry.descriptor.label };
+                return { status: 'already-open', channelId: entry.descriptor.id, serverId: entry.serverId, label: entry.descriptor.label };
             }
+            // A channel speech leaves as it stands opens nothing. Every other one
+            // is opened, as it always was: one open at the transport with no
+            // decision on record too, so the send's engagement is recorded as an
+            // open decision, which a retarget or a restart carries out.
+            if (this.speechLeavesAsItStands(entry))
+                return this.sendLeavesChannel(entry);
             opening = desired !== 'open' && desired !== 'tuned-out';
             const { opened } = await this.openChannelNow(entry, 'opened-by-reply');
             entry = await this.waitForOpenChannel(entry);
@@ -3511,12 +4092,23 @@ export class ChannelRegistry {
                     channelId: entry.descriptor.id,
                 });
             }
-            return { status: opened ? 'opened' : 'already-open', channelId: entry.descriptor.id, label: entry.descriptor.label };
+            return {
+                status: opened ? 'opened' : 'already-open',
+                channelId: entry.descriptor.id, serverId: entry.serverId, label: entry.descriptor.label,
+            };
         }
         catch (err) {
+            // A channel the send now leaves as it stands, such as one the agent
+            // closed or declined while queued work or the open was out, answers as
+            // one it found so: nothing failed that the send would have done.
+            // Convergence that never established its target is still reported
+            // (refusalGivesWay).
+            const now = this.entryAt({ serverId: entry.serverId, channelId: entry.descriptor.id });
+            if (this.refusalGivesWay(err, now))
+                return this.sendLeavesChannel(now);
             // 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.
+            // as the agent's 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({
@@ -3525,8 +4117,8 @@ export class ChannelRegistry {
                 channelId: entry.descriptor.id,
                 error: err.message,
             });
-            const current = this.channels.get(`${entry.serverId}:${entry.descriptor.id}`);
-            return { status: 'open-failed', channelId: entry.descriptor.id, opening,
+            const current = this.entryAt({ serverId: entry.serverId, channelId: entry.descriptor.id });
+            return { status: 'open-failed', channelId: entry.descriptor.id, serverId: entry.serverId, 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' } : {}),
@@ -3534,8 +4126,16 @@ export class ChannelRegistry {
                 ...(current ? { label: current.descriptor.label } : {}) };
         }
     }
-    async handleToolOpen(input) {
-        const resolved = this.resolveToolChannelEntry(input.channelId, input.serverId);
+    /** What a send answers for a channel it leaves as it is
+     *  (speechLeavesAsItStands):
+     *  `already-open` where its transport is open with no close standing,
+     *  `stays-closed` otherwise. */
+    sendLeavesChannel(entry) {
+        const status = entry.open && !this.closeStands(entry) ? 'already-open' : 'stays-closed';
+        return { status, channelId: entry.descriptor.id, serverId: entry.serverId, label: entry.descriptor.label };
+    }
+    async handleToolOpen(input, own) {
+        const resolved = this.resolveToolChannelEntry(input.channelId, input.serverId, own);
         const entry = resolved.entry;
         if (!entry) {
             return {
@@ -3544,12 +4144,17 @@ export class ChannelRegistry {
                 isError: true,
             };
         }
+        // From here, the channel's own id, whichever name the call gave for it
+        // (a server-qualified one included).
+        input = { ...input, channelId: entry.descriptor.id };
+        // The channel as the agent is shown it, and names it back (nameShown).
+        const shown = this.nameShown(refOf(entry));
         // 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.
         if (this.getDesiredState(entry.serverId, input.channelId) === 'tuned-out') {
-            return tunedOutRefusal('channel_open', input.channelId);
+            return this.tunedOutRefusal('channel_open', entry);
         }
         const alreadyDesiredOpen = this.getDesiredState(entry.serverId, input.channelId) === 'open';
         if (entry.open && alreadyDesiredOpen && !input.backscroll && !this.hasPendingLifecycle(entry)) {
@@ -3563,13 +4168,13 @@ export class ChannelRegistry {
             catch (err) {
                 return {
                     success: false,
-                    error: `Channel ${input.channelId} is already open, but recording your decision to open it failed: ${err.message}`,
+                    error: `Channel ${shown} 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' },
+                data: { channelId: input.channelId, serverId: entry.serverId, status: 'already open' },
             };
         }
         try {
@@ -3584,6 +4189,7 @@ export class ChannelRegistry {
                 success: true,
                 data: {
                     channelId: input.channelId,
+                    serverId: entry.serverId,
                     status: alreadyDesiredOpen ? 'reconciled' : 'opened',
                     ...(result.history ? { history: result.history } : {}),
                     ...(result.historyTruncated ? { historyTruncated: true } : {}),
@@ -3603,7 +4209,7 @@ export class ChannelRegistry {
         }
     }
     async handleToolClose(input, origin) {
-        const resolved = this.resolveToolChannelEntry(input.channelId, input.serverId);
+        const resolved = this.resolveToolChannelEntry(input.channelId, input.serverId, origin?.kind === 'agent' ? origin.own : undefined);
         const entry = resolved.entry;
         if (!entry) {
             return {
@@ -3612,13 +4218,19 @@ export class ChannelRegistry {
                 isError: true,
             };
         }
+        // From here, the channel's own id, whichever name the call gave for it
+        // (a server-qualified one included).
+        input = { ...input, channelId: entry.descriptor.id };
+        // The channel as the agent is shown it, and names it back (nameShown).
+        const shown = this.nameShown(refOf(entry));
         // 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
+        // the closed vocabulary; without one, a module's close is its own
+        // (MODULE_CLOSE_SOURCE). Agent-origin (or origin-less — the safe
         // default for any legacy caller) records 'agent-tool' and has its
         // machine fields ignored entirely.
         const isModuleOrigin = origin?.kind === 'module';
-        let closeSource = 'agent-tool';
+        let closeSource = isModuleOrigin ? MODULE_CLOSE_SOURCE : 'agent-tool';
         if (isModuleOrigin && input.source !== undefined) {
             if (!MACHINE_CLOSE_SOURCES.has(input.source)) {
                 return {
@@ -3642,13 +4254,13 @@ export class ChannelRegistry {
             catch (err) {
                 return {
                     success: false,
-                    error: `Channel ${input.channelId} is already closed, but recording the decision to close it failed: ${err.message}`,
+                    error: `Channel ${shown} 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' },
+                data: { channelId: input.channelId, serverId: entry.serverId, status: 'already closed' },
             };
         }
         // Housekeeping must not override stated intent (issue #5: GC closes wore
@@ -3656,7 +4268,7 @@ export class ChannelRegistry {
         // close of a channel whose current desired state is an agent/operator
         // 'open' is refused — structurally, so the caller can stand down rather
         // than retry — unless it certifies an explicit idle lease.
-        if (isModuleOrigin && closeSource !== 'agent-tool' && !input.overrideExplicitOpen) {
+        if (isModuleOrigin && MACHINE_CLOSE_SOURCES.has(closeSource) && !input.overrideExplicitOpen) {
             const current = this.desiredStates.get(this.lifecycleKey(entry.serverId, input.channelId));
             // Tuned-out is stated intent too: a GC/housekeeping close would
             // silently end the epoch and orphan its backlog.
@@ -3664,10 +4276,10 @@ export class ChannelRegistry {
                 return {
                     success: false,
                     isError: false,
-                    error: `Channel ${input.channelId} was explicitly opened (source: agent-tool); ` +
+                    error: `Channel ${shown} was explicitly opened (source: agent-tool); ` +
                         `a '${closeSource}' close does not override stated intent. Machine closes ` +
                         `of explicit opens require an explicit idle lease (overrideExplicitOpen).`,
-                    data: { refusal: 'explicit-open', channelId: input.channelId },
+                    data: { refusal: 'explicit-open', channelId: input.channelId, serverId: entry.serverId },
                 };
             }
         }
@@ -3679,7 +4291,7 @@ export class ChannelRegistry {
         // that certified an idle lease, which the guard above lets through, is
         // refused too, as a refusal it stands down on rather than an error.
         if (this.getDesiredState(entry.serverId, input.channelId) === 'tuned-out') {
-            const refusal = tunedOutRefusal('channel_close', input.channelId);
+            const refusal = this.tunedOutRefusal('channel_close', entry);
             return isModuleOrigin ? { ...refusal, isError: false } : refusal;
         }
         // A decision the log refused changed nothing, and the answer says so.
@@ -3689,7 +4301,9 @@ export class ChannelRegistry {
         catch (err) {
             return { success: false, error: this.lifecycleFailureText('close', entry, unrecordedDecision(err)), isError: true };
         }
-        this.stopTyping(input.channelId);
+        // This channel's typing, not every channel with its id (stopTyping's
+        // fan-out of a bare name).
+        this.stopTyping(refOf(entry));
         // Refused now, the close stays recorded for the server's next
         // registration, and the text says so.
         if (!this.directsLifecycle(entry.serverId)) {
@@ -3702,27 +4316,37 @@ export class ChannelRegistry {
                 throw new ChannelLifecycleError(supersededClause('close', now), 'superseded');
             return {
                 success: true,
-                data: { channelId: input.channelId, status: 'closed' },
+                data: { channelId: input.channelId, serverId: entry.serverId, status: 'closed' },
             };
         }
         catch (err) {
             return { success: false, error: this.lifecycleFailureText('close', entry, err), isError: true };
         }
     }
-    async handleToolDecline(input) {
-        const resolved = this.resolveToolChannelEntry(input.channelId, input.serverId);
+    async handleToolDecline(input, own) {
+        const resolved = this.resolveToolChannelEntry(input.channelId, input.serverId, own);
         const entry = resolved.entry;
         if (!entry) {
             return { success: false, error: resolved.error, isError: true };
         }
+        // From here, the channel's own id, whichever name the call gave for it
+        // (a server-qualified one included).
+        input = { ...input, channelId: entry.descriptor.id };
+        // The channel as the agent is shown it, and names it back (quotedShown).
+        const quoted = this.quotedShown(refOf(entry));
         // 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') {
+            return this.tunedOutRefusal('channel_decline', entry);
+        }
+        // Refused only for a channel open at the transport. One decided open
+        // whose open failed or is still on its way isn't open there, and the
+        // invitation a message from it brings offers the decline as the way to
+        // reply without opening it. The decline closes it below, through the
+        // lifecycle queue, wherever its transport may be open.
+        if (entry.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
@@ -3731,7 +4355,7 @@ export class ChannelRegistry {
                 ? this.lifecycleRefusal(entry.serverId) : undefined;
             return {
                 success: false,
-                error: `Channel "${input.channelId}" is open, or set to open, so there's nothing to decline` +
+                error: `Channel ${quoted} is 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,
@@ -3746,7 +4370,7 @@ export class ChannelRegistry {
         catch (err) {
             return {
                 success: false,
-                error: `Nothing changed for channel "${input.channelId}": ${unrecordedDecision(err).message}, so no acknowledgment ` +
+                error: `Nothing changed for channel ${quoted}: ${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,
@@ -3827,7 +4451,7 @@ export class ChannelRegistry {
         // below; the decision stands.
         let closeFailure;
         let closeFailed = false;
-        const current = this.channels.get(`${entry.serverId}:${input.channelId}`);
+        const current = this.entryAt({ serverId: entry.serverId, channelId: input.channelId });
         if (current && this.directsLifecycle(entry.serverId) &&
             this.getDesiredState(entry.serverId, input.channelId) === 'closed' &&
             (current.open || this.unconfirmedChannelTargets.has(current) || this.hasPendingLifecycle(current))) {
@@ -3852,7 +4476,7 @@ export class ChannelRegistry {
         // 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 after = this.entryAt({ serverId: entry.serverId, channelId: 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
@@ -3965,6 +4589,7 @@ export class ChannelRegistry {
             success: true,
             data: {
                 channelId: input.channelId,
+                serverId: entry.serverId,
                 status,
                 acknowledged,
                 ...(representation ? { representation } : {}),
@@ -4067,101 +4692,60 @@ export class ChannelRegistry {
      * 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.
+     * publish delivered before it.
      */
     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);
-            }
-        }
+        const key = destinationKey(to);
+        let started = this.takenStreams.get(inferenceId);
+        const continuing = started?.has(key) ?? false;
+        const server = this.streamingServerAt(to, !continuing);
         if (!server)
             return;
-        const channelId = typeof to === 'string' ? to : to.channelId;
+        if (!continuing) {
+            if (!started)
+                this.takenStreams.set(inferenceId, started = new Set());
+            started.add(key);
+        }
         try {
-            server.sendChannelsOutgoingChunk({ inferenceId, conversationId, channelId, index, delta });
+            server.sendChannelsOutgoingChunk({ inferenceId, conversationId, channelId: to.channelId, index, delta });
         }
         catch { /* observer surface — never disturb the turn */ }
     }
     /**
      * 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).
+     * 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.
      */
     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);
-        }
+        const started = this.takenStreams.get(inferenceId);
+        if (!started?.delete(destinationKey(to)))
+            return;
+        if (started.size === 0)
+            this.takenStreams.delete(inferenceId);
+        const server = this.streamingServerAt(to, false);
         if (!server)
             return;
         try {
             server.sendChannelsOutgoingComplete({
                 inferenceId,
                 conversationId,
-                channelId: typeof to === 'string' ? to : to.channelId,
+                channelId: to.channelId,
                 content: [{ type: 'text', text }],
             });
         }
         catch { /* observer surface — never disturb the turn */ }
     }
-    streamingServerFor(channelId) {
-        // The map is keyed `${serverId}:${channelId}`; stream targets arrive as
-        // bare descriptor ids (what resolveProseTarget returns). Scan like the
-        // resolver does, and fail closed on cross-server ambiguity — the same
-        // never-guess rule that governs delivery.
-        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
-        // for the boolean `channels: true` shape (masking discord-mcpl's latent
-        // double-post, AUDIT-001), and pre-policy it would have sent before the
-        // server was told anything was granted.
-        if (!CapabilityGrant.of(server).has('channels.streaming'))
-            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.
+     * registers that channel, and its grant has `channels.streaming` (§5.4:
+     * the grant gates streaming, not the raw advertisement). 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)
+        const entry = this.entryAt(to);
+        if (!entry)
             return null;
         if (starting && isInboundOnly(entry))
             return null;
@@ -4169,11 +4753,16 @@ export class ChannelRegistry {
         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`. */
+     *  process-global default), with its server. Public so a multi-segment
+     *  caller can snapshot it ONCE and pin every segment to it via
+     *  routeSpeech's locus. */
     resolveLocus(conversationId) {
         const home = this.homeChannelResolver?.(conversationId);
-        return home ?? this.activeChannelResolver?.(conversationId) ?? this.globalFallbackFor(conversationId);
+        if (home)
+            return home;
+        // A turn that deliberately has no channel (null) takes no fallback.
+        const active = this.activeChannelResolver?.(conversationId);
+        return active !== undefined ? active : this.globalFallbackFor(conversationId);
     }
     /** The process-global fallback channel for this conversation, or null when it takes none (takesGlobalFallback). */
     globalFallbackFor(conversationId) {
@@ -4181,9 +4770,10 @@ export class ChannelRegistry {
     }
     /**
      * Resolve a publish target to exactly one registered channel: `serverId`
-     * plus `channelId` when the caller has the server, otherwise a channel id
-     * registered by exactly one server. A shared id is refused, never resolved
-     * to whichever server registered it first.
+     * plus `channelId` when the caller has the server, otherwise the one
+     * channel the id, or its server-qualified name, means (entriesNamed). A
+     * shared id is refused, never resolved to whichever server registered it
+     * first.
      */
     resolveDestination(target) {
         const entry = this.findExactEntry(target);
@@ -4206,7 +4796,11 @@ export class ChannelRegistry {
         if (target.serverId !== undefined && (typeof target.serverId !== 'string' || !target.serverId)) {
             return { error: 'serverId must name a server (omit it to resolve the channel id alone)' };
         }
-        const matches = [...this.channels.values()].filter((e) => e.descriptor.id === target.channelId && (!target.serverId || e.serverId === target.serverId));
+        // Without a server, the channel id, or its server-qualified name, means
+        // what it means to every channel tool (entriesNamed).
+        const matches = target.serverId
+            ? [this.entryAt({ serverId: target.serverId, channelId: target.channelId })].filter((e) => e !== undefined)
+            : this.entriesNamed(target.channelId);
         if (matches.length === 0) {
             return {
                 error: target.serverId
@@ -4215,12 +4809,16 @@ export class ChannelRegistry {
             };
         }
         if (matches.length > 1) {
+            // The framework's own speech always names its server, so only a
+            // caller that named none meets this, and it can name one.
+            // Each named by what picks it alone, or by its id and server where
+            // nothing does; "more than one server" only where the servers differ.
+            const names = matches.map((e) => this.quotedShown(refOf(e)));
+            const servers = new Set(matches.map((e) => e.serverId));
             return {
-                // 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',
+                error: servers.size > 1
+                    ? `channel id "${target.channelId}" is on more than one server (${names.join(', ')}), and the destination named no server`
+                    : `channel id "${target.channelId}" names more than one channel on server "${matches[0].serverId}" (${names.join(', ')})`,
             };
         }
         return { entry: matches[0] };
@@ -4234,16 +4832,19 @@ export class ChannelRegistry {
      * publishReceiptOutcome and publishErrorOutcome.
      *
      * Resolution is exact (resolveDestination): `serverId` plus `channelId`
-     * when the caller has the server, otherwise the channel id must be
-     * registered by exactly one server (a shared id is refused, never routed
-     * through whichever server came first). An omitted `serverId` means "not
+     * when the caller has the server, otherwise the channel id, or its
+     * server-qualified name, must mean exactly one channel (a shared id is
+     * refused, never routed through whichever server came first). An omitted `serverId` means "not
      * in use"; a supplied one must be a non-empty server id, and an empty or
      * non-string selector is refused rather than read as omission. It is not
-     * 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 send refused before the open opens nothing; and a failed open sends
-     * nothing.
+     * possible to send into a closed channel that speech opens (speechOpens):
+     * it's opened first (`openSource` names why), once its server and that
+     * server's channels.publish grant are known to take the send, so a send
+     * refused before the open opens nothing; and a failed open sends nothing.
+     * A channel speech leaves as it stands (speechLeavesAsItStands), one the
+     * agent closed or declined itself or a module closed, or a closed one on
+     * a server that's up but whose lifecycle this host doesn't direct, takes
+     * the words as it is, once its queued lifecycle work has settled.
      *
      * A channel its server declared inbound-only (isInboundOnly) takes nothing
      * the host would post, whichever path the words took, a drafts resend
@@ -4306,30 +4907,41 @@ export class ChannelRegistry {
         const prevented = (err) => ({
             status: 'failed', destination, reason: lifecycleClause(err) + refusalRemedy(err), at: at(),
         });
+        // Words go into a channel that's open with no close standing, or into
+        // one speech leaves as it stands (speechLeavesAsItStands): a channel the
+        // agent closed or declined itself, or a module closed, and a closed
+        // channel on a server that's up but whose lifecycle this host doesn't
+        // direct, where nothing opens. Every other channel speech opens first
+        // (speechOpens), and if it doesn't open, nothing goes out. A wait or an
+        // open that fails is read against the channel as it is then, so a close
+        // the agent decides while the words wait lets them go into the channel
+        // as that close leaves it, unless the failure is convergence that never
+        // established its target (refusalGivesWay). A channel the server last
+        // answered for another one takes nothing as it stands (answeredElsewhere).
         // 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.
+        // none open and speech would open it.
         if (this.hasPendingLifecycle(entry)) {
             try {
                 entry = await this.waitForOpenChannel(entry);
             }
             catch (err) {
-                return prevented(err);
+                const now = this.entryAt(refOf(entry));
+                if (!this.refusalGivesWay(err, now))
+                    return prevented(err);
+                entry = now;
             }
         }
-        // INVARIANT: it is not possible to send into a closed channel. A send
-        // into a closed-but-registered channel (the canonical case: a DM that
-        // woke the agent, since DMs register closed) OPENS it first, so typing
-        // indicators, reaction machinery and inbound forwarding come alive with
-        // the words. If the open fails, nothing goes out: a half-alive delivery
-        // is worse than a loud marker. A channel decided closed is engaged even
-        // while its transport is still open (a close that failed), as a reply
-        // would engage it, wherever an open can succeed. Without the lifecycle
-        // grant it can't, and a send opens before it publishes, so there a
-        // channel whose transport is open keeps publishing.
-        const engagesDecidedClosed = this.getDesiredState(entry.serverId, entry.descriptor.id) === 'closed' &&
-            CapabilityGrant.of(server).has('channels.lifecycle');
-        if (!entry.open || engagesDecidedClosed) {
+        // A send into a closed-but-registered channel (the canonical case: a DM
+        // that woke the agent, since DMs register closed) OPENS it first where
+        // speech opens it (speechOpens), so typing indicators, reaction
+        // machinery and inbound forwarding come alive with the words. If the
+        // open fails, nothing goes out: a half-alive delivery is worse than a
+        // loud marker. A channel decided closed is engaged even while its
+        // transport is still open (a close that failed), as a reply would engage
+        // it, wherever an open can succeed, unless that close is the agent's or
+        // a module's own.
+        if (this.speechOpens(refOf(entry))) {
             try {
                 const { opened } = await this.openChannelNow(entry, openSource);
                 entry = await this.waitForOpenChannel(entry);
@@ -4358,7 +4970,10 @@ export class ChannelRegistry {
                 }
             }
             catch (err) {
-                return { status: 'failed', destination, reason: openFailedReason(err), at: at() };
+                const now = this.entryAt(refOf(entry));
+                if (!this.refusalGivesWay(err, now))
+                    return { status: 'failed', destination, reason: openFailedReason(err), at: at() };
+                entry = now;
             }
         }
         // Checked again here, after every await above, the lifecycle work's, the
@@ -4374,15 +4989,18 @@ export class ChannelRegistry {
         // 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}`;
+        // throws, so the loop ends unless the channel keeps changing. A channel
+        // speech leaves as it stands (speechLeavesAsItStands) needs none of
+        // that, and its words go into it as it is.
+        const key = destinationKey({ serverId: entry.serverId, channelId: entry.descriptor.id });
         let current = this.channels.get(key);
-        while (current && !isInboundOnly(current) && (!current.open || this.closeStands(current))) {
+        while (current && !isInboundOnly(current) && (!current.open || this.closeStands(current)) && !this.speechLeavesAsItStands(current)) {
             try {
                 entry = await this.waitForOpenChannel(current);
             }
             catch (err) {
-                return prevented(err);
+                if (!this.refusalGivesWay(err, this.channels.get(key)))
+                    return prevented(err);
             }
             current = this.channels.get(key);
         }
@@ -4391,6 +5009,17 @@ export class ChannelRegistry {
         if (isInboundOnly(current)) {
             return { status: 'failed', destination, reason: inboundOnlyReason(current), at: at() };
         }
+        // A channel the words go into as it stands, with no open to check what
+        // the server reaches by its id, takes nothing where the server answered
+        // its last open for another channel, whenever that was (answeredElsewhere):
+        // the words could reach that other channel.
+        if ((!current.open || this.closeStands(current)) && this.answeredElsewhere.has(current)) {
+            return {
+                status: 'failed', destination, at: at(),
+                reason: `the "${current.serverId}" server answered this channel's last open for a different channel, so words ` +
+                    "sent by its id may not reach it; once an open of it is answered for this channel, they go into it again",
+            };
+        }
         // 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`).
@@ -4423,7 +5052,7 @@ export class ChannelRegistry {
      * that used to live in discord-mcpl.
      */
     async deliverSpeech(conversationId, text, 
-    /** The turn's FROZEN locus, snapshotted once by the caller (resolveLocus
+    /** The turn's FROZEN locus, with its server, snapshotted once by the caller (resolveLocus
      *  at turn start) and passed to every segment of the turn. Mandatory:
      *  there is deliberately no live-resolution fallback here — a late
      *  dispatch resolving live can read the NEXT turn's trigger state or a
@@ -4432,21 +5061,23 @@ export class ChannelRegistry {
      *  "this turn is pinned to no locus": fail loudly rather than guess,
      *  except for an ephemeral run, whose speech is then its caller's
      *  result. */
-    locusChannelId, 
+    locus, 
     /** `heldOnFailure`: the caller holds a `failed` delivery's words as a
      *  draft with its own notice, so no failure marker is written for it.
      *  An `unknown` outcome still gets its marker. */
     opts) {
         // `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 fail = (channel, reason, outcome, logged = reason) => {
             const status = outcome.status === 'unknown' ? 'unknown' : 'failed';
+            const channelId = channel?.channelId ?? null;
             const detail = outcome.detail !== undefined ? connectorText(outcome.detail) : undefined;
             const detailText = detail !== undefined ? `; connector detail: ${detail}` : '';
             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,
+                ...(channel ? { serverId: channel.serverId } : {}),
                 channelId: channelId ?? '',
                 reason: logged,
                 textLen: text.length,
@@ -4454,7 +5085,10 @@ export class ChannelRegistry {
                 ...(detail !== undefined ? { detail } : {}),
             });
             if (status === 'unknown' || !opts?.heldOnFailure) {
-                this.onRouteFailure?.({ conversationId, channelId, reason, textLen: text.length, outcome: status, ...(detail !== undefined ? { detail } : {}) });
+                this.onRouteFailure?.({
+                    conversationId, channelId, ...(channel ? { serverId: channel.serverId } : {}),
+                    reason, textLen: text.length, outcome: status, ...(detail !== undefined ? { detail } : {}),
+                });
             }
             return outcome;
         };
@@ -4467,11 +5101,11 @@ export class ChannelRegistry {
         // 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) {
+        if (locus === undefined) {
             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) {
+        if (!locus) {
             // An ephemeral run with no channel of its own: its plain speech is its
             // caller's result (takesGlobalFallback). It returns as not delivered,
             // with its own reason, and writes no line, trace or notice.
@@ -4486,10 +5120,10 @@ export class ChannelRegistry {
                 '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;
+        const outcome = await this.publish(conversationId, text, { serverId: locus.serverId, channelId: locus.channelId, routed: true });
+        const channelId = outcome.destination?.channelId ?? locus.channelId;
         if (outcome.status !== 'delivered') {
-            return fail(channelId, outcome.reason ?? 'delivery not confirmed', outcome);
+            return fail(outcome.destination ?? locus, outcome.reason ?? 'delivery not confirmed', outcome);
         }
         console.error(`[routeSpeech] ${conversationId}: routed ${text.length} chars -> ${logValue(channelId)} (server=${outcome.destination.serverId}, delivered=true)`);
         this.emitTraceFn({
@@ -4508,8 +5142,8 @@ export class ChannelRegistry {
         return outcome;
     }
     /** deliverSpeech, reduced to the confirmed delivery (null when there was none). */
-    async routeSpeech(conversationId, text, locusChannelId) {
-        const outcome = await this.deliverSpeech(conversationId, text, locusChannelId);
+    async routeSpeech(conversationId, text, locus) {
+        const outcome = await this.deliverSpeech(conversationId, text, locus);
         if (outcome.status !== 'delivered')
             return null;
         return {
@@ -4525,10 +5159,14 @@ export class ChannelRegistry {
      * 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. */
+    async handleToolPublish(
+    /** `serverId` isn't in channel_publish's schema: the framework gives it
+     *  with a conversation fork's home, and publishForAgent with a ref. */
+    input, origin, 
+    /** Filled for publishForAgent: the channel the call names once it
+     *  resolves, and 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.'
@@ -4551,9 +5189,13 @@ export class ChannelRegistry {
         // 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.
+        // A channel named by a string means what it means to every channel tool
+        // (entriesNamed): one channel, by its id or its server-qualified name,
+        // and a name two servers' channels answer to is refused with them as
+        // candidates, never sent to the first.
         const caller = origin?.kind === 'agent' ? origin.agentName : undefined;
-        const channelId = input.channelId ?? (caller !== undefined ? this.globalFallbackFor(caller) : this.defaultPublishChannel);
-        if (!channelId) {
+        const fallback = caller !== undefined ? this.globalFallbackFor(caller) : this.defaultPublishChannel;
+        if (!(input.channelId ?? fallback)) {
             return {
                 success: false,
                 error: tool === 'speak_in_channel'
@@ -4565,18 +5207,90 @@ export class ChannelRegistry {
                 isError: true,
             };
         }
-        const entry = this.findChannelEntry(channelId);
+        // A host's ref (publishForAgent, the one caller that gives
+        // speak_in_channel a serverId) names its exact pair, an empty serverId
+        // included, as publish's destination does. A tool's empty serverId is a
+        // parameter filled with nothing, read as none given, as the channel tools
+        // read one.
+        const serverGiven = tool === 'speak_in_channel' ? input.serverId !== undefined : !!input.serverId;
+        // Inside the calling turn, a name one of the turn's own channels answers
+        // to by its id means that channel, as a `>>` target does (ownChannelNamed).
+        const own = input.channelId !== undefined && !serverGiven && origin?.kind === 'agent'
+            ? this.ownChannelNamed(input.channelId, origin.own)
+            : undefined;
+        let entry;
+        if (input.channelId === undefined) {
+            // A serverId given with no channelId names the default's id on that
+            // server, held to as one given with a channelId is.
+            entry = this.entryAt(serverGiven ? { serverId: input.serverId, channelId: fallback.channelId } : fallback);
+        }
+        else if (own && 'neither' in own) {
+            if (seen)
+                seen.refusal = 'shared-id';
+            return { success: false, error: this.ownNeitherRefusal(input.channelId, own.neither, 'was posted'), isError: true };
+        }
+        else if (own) {
+            entry = this.entryAt(own.channel);
+            if (!entry) {
+                if (seen)
+                    seen.refusal = 'channel-not-registered';
+                return { success: false, error: this.ownChannelGoneRefusal(input.channelId, own.channel, 'publish'), isError: true };
+            }
+        }
+        else if (serverGiven) {
+            entry = this.entryAt({ serverId: input.serverId, channelId: input.channelId });
+        }
+        else {
+            const matches = this.entriesNamed(input.channelId);
+            if (matches.length > 1) {
+                if (seen)
+                    seen.refusal = 'shared-id';
+                return {
+                    success: false,
+                    error: this.sharedNameRefusal(input.channelId, matches, { takesServerId: false, nothing: 'nothing was posted' }),
+                    isError: true,
+                };
+            }
+            entry = matches[0];
+        }
         if (!entry) {
             if (seen)
                 seen.refusal = 'channel-not-registered';
-            return { success: false, error: `No channel has the id "${channelId}", so nothing was posted. ${findIds}`, isError: true };
+            return {
+                success: false,
+                // The default channel is gone (its server no longer registers it),
+                // though another server's channel may have its id.
+                // No advice: the default's channel is gone, and another server's
+                // channel with its id isn't where its message came from.
+                error: input.channelId === undefined
+                    ? serverGiven
+                        ? `Server "${input.serverId}" has no channel "${fallback.channelId}", the id of the channel this call would default to, so nothing was posted.`
+                        : `The channel this would default to, ${this.quotedShown(fallback)}, isn't registered now, so nothing was posted.`
+                    // This tool's schema has no serverId, so one given here is a host's
+                    // ref (publishForAgent), or one an agent added unasked, and the
+                    // refusal offers names its channelId takes instead. (A fork's guard
+                    // refuses a home its server no longer registers before this runs.)
+                    : serverGiven
+                        ? `No channel "${input.channelId}" is on server "${input.serverId}", so nothing was posted. ${this.elsewhereText(input.channelId, false)}`
+                        : `No channel has the id "${input.channelId}", so nothing was posted. ${findIds}`,
+                isError: true,
+            };
         }
+        // From here, the channel's own id, whichever name the call gave for it,
+        // and the name the agent is shown it by (nameShown).
+        const channelId = entry.descriptor.id;
+        // The channel the call names, for a caller that reports a refusal before
+        // the send (publishForAgent's trace).
+        if (seen)
+            seen.resolved = refOf(entry);
+        const shown = this.nameShown(refOf(entry));
+        const quoted = this.quotedShown(refOf(entry));
         if (isInboundOnly(entry)) {
             if (seen)
                 seen.refusal = 'inbound-only';
             return {
                 success: false,
-                error: `Channel ${channelId} is ${inboundOnlyReason(entry)}`,
+                error: `Channel ${shown} is ${inboundOnlyReason(entry)}`,
                 isError: true,
             };
         }
@@ -4588,7 +5302,7 @@ export class ChannelRegistry {
                 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 };
+            return { success: false, error: `Nothing was posted to channel ${quoted}: ${this.sendRefusal(entry.serverId)}.`, isError: true };
         }
         const publishParams = {
             conversationId: '', // Framework will fill this when wired
@@ -4621,11 +5335,15 @@ export class ChannelRegistry {
             return { success: true, data: result };
         // The connector's data may say what a multi-part send already posted.
         const detail = outcome.status === 'unknown' && outcome.detail !== undefined ? ` Connector detail: ${connectorText(outcome.detail)}` : '';
+        // Named as it's shown now, after the send's await: registrations may have
+        // changed meanwhile, and the name shown before it may now pick another
+        // channel.
+        const sentTo = this.quotedShown(refOf(entry));
         return {
             success: false,
             error: (outcome.status === 'failed'
-                ? `Nothing was posted to channel "${channelId}": ${outcome.reason}.`
-                : `Posting to channel "${channelId}" wasn't confirmed: ${outcome.reason}. ` +
+                ? `Nothing was posted to channel ${sentTo}: ${outcome.reason}.`
+                : `Posting to channel ${sentTo} wasn't confirmed: ${outcome.reason}. ` +
                     'It may or may not have been posted, so sending it again could post it twice.') + detail,
             isError: true,
         };