@animalabs/agent-framework 0.23.1 → 0.23.3

package/src/gate/event-gate.ts

@@ -130,6 +130,9 @@ export interface WakeProvenance {
    *  (2026-09-30: a DM reply published into a guild channel). Ambient-only
    *  batches still set nothing and keep the legacy fallback. */
   routeChannelId?: string;
+  /** The server whose event `routeChannelId` came from: the turn's replies
+   *  to that channel go out through this server only. */
+  routeServerId?: string;
   /** Timestamp (ms) of the chosen event, so a consumer coalescing several
    *  requests can order by event recency, not by flush order. */
   at?: number;
@@ -235,7 +238,9 @@ export function wakeProvenance(events: PendingEvent[]): WakeProvenance | undefin
     ...(channelId ? { channelId } : {}),
     ...(pick.authorId ? { counterparty: `${ns}:user:${pick.authorId}` } : {}),
     ...(pick.addressed ? { addressed: true } : {}),
-    ...(pick.addressed && pick.routeChannelId ? { routeChannelId: pick.routeChannelId } : {}),
+    ...(pick.addressed && pick.routeChannelId
+      ? { routeChannelId: pick.routeChannelId, ...(pick.serverId ? { routeServerId: pick.serverId } : {}) }
+      : {}),
     at: pick.timestamp,
   };
 }

package/src/mcpl/channel-registry.ts

@@ -682,7 +682,17 @@ interface ChannelRegistryOptions {
  */
 export type ChannelToolOrigin =
   | { kind: 'module'; moduleName?: string }
-  | { kind: 'agent'; agentName: string };
+  | {
+    kind: 'agent';
+    agentName: string;
+    /** The calling turn's trigger channel with the server whose message it
+     *  was: a channel_publish into that channel goes out through that server
+     *  only. */
+    trigger?: { channelId: string; serverId: string };
+    /** The calling turn's locus with the server of the message that put it
+     *  there, where that isn't the trigger: the same holds for it. */
+    locus?: { channelId: string; serverId: string };
+  };
 
 /** The machine decision sources a module-origin channel_close may record.
  *  Closed on purpose: honest provenance means a small, auditable vocabulary,
@@ -772,6 +782,8 @@ export class ChannelRegistry {
 
   /** Most recent incoming channel ID — used for speech routing / default publish. */
   private defaultPublishChannel: string | null = null;
+  /** The server whose accepted message set defaultPublishChannel. */
+  private defaultPublishServer: string | null = null;
 
   /** Most recent incoming message metadata, used for buildChannelContext. */
   private defaultPublishMessageId: string | null = null;
@@ -932,7 +944,7 @@ export class ChannelRegistry {
       }
       const key = `${serverId}:${channel.id}`;
       this.registerEntry(key, serverId, channel);
-      this.appendLabelSighting(channel.id, channel.label, extractDmMeta(channel.metadata));
+      this.appendLabelSighting(serverId, channel.id, channel.label, extractDmMeta(channel.metadata));
       registeredIds.push(channel.id);
       results.push({ id: channel.id, accepted: true });
     }
@@ -1018,7 +1030,7 @@ export class ChannelRegistry {
           }
         }
         existing.descriptor = channel;
-        this.appendLabelSighting(channel.id, channel.label, extractDmMeta(channel.metadata));
+        this.appendLabelSighting(serverId, channel.id, channel.label, extractDmMeta(channel.metadata));
         addedResults.push({ id: channel.id, accepted: true });
       }
     }
@@ -1035,7 +1047,7 @@ export class ChannelRegistry {
         }
         const key = `${serverId}:${channel.id}`;
         this.registerEntry(key, serverId, channel);
-        this.appendLabelSighting(channel.id, channel.label, extractDmMeta(channel.metadata));
+        this.appendLabelSighting(serverId, channel.id, channel.label, extractDmMeta(channel.metadata));
         addedResults.push({ id: channel.id, accepted: true });
         accepted.push(channel);
       }
@@ -1237,6 +1249,7 @@ export class ChannelRegistry {
       const incomingEntry = this.channels.get(incomingKey)!;
       const markAccepted = () => {
         this.defaultPublishChannel = message.channelId;
+        this.defaultPublishServer = serverId;
         this.defaultPublishMessageId = message.messageId;
         this.defaultPublishThreadId = message.threadId;
         // Where the host directs this server's lifecycle, only a receipt for
@@ -1376,7 +1389,9 @@ export class ChannelRegistry {
     label?: string,
     extraMetadata?: Record<string, unknown>,
   ): void {
-    const existing = this.findChannelEntry(channelId);
+    // The pushing server's own entry: another server's entry for the same id
+    // is that server's, and a push leaves it as it was.
+    const existing = this.channels.get(`${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
@@ -1392,7 +1407,7 @@ export class ChannelRegistry {
         // Recorded before the live descriptor takes it, since this branch's
         // guard reads the descriptor: an append that throws leaves the
         // placeholder, so the next push tries again.
-        this.appendLabelSighting(existing.descriptor.id, label, extractDmMeta(metadata));
+        this.appendLabelSighting(serverId, existing.descriptor.id, label, extractDmMeta(metadata));
         existing.descriptor.label = label;
         existing.descriptor.metadata = metadata;
       }
@@ -1412,7 +1427,7 @@ export class ChannelRegistry {
     // routing; only the durable write is skipped when there's no real
     // label to record. A real label is recorded before the entry exists:
     // an append that throws registers nothing, so the next push tries again.
-    if (label) this.appendLabelSighting(channelId, label, extractDmMeta(extraMetadata));
+    if (label) this.appendLabelSighting(serverId, channelId, label, extractDmMeta(extraMetadata));
     const key = `${serverId}:${channelId}`;
     this.channels.set(key, {
       serverId,
@@ -1742,8 +1757,11 @@ export class ChannelRegistry {
       if (entry.serverId !== serverId) continue;
       this.channels.delete(key);
       this.stopTyping(entry.descriptor.id);
-      if (this.defaultPublishChannel === entry.descriptor.id) {
+      // The fallback goes with the server whose message set it, not with
+      // another server's entry for the same id.
+      if (this.defaultPublishChannel === entry.descriptor.id && this.defaultPublishServer === serverId) {
         this.defaultPublishChannel = null;
+        this.defaultPublishServer = null;
         this.defaultPublishMessageId = null;
         this.defaultPublishThreadId = undefined;
       }
@@ -1766,6 +1784,7 @@ export class ChannelRegistry {
 
     // Reset default publish tracking
     this.defaultPublishChannel = null;
+    this.defaultPublishServer = null;
     this.defaultPublishMessageId = null;
     this.defaultPublishThreadId = undefined;
   }
@@ -1910,11 +1929,17 @@ export class ChannelRegistry {
    * `resolveProseTargetDurable()`.
    */
   private appendLabelSighting(
+    serverId: string,
     channelId: string,
     label: string | undefined,
     dmMeta: { recipientId?: string; recipientName?: string; isDm?: boolean } = {},
   ): void {
     if (typeof label !== 'string' || !label) return;
+    // The log is kept by the bare id, and a durable lookup by label resolves
+    // to that id with no server. So a server's label for an id another
+    // server registers isn't recorded: it would name the other server's
+    // channel, across restarts.
+    if (this.registeredByAnotherServer(serverId, channelId)) return;
     const { recipientId, recipientName, isDm } = dmMeta;
     // Never let a bare-id placeholder (ensureChannelRegistered's fallback
     // `label ?? channelId` when no real label was ever supplied — e.g. a
@@ -2735,11 +2760,28 @@ export class ChannelRegistry {
       .map((e) => e.descriptor);
   }
 
+  /**
+   * The server whose accepted message set the global fallback, where
+   * `channelId` is the fallback's channel: a turn whose locus is the
+   * fallback resolves it with this server, taken with the locus.
+   */
+  fallbackServerFor(channelId: string): string | undefined {
+    return this.defaultPublishChannel === channelId ? this.defaultPublishServer ?? undefined : undefined;
+  }
+
   /** Server id owning a registered channel (by descriptor id), or null. */
   getChannelServerId(channelId: string): string | null {
     return this.findChannelEntry(channelId)?.serverId ?? null;
   }
 
+  /** Whether a server other than `serverId` registers `channelId`. */
+  private registeredByAnotherServer(serverId: string, channelId: string): boolean {
+    for (const entry of this.channels.values()) {
+      if (entry.descriptor.id === channelId && entry.serverId !== serverId) return true;
+    }
+    return false;
+  }
+
   /**
    * Find a channel entry by channelId (searches across all servers).
    * Returns the first match.
@@ -3488,8 +3530,11 @@ export class ChannelRegistry {
     inferenceId: string,
     index: number,
     delta: string,
+    /** The server the channel resolves with, as the speech's locus does
+     *  (deliverSpeech's locusServerId). */
+    serverId?: string,
   ): void {
-    const server = this.streamingServerFor(channelId);
+    const server = this.streamingServerFor(channelId, serverId);
     if (!server) return;
     try {
       server.sendChannelsOutgoingChunk({ inferenceId, conversationId, channelId, index, delta });
@@ -3502,8 +3547,10 @@ export class ChannelRegistry {
     conversationId: string,
     inferenceId: string,
     text: string,
+    /** As sendOutgoingChunk's. */
+    serverId?: string,
   ): void {
-    const server = this.streamingServerFor(channelId);
+    const server = this.streamingServerFor(channelId, serverId);
     if (!server) return;
     try {
       server.sendChannelsOutgoingComplete({
@@ -3515,14 +3562,18 @@ export class ChannelRegistry {
     } catch { /* observer surface — never disturb the turn */ }
   }
 
-  private streamingServerFor(channelId: string) {
+  private streamingServerFor(channelId: string, serverId?: string) {
     // 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.
+    // bare descriptor ids (what resolveProseTarget returns). With the server
+    // the speech resolves with, only that server's entry; otherwise 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;
-    const server = this.serverRegistry.getServer(matches[0]!.serverId);
+    const entry = serverId !== undefined
+      ? matches.find((e) => e.serverId === serverId)
+      : matches.length === 1 ? matches[0] : undefined;
+    if (!entry) return null;
+    const server = this.serverRegistry.getServer(entry.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
@@ -3762,8 +3813,13 @@ export class ChannelRegistry {
     locusChannelId: string | null,
     /** `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?: { heldOnFailure?: boolean },
+     *  An `unknown` outcome still gets its marker. `locusServerId`: the
+     *  server the locus resolves with, snapshotted by the caller with the
+     *  locus: the server whose message triggered the turn, where the locus is
+     *  that message's channel. The speech goes out through that server only,
+     *  and fails where it no longer registers the channel. Without it, the
+     *  locus is taken only where exactly one server registers it. */
+    opts?: { heldOnFailure?: boolean; locusServerId?: string },
   ): Promise<PublishOutcome> {
     const fail = (channelId: string | null, reason: string, outcome: PublishOutcome): PublishOutcome => {
       const status = outcome.status === 'unknown' ? 'unknown' : 'failed';
@@ -3806,7 +3862,11 @@ export class ChannelRegistry {
       return fail(null, reason, { status: 'failed', reason, at: Date.now() });
     }
 
-    const outcome = await this.publish(conversationId, text, { channelId: locusChannelId, routed: true });
+    const outcome = await this.publish(conversationId, text, {
+      ...(opts?.locusServerId !== undefined ? { serverId: opts.locusServerId } : {}),
+      channelId: locusChannelId,
+      routed: true,
+    });
     const channelId = outcome.destination?.channelId ?? locusChannelId;
     if (outcome.status !== 'delivered') {
       return fail(channelId, outcome.reason ?? 'delivery not confirmed', outcome);
@@ -3829,13 +3889,16 @@ export class ChannelRegistry {
     return outcome;
   }
 
-  /** deliverSpeech, reduced to the confirmed delivery (null when there was none). */
+  /** deliverSpeech, reduced to the confirmed delivery (null when there was
+   *  none). `opts.locusServerId` is deliverSpeech's. */
   async routeSpeech(
     conversationId: string,
     text: string,
     locusChannelId: string | null,
+    opts?: { locusServerId?: string },
   ): Promise<{ delivered: boolean; channelId: string; messageId?: string } | null> {
-    const outcome = await this.deliverSpeech(conversationId, text, locusChannelId);
+    const outcome = await this.deliverSpeech(conversationId, text, locusChannelId,
+      opts?.locusServerId !== undefined ? { locusServerId: opts.locusServerId } : undefined);
     if (outcome.status !== 'delivered') return null;
     return {
       delivered: true,
@@ -3845,7 +3908,7 @@ export class ChannelRegistry {
   }
 
   private async handleToolPublish(
-    input: { channelId?: string; content?: string; text?: string },
+    input: { channelId?: string; serverId?: string; content?: string; text?: string },
     origin?: ChannelToolOrigin,
   ): Promise<ToolResult> {
     // Resolve content: accept both `content` and `text` (backward compat)
@@ -3873,11 +3936,30 @@ export class ChannelRegistry {
       };
     }
 
-    const entry = this.findChannelEntry(channelId);
+    // A serverId the call gives names the exact pair, as the other channel
+    // tools read theirs (this tool's schema doesn't declare one); with no
+    // channelId, it's the default channel on that server. A call naming no
+    // server takes the calling turn's server for its trigger's or locus's
+    // channel; else, for the default channel, the server whose accepted
+    // message set it; else a channelId only where exactly one server
+    // registers it.
+    const serverId = input.serverId;
+    const trigger = !serverId && origin?.kind === 'agent'
+      ? [origin.trigger, origin.locus].find((o) => o?.channelId === channelId)
+      : undefined;
+    const defaultServer = !serverId && trigger === undefined && input.channelId === undefined
+      ? this.fallbackServerFor(channelId)
+      : undefined;
+    const resolved = this.resolveToolChannelEntry(channelId, serverId || (trigger?.serverId ?? defaultServer));
+    const entry = resolved.entry;
     if (!entry) {
       return {
         success: false,
-        error: `Channel not found: ${channelId}`,
+        error: trigger !== undefined
+          ? `Channel ${channelId} is no longer registered by the server whose message brought you there, so nothing was published.`
+          : defaultServer !== undefined
+            ? `Channel ${channelId}, which this call took as its default, is no longer registered by the server whose message set that default, so nothing was published.`
+            : resolved.error!,
         isError: true,
       };
     }

package/src/mcpl/conversation-router.ts

@@ -108,6 +108,10 @@ export interface ConversationRouterConfig {
 
 export interface ConversationBinding {
   channelId: string;
+  /** The channel's MCPL server, where the binding was made with one: channel
+   *  ids are unique only within one server's connection (MCPL §14.2), so each
+   *  server's channel has its own binding. */
+  serverId?: string;
   agentName: string;
   /** Engagement counter per channel — fresh forks get a new generation. */
   generation: number;
@@ -157,11 +161,15 @@ export const DEFAULT_CLOSURE_PROMPT =
 export class ConversationRouter {
   private config: ConversationRouterConfig;
 
-  /** Active bindings, keyed by channelId. */
+  /** Active bindings, keyed by the channel's server and id (bindingKey):
+   *  two servers' channels with one id are two conversations. */
   private bindings = new Map<string, ConversationBinding>();
 
-  /** Engagement counter per channel — survives unbind, so a re-bound channel
-   * gets a distinct fork agent name. */
+  /** Engagement counter per channel id — survives unbind, so a re-bound
+   * channel gets a distinct fork agent name. Kept by bare id, as it's
+   * persisted: two servers sharing an id share a counter, which still never
+   * repeats a name, and their forks' names differ anyway, since each hashes
+   * its server (forkAgentName). */
   private generations = new Map<string, number>();
 
   constructor(config: ConversationRouterConfig) {
@@ -191,7 +199,7 @@ export class ConversationRouter {
    * unchanged; a failed spawn doesn't leave a dangling route.
    */
   route(facts: IncomingMessageFacts): RoutingDecision {
-    const existing = this.bindings.get(facts.channelId);
+    const existing = this.bindings.get(bindingKey(facts));
 
     if (existing) {
       return {
@@ -223,33 +231,57 @@ export class ConversationRouter {
    * Record a binding after the framework successfully spawned the fork.
    * Returns the new binding.
    */
-  bind(channelId: string, agentName: string, generation: number, now = Date.now()): ConversationBinding {
-    this.generations.set(channelId, generation);
+  bind(channel: string | ConversationChannel, agentName: string, generation: number, now = Date.now()): ConversationBinding {
+    const { channelId, serverId } = asChannel(channel);
+    // The counter is kept by bare id, and two servers' spawns on one id can
+    // run beside each other, so a bind can finish after a later spawn's: the
+    // counter keeps the higher, or the next spawn would propose a fork name
+    // already used.
+    this.generations.set(channelId, Math.max(this.generations.get(channelId) ?? 0, generation));
     const binding: ConversationBinding = {
       channelId,
+      ...(serverId !== undefined ? { serverId } : {}),
       agentName,
       generation,
       boundAt: now,
       lastActivity: now,
     };
-    this.bindings.set(channelId, binding);
+    this.bindings.set(bindingKey({ channelId, serverId }), binding);
     return binding;
   }
 
   /** Record delivered activity on an existing binding. Does not bind a
    * channel or advance its generation. Call after successful delivery, not
    * when previewing a route. The optional clock supports deterministic use. */
-  touch(channelId: string, now = Date.now()): void {
-    const binding = this.bindings.get(channelId);
-    if (binding) binding.lastActivity = now;
+  touch(channel: string | ConversationChannel, now = Date.now()): void {
+    const found = this.findBinding(channel);
+    if (found) found[1].lastActivity = now;
+  }
+
+  unbind(channel: string | ConversationChannel): void {
+    const found = this.findBinding(channel);
+    if (found) this.bindings.delete(found[0]);
   }
 
-  unbind(channelId: string): void {
-    this.bindings.delete(channelId);
+  getBinding(channel: string | ConversationChannel): ConversationBinding | undefined {
+    return this.findBinding(channel)?.[1];
   }
 
-  getBinding(channelId: string): ConversationBinding | undefined {
-    return this.bindings.get(channelId);
+  /**
+   * The binding a caller names, with its key. A channel given with its server
+   * names that server's binding only. A bare id, as callers gave it before
+   * bindings had servers, names the binding made with no server, else the one
+   * binding for that id; where several servers' channels with that id are
+   * bound, it names none.
+   */
+  private findBinding(channel: string | ConversationChannel): [string, ConversationBinding] | undefined {
+    const named = asChannel(channel);
+    const key = bindingKey(named);
+    const exact = this.bindings.get(key);
+    if (exact) return [key, exact];
+    if (named.serverId !== undefined) return undefined;
+    const matches = [...this.bindings.entries()].filter(([, b]) => b.channelId === named.channelId);
+    return matches.length === 1 ? matches[0] : undefined;
   }
 
   /** Reverse lookup: the channel an agent is bound to, if any. */
@@ -317,6 +349,25 @@ export class ConversationRouter {
   }
 }
 
+/**
+ * A channel as the router's bindings take it: its id, with the MCPL server it
+ * belongs to where the caller has one. A bare id, as callers gave it before,
+ * is the channel with no server.
+ */
+export interface ConversationChannel {
+  channelId: string;
+  serverId?: string;
+}
+
+function asChannel(channel: string | ConversationChannel): ConversationChannel {
+  return typeof channel === 'string' ? { channelId: channel } : channel;
+}
+
+/** A binding's key: its channel's server and id, unambiguous whatever either holds. */
+function bindingKey(channel: ConversationChannel): string {
+  return JSON.stringify([channel.serverId ?? null, channel.channelId]);
+}
+
 /** The readable part of a fork's name stops here: uniqueness rides on the hash. */
 const FORK_NAME_READABLE_MAX = 64;
 

package/src/mcpl/push-handler.ts

@@ -22,6 +22,7 @@ import type { InboundSource } from './inbound-source.js';
 import { isSilentHeartbeatMarker, isVisiblyEmptyConversion } from './visible-content.js';
 import { logDetail, logValue } from './log-value.js';
 import { RefusalLines } from './refusal-lines.js';
+import { channelNotPermitted } from './errors.js';
 
 // ============================================================================
 // McplPushEvent (the ProcessEvent shape pushed to the queue)
@@ -109,8 +110,9 @@ export class PushHandler {
   private emitTraceFn: (event: { type: string; [key: string]: unknown }) => void;
   private shouldTriggerInference?: (content: string, metadata: Record<string, unknown>) => boolean;
   private dedup = new DedupSet(1000);
-  /** Holds back repeats of the line for a channel-scoped push refused because
-   *  its channel isn't declared (-32023) or may not be used (-32017). */
+  /** Holds back repeats of the line for a push refused for its channel: a
+   *  channel-scoped one whose channel isn't declared (-32023) or may not be
+   *  used (-32017), and one naming a channel another server registers. */
   private channelRefusalLines = new RefusalLines();
 
   constructor(
@@ -123,6 +125,9 @@ export class PushHandler {
      *  or acknowledged: return its source envelope, frozen now
      *  (mcpl/inbound-source.ts). Coalesced work is stamped by its own path. */
     private readonly acceptInbound?: (event: McplPushEvent) => InboundSource | undefined,
+    /** The channel a push names, and the server that registers it, when
+     *  another server registers that channel id and this server doesn't. */
+    private readonly channelOfAnotherServer?: (serverId: string, params: PushEventParams) => { channelId: string; holder: string } | undefined,
   ) {
     this.featureSetManager = featureSetManager;
     this.pushEventFn = pushEventFn;
@@ -135,6 +140,7 @@ export class PushHandler {
    *
    * 1. Validate feature set
    * 2. Convert content blocks; reject visibly-empty content
+   *    Refuse a push naming a channel another server registers
    * 3. Deduplicate by eventId
    * 4. Optionally check shouldTriggerInference callback
    * 5. Push event to queue
@@ -208,6 +214,18 @@ export class PushHandler {
       return;
     }
 
+    // A push is its own server's event, and the agent's reply to it goes to
+    // the channel the push names. A channel's id is the agent's locus, so a
+    // push naming a channel another server registers, which this server
+    // doesn't, would have the reply sent through that other server. It's
+    // refused, before dedup, so a retry once this server registers the
+    // channel isn't refused as a duplicate.
+    const elsewhere = this.channelOfAnotherServer?.(serverId, params);
+    if (elsewhere) {
+      this.refuseChannelOfAnotherServer(serverId, params, elsewhere, responder);
+      return;
+    }
+
     // 3. Deduplicate by eventId. A coalesced occurrence is deduplicated by the
     // coalescer's receipts instead (RFC-006 §3.1: a retry within the window
     // gets its original result, which this set could not return).
@@ -335,6 +353,38 @@ export class PushHandler {
     });
   }
 
+  /** A push naming a channel another server registers: refused with -32017.
+   *  The operator's line names the server that registers it; the answer to
+   *  the pushing server doesn't. The line prints at most once a minute per
+   *  channel, as the other channel refusals' do, and every refusal is traced. */
+  private refuseChannelOfAnotherServer(
+    serverId: string,
+    params: PushEventParams,
+    elsewhere: { channelId: string; holder: string },
+    responder: Responder | undefined,
+  ): void {
+    const held = this.channelRefusalLines.admit(serverId, elsewhere.channelId);
+    if (held !== null) {
+      console.error(
+        `[push-event-rejected] server=${serverId} featureSet=${logValue(params.featureSet ?? '')} eventId=${logValue(params.eventId ?? '')} ` +
+        `channel=${logValue(elsewhere.channelId)} reason=channel-of-another-server: registered by server ${logValue(elsewhere.holder)}, not this one` +
+        (held ? ` (${held} more since the last line)` : ''),
+      );
+    }
+    this.emitTraceFn({
+      type: 'mcpl:push-event-rejected',
+      serverId,
+      eventId: typeof params.eventId === 'string' ? params.eventId : '',
+      featureSet: params.featureSet,
+      reason: 'channel-of-another-server',
+      channelId: elsewhere.channelId,
+      detail: `registered by server ${elsewhere.holder}`,
+    });
+    const error = channelNotPermitted(elsewhere.channelId);
+    if (responder?.respondError) responder.respondError(error.code, error.message, error.data);
+    else responder?.respond({ accepted: false, reason: error.message });
+  }
+
   /** Loud, like every other push rejection: the producer's wake went nowhere.
    *  A missing eventId prints as `""` and traces as `''`, as on every push line. */
   private traceEmptyRejection(serverId: string, params: PushEventParams): void {

package/src/types/agent.ts

@@ -386,6 +386,12 @@ export interface InferenceRequest {
    * ephemeral run's (a subagent's), which takes no global fallback.
    */
   channelId?: string;
+  /**
+   * Host-owned: the MCPL server whose message set `channelId`. A turn's
+   * replies to that channel go out through this server only. Unset where the
+   * wake's channel came from no one server's message.
+   */
+  serverId?: string;
   /**
    * True when the triggering message explicitly addressed the agent (mention,
    * reply-to-bot, DM — `chat:addressed` in MCPL RFC-001 terms). When a wake