@animalabs/agent-framework 0.28.0 → 0.29.0

package/src/line-reader.ts

@@ -0,0 +1,58 @@
+import type { Readable } from 'node:stream';
+import { StringDecoder } from 'node:string_decoder';
+
+const LF = 0x0a;
+const CR = 0x0d;
+
+export function readLines(input: Readable, onLine: (line: string) => void, onEnd?: () => void): () => void {
+  const decoder = new StringDecoder('utf8');
+  let partial = '';
+  let lineEndedAtCr = false;
+  let stopped = false;
+
+  const take = (text: string) => {
+    let from = 0;
+    if (lineEndedAtCr && text.length > 0) {
+      lineEndedAtCr = false;
+      if (text.charCodeAt(0) === LF) from = 1;
+    }
+    for (let i = from; i < text.length && !stopped; i++) {
+      const code = text.charCodeAt(i);
+      if (code !== LF && code !== CR) continue;
+      const line = partial + text.slice(from, i);
+      partial = '';
+      if (code === CR) {
+        if (i + 1 === text.length) lineEndedAtCr = true;
+        else if (text.charCodeAt(i + 1) === LF) i++;
+      }
+      from = i + 1;
+      onLine(line);
+    }
+    if (!stopped) partial += text.slice(from);
+  };
+
+  const onData = (chunk: Buffer | string) => take(decoder.write(chunk));
+  const onStreamEnd = () => {
+    take(decoder.end());
+    if (!stopped && partial.length > 0) {
+      const last = partial;
+      partial = '';
+      onLine(last);
+    }
+    if (stopped) return;
+    stop();
+    onEnd?.();
+  };
+  const stop = () => {
+    stopped = true;
+    input.off('data', onData);
+    input.off('end', onStreamEnd);
+  };
+  input.on('data', onData);
+  input.on('end', onStreamEnd);
+  return stop;
+}
+
+export function escapeLineSeparators(json: string): string {
+  return json.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
+}

package/src/mcpl/channel-registry.ts

@@ -13,8 +13,10 @@
  * - Build channel context for beforeInference params
  */
 
+import { NOTICE_TAG } from '../notice-tags.js';
 import type { ContentBlock } from '@animalabs/membrane';
-import { convertBlock } from './convert-block.js';
+import { convertBlocks } from './convert-block.js';
+import { cutToFit, markedText, markNoticeOpenings, nameToTypeBack, quotedValue, showsAsItself, suppliedValue } from '../supplied-text.js';
 import type { JsStore } from '@animalabs/chronicle';
 import { isDeepStrictEqual } from 'node:util';
 import { ensureStateRegistered } from '../module-registry.js';
@@ -45,7 +47,7 @@ import { RefusalLines } from './refusal-lines.js';
 import { CapabilityGrant } from './capability-grant.js';
 import type { InboundSource } from './inbound-source.js';
 import { McplRequestError, type McplServerConnection } from './server-connection.js';
-import { readSkipReplyWake } from './skip-reply-wake.js';
+import { readSkipReplyWake, skipReplyNote, type SkipReplyEarlierWake } from './skip-reply-wake.js';
 import { isProseTargetToken } from './prose-grammar.js';
 
 // ============================================================================
@@ -643,19 +645,21 @@ const CHANNEL_TOOL_DEFINITIONS: ToolDefinition[] = [
 // Constructor Options
 // ============================================================================
 
-/** Bound connector values for notices, logs and an outcome's reason. A
- *  PublishOutcome keeps the connector's structured data (`detail`) as the
- *  connection gives it, its strings redacted (redactedData). */
+/** Bound connector values for notices, logs and an outcome's reason, on one
+ *  line with their notice openings marked (suppliedValue). A PublishOutcome
+ *  keeps the connector's structured data (`detail`) as the connection gives
+ *  it, its strings redacted (redactedData). */
 export function connectorText(value: unknown): string {
   let text: string;
   try {
     text = typeof value === 'string' ? value : JSON.stringify(value) ?? String(value);
   } catch {
-    return '[unserializable connector value]';
+    return `[${NOTICE_TAG.unserializableConnectorValue}]`;
   }
   const limit = 2000;
-  const suffix = '… [truncated]';
-  return text.length > limit ? text.slice(0, limit - suffix.length) + suffix : text;
+  const suffix = `… [${NOTICE_TAG.truncated}]`;
+  const shown = suppliedValue(text);
+  return shown.length > limit ? cutToFit(shown, limit - suffix.length) + suffix : shown;
 }
 
 /**
@@ -688,6 +692,9 @@ export function sameChannel(a: ChannelRef | null | undefined, b: ChannelRef | nu
   return a.serverId === b.serverId && a.channelId === b.channelId;
 }
 
+export const NO_CHANNEL_EXAMPLE = '#<channel>';
+export const NO_PERSON_EXAMPLE = '@<person>';
+
 /**
  * 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
@@ -699,12 +706,32 @@ export function qualifiedChannelName(ref: ChannelRef): string {
   return `${ref.serverId}:${ref.channelId}`;
 }
 
+function markedHistory(history: readonly unknown[]): unknown[] {
+  return history.map((item) => {
+    if (item === null || typeof item !== 'object' || Array.isArray(item) || !('content' in item)) return item;
+    const { content } = item as { content: unknown };
+    if (Array.isArray(content)) return { ...item, content: markNoticeOpenings(content.map(withEmbeddedTextMarked) as object[]) };
+    return typeof content === 'string' ? { ...item, content: markedText(content) } : item;
+  });
+}
+
+function withEmbeddedTextMarked(block: unknown): unknown {
+  if (block === null || typeof block !== 'object' || (block as { type?: unknown }).type !== 'resource') return block;
+  const { resource } = block as { resource?: unknown };
+  if (resource === null || typeof resource !== 'object' || typeof (resource as { text?: unknown }).text !== 'string') return block;
+  return { ...block, resource: { ...resource, text: markedText((resource as { text: string }).text) } };
+}
+
 /** 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. */
+ *  alone or whose name wouldn't show as itself: `"b:room" on server "a"`,
+ *  each a JSON literal a channel tool's channelId and serverId take back
+ *  (quotedValue). No input takes the whole form for a name. */
 function channelOnServer(ref: ChannelRef): string {
-  return `${JSON.stringify(ref.channelId)} on server ${JSON.stringify(ref.serverId)}`;
+  return `${quotedValue(ref.channelId)} on server ${quotedValue(ref.serverId)}`;
 }
 
+const CHANNEL_ON_SERVER_AT_END = /("(?:[^"\\]|\\.)*") on server ("(?:[^"\\]|\\.)*")$/;
+
 /**
  * What one channels/publish attempt established (ChannelRegistry.publish).
  * - `delivered`: the connector returned `delivered: true`. A historical
@@ -1089,6 +1116,10 @@ export type ChannelToolOrigin =
      *  name one of them answers to by its id means that channel
      *  (ChannelRegistry.ownChannelNamed). */
     own?: readonly ChannelRef[];
+    /** For a skip_reply whose self-wake the framework armed: the heartbeat's
+     *  wake due before it, when there is one, which its confirmation names
+     *  (skipReplyNote). */
+    earlierWake?: SkipReplyEarlierWake;
   };
 
 /** The machine decision sources a module-origin channel_close may record.
@@ -1894,7 +1925,7 @@ export class ChannelRegistry {
         }
       }
       if (message.tags) message.tags = expandCoreTags(message.tags);
-      const convertedContent: ContentBlock[] = message.content.map((block) => convertBlock(block, 'attachment on channel message', serverId));
+      const convertedContent: ContentBlock[] = convertBlocks(message.content, 'attachment on channel message', serverId);
       if (!emptyAllowed && isVisiblyEmptyConversion(message.content, convertedContent)) {
         rejectEmpty();
         continue;
@@ -2386,7 +2417,10 @@ export class ChannelRegistry {
         return this.handleToolJournal(input as { content?: string });
 
       case 'skip_reply':
-        return this.handleToolSkipReply(input as { reason?: string; wake_in_seconds?: unknown });
+        return this.handleToolSkipReply(
+          input as { reason?: string; wake_in_seconds?: unknown },
+          origin?.kind === 'agent' ? origin.earlierWake : undefined,
+        );
 
       default:
         // Not every agent is given every channel tool, so the refusal points
@@ -2442,7 +2476,8 @@ export class ChannelRegistry {
     // declared it inbound-only, since speech isn't posted there): a conversation
     // fork's home channel, else this turn's channel (single trunk agent — item-3
     // redux: its locus, else its triggering channel), else the global default
-    // (heartbeats). Without this, a fork
+    // (a no-trigger turn's, but not a heartbeat's, whose turn takes none).
+    // Without this, a fork
     // was advertised the global locus but published somewhere else; and a trunk
     // agent was told the wrong channel under concurrency.
     // Each lookup is keyed on whether a name was given, not its truthiness:
@@ -3921,12 +3956,20 @@ export class ChannelRegistry {
    * 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.
+   * A name that wouldn't show as itself (showsAsItself: one holding a line
+   * break, a notice opening, a quote, a backslash or a lone surrogate, or
+   * whitespace at its edges) is shown by its id and its server too, which
+   * the channel tools take exactly and the prose resolver doesn't, so no name
+   * shown can be another channel's.
    */
   nameShown(ref: ChannelRef): string {
     const entry = this.entryAt(ref);
-    if (entry) return this.nameFor(entry) ?? channelOnServer(ref);
+    if (entry) {
+      const name = this.nameFor(entry);
+      return name !== undefined && showsAsItself(name) ? name : channelOnServer(ref);
+    }
     for (const name of [ref.channelId, qualifiedChannelName(ref)]) {
-      if (this.entriesNamed(name).length === 0 && !('channelId' in this.resolveProseTarget(name))) return name;
+      if (showsAsItself(name) && this.entriesNamed(name).length === 0 && !('channelId' in this.resolveProseTarget(name))) return name;
     }
     return channelOnServer(ref);
   }
@@ -3966,7 +4009,7 @@ export class ChannelRegistry {
   private tuneOutEndText(entry: ChannelEntry, tool?: string): string {
     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 ` +
+      ? `Call tune_out with channelId ${quotedValue(this.nameFor(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.' +
@@ -3979,7 +4022,7 @@ export class ChannelRegistry {
    */
   quotedShown(ref: ChannelRef): string {
     const shown = this.nameShown(ref);
-    return shown === channelOnServer(ref) ? shown : JSON.stringify(shown);
+    return shown === channelOnServer(ref) ? shown : quotedValue(shown);
   }
 
   /**
@@ -4017,7 +4060,7 @@ export class ChannelRegistry {
     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 listed = names.map((n) => quotedValue(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.
@@ -4038,8 +4081,8 @@ export class ChannelRegistry {
       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)}.`;
+        ? `- ${where}: call again with channelId ${quotedValue(own)}.`
+        : `- ${where}: call again with channelId ${quotedValue(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')}`;
@@ -4078,7 +4121,7 @@ export class ChannelRegistry {
       // 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 `
+      const names = `${JSON.stringify(channelId)} alone names channel ${quotedValue(one.descriptor.id)} on server `
         + JSON.stringify(one.serverId);
       return takesServerId ? `${names}: for that one, call again with serverId left out.` : `${names}.`;
     }
@@ -4090,7 +4133,7 @@ export class ChannelRegistry {
       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 name === undefined ? `${at} (no channelId reaches it alone)` : `${at} as ${quotedValue(name)}`;
       });
       return `It's ${places.length === 1 ? places[0] : `${places.slice(0, -1).join(', ')} and ${places.at(-1)}`}.`;
     }
@@ -4394,17 +4437,19 @@ export class ChannelRegistry {
     spec: string,
     opts?: { forSpeech?: boolean; own?: readonly ChannelRef[] },
   ): PublishDestination | { error: string; candidates?: string[]; refusedChannelId?: string } {
-    const own = this.ownChannelNamed(spec.trim(), opts?.own);
+    const name = spec.trim();
+    if (name === NO_CHANNEL_EXAMPLE || name === NO_PERSON_EXAMPLE) return { error: `${name} is the example's placeholder: write the name it stands for in its place` };
+    const own = this.ownChannelNamed(name, opts?.own);
     let resolved: PublishDestination | { error: string; candidates?: string[] };
     if (own === undefined) {
-      resolved = this.resolveTargetByName(spec);
+      resolved = this.resolveTargetByName(name);
     } 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) };
+      resolved = { error: `"${name}" is the id of this turn's channels on more than one server`, candidates: this.ownCandidates(own.neither).map((c) => c.prose) };
     } 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` };
+        : { error: `${this.ownChannelGoneText(name, 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.entryAt(resolved);
@@ -4463,7 +4508,7 @@ export class ChannelRegistry {
     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 { error: this.ownNeitherRefusal(name, mine.neither, done, false) };
     }
     return this.entryAt(mine.channel) ? { channel: mine.channel } : { error: this.ownChannelGoneRefusal(name, mine.channel, tool) };
   }
@@ -4482,32 +4527,73 @@ export class ChannelRegistry {
   /**
    * 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.
+   * name, where that picks it alone, since its id is the name refused. `text`
+   * is that name, which a refusal writes as JSON; `prose`, which a `>>`
+   * target reads, is that name where it shows as itself, else its id and
+   * server. One no string picks alone, and one its server no longer
+   * registers, are named by id and server in both, saying so. `reaches` says
+   * which a name reaches.
    */
-  private ownCandidates(channels: readonly ChannelRef[]): Array<{ text: string; reaches: boolean }> {
+  private ownCandidates(channels: readonly ChannelRef[]): Array<{ text: string; prose: string; reaches: boolean; byServer: boolean }> {
     return channels.map((c) => {
       const entry = this.entryAt(c);
-      if (!entry) return { text: `${channelOnServer(c)} (its server no longer registers it)`, reaches: false };
+      if (!entry) {
+        const text = `${channelOnServer(c)} (its server no longer registers it)`;
+        return { text, prose: text, reaches: false, byServer: 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 };
+      if (picked.length !== 1 || picked[0] !== entry) {
+        const text = `${channelOnServer(c)} (no channelId reaches it alone)`;
+        return { text, prose: text, reaches: false, byServer: true };
+      }
+      return { text: qualified, prose: showsAsItself(qualified) ? qualified : channelOnServer(c), reaches: true, byServer: false };
     });
   }
 
+  /**
+   * What a refusal listing these candidates says of each one that is a
+   * channel shown by its id and server: the channelId channel_publish reaches
+   * it by, or that no channelId reaches it alone. That is its server-qualified
+   * name where that picks it alone, since a bare id is what a turn's own
+   * channels answer to first, whether or not their server still registers
+   * them (ownChannelNamed), and else its id where that picks it alone and
+   * isn't empty (channel_publish refuses an empty one). It leaves out a channel no
+   * longer registered and a candidate that already says no channelId reaches
+   * it alone, and is empty when nothing is left.
+   */
+  publishRouteFor(candidates: readonly string[]): string {
+    const parts = new Set<string>();
+    for (const candidate of candidates) {
+      const shown = CHANNEL_ON_SERVER_AT_END.exec(candidate);
+      if (!shown) continue;
+      const ref: ChannelRef = { channelId: JSON.parse(shown[1]!) as string, serverId: JSON.parse(shown[2]!) as string };
+      const entry = this.entryAt(ref);
+      if (!entry) continue;
+      const name = [qualifiedChannelName(ref), ref.channelId].find((n) => {
+        const named = n === '' ? [] : this.entriesNamed(n);
+        return named.length === 1 && named[0] === entry;
+      });
+      parts.add(name !== undefined
+        ? `channel_publish reaches ${channelOnServer(ref)} with channelId ${quotedValue(name)}`
+        : `no channelId reaches ${channelOnServer(ref)} alone`);
+    }
+    return parts.size ? ` For a channel shown by its id and server: ${[...parts].join('; ')}.` : '';
+  }
+
   /** A tool's refusal of a name the turn's channels on more than one server
    *  answer to by their id (ownChannelNamed's neither). */
-  private ownNeitherRefusal(name: string, channels: readonly ChannelRef[], done: string): string {
+  private ownNeitherRefusal(name: string, channels: readonly ChannelRef[], done: string, takesServer = true): string {
     const candidates = this.ownCandidates(channels);
-    const named = candidates.filter((c) => c.reaches).map((c) => JSON.stringify(c.text));
+    const named = candidates.filter((c) => c.reaches).map((c) => quotedValue(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}`;
+    const listed = candidates.map((c) => (c.reaches ? quotedValue(c.text) : c.text)).join(', ');
+    const byServer = takesServer && candidates.some((c) => c.byServer)
+      ? ' For a channel shown by its id and server, call again with that channelId and that serverId.'
+      : '';
+    return `"${name}" is the id of this turn's channels on more than one server (${listed}), so nothing ${done}.${pick}${byServer}`;
   }
 
   private resolveTargetByName(
@@ -4521,7 +4607,7 @@ export class ChannelRegistry {
     // 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: ChannelEntry): string => this.nameFor(e) ?? channelOnServer(refOf(e));
+    const token = (e: ChannelEntry): string => this.nameShown(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
@@ -4537,7 +4623,7 @@ export class ChannelRegistry {
     };
     const dmShown = (list: ChannelEntry[]): string[] => list.map((e) => {
       const label = e.descriptor.label ?? e.descriptor.id;
-      return labelPicks(e, label) ? label : token(e);
+      return showsAsItself(label) && labelPicks(e, label) ? label : token(e);
     });
 
     // A channel id, or its server-qualified name (entriesNamed).
@@ -4655,7 +4741,7 @@ export class ChannelRegistry {
     if (byName.length > 1) {
       return {
         error: `"${trimmed}" matches several channels`,
-        candidates: byName.map((e) => `${e.descriptor.label} = ${token(e)}`),
+        candidates: byName.map((e) => `${nameToTypeBack(e.descriptor.label ?? '')} = ${token(e)}`),
       };
     }
 
@@ -4664,7 +4750,7 @@ export class ChannelRegistry {
     const near = entries
       .filter((e) => norm(e.descriptor.label ?? '').includes(norm(trimmed)))
       .slice(0, 5)
-      .map((e) => `${e.descriptor.label} = ${token(e)}`);
+      .map((e) => `${nameToTypeBack(e.descriptor.label ?? '')} = ${token(e)}`);
     return { error: `no channel matches "${trimmed}"`, ...(near.length ? { candidates: near } : {}) };
   }
 
@@ -4701,7 +4787,7 @@ export class ChannelRegistry {
       qualifiedChannelName(ref),
     ];
     for (const c of candidates) {
-      if (!isProseTargetToken(c) || c === '#') continue;
+      if (!isProseTargetToken(c) || c === '#' || !showsAsItself(c)) continue;
       const r = this.resolveProseTarget(c, { forSpeech: true });
       if ('channelId' in r && sameChannel(r, ref)) return c;
     }
@@ -4990,7 +5076,7 @@ export class ChannelRegistry {
           channelId: input.channelId,
           serverId: entry.serverId,
           status: alreadyDesiredOpen ? 'reconciled' : 'opened',
-          ...(result.history ? { history: result.history } : {}),
+          ...(result.history ? { history: markedHistory(result.history) } : {}),
           ...(result.historyTruncated ? { historyTruncated: true } : {}),
         },
       };
@@ -5479,13 +5565,14 @@ export class ChannelRegistry {
    * tool, so any trailing prose this turn is NOT posted. Replaces the old
    * overloaded use of `think` for staying silent.
    */
-  private handleToolSkipReply(input: { reason?: string; wake_in_seconds?: unknown }): ToolResult {
+  private handleToolSkipReply(input: { reason?: string; wake_in_seconds?: unknown }, earlierWake?: SkipReplyEarlierWake): ToolResult {
     // The self-wake itself is armed by the framework (which owns the
     // EventGate) BEFORE its dispatch reaches this handler, from the same
     // reading, and the framework refuses a wake the host can't set before
     // dispatching. A caller of this registry's handleChannelToolCall
     // (AgentFramework.channels) goes past both, so its note names a wake
-    // nothing armed.
+    // nothing armed. The framework, which also owns the heartbeat, says
+    // which of its wakes is due before the self-wake (`earlierWake`).
     const wake = readSkipReplyWake(input);
     const selfWake = wake.kind === 'wake' ? wake.seconds : undefined;
     return {
@@ -5501,9 +5588,7 @@ export class ChannelRegistry {
       // on Fable: ~60% of skip_reply result bytes were verbatim input echo).
       data: {
         skipped: true,
-        note: selfWake !== undefined
-          ? `Turn ended; nothing sent. Self-wake in ~${selfWake}s unless something wakes you first.`
-          : 'Turn ended; nothing sent.',
+        note: skipReplyNote(selfWake, selfWake !== undefined ? earlierWake : undefined),
       },
     };
   }
@@ -6096,7 +6181,7 @@ export class ChannelRegistry {
       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 };
+      return { success: false, error: this.ownNeitherRefusal(input.channelId, own.neither, 'was posted', false), isError: true };
     } else if (own) {
       entry = this.entryAt(own.channel);
       if (!entry) {
@@ -6127,7 +6212,7 @@ export class ChannelRegistry {
         // 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.`
+            ? `Server "${input.serverId}" has no channel ${quotedValue(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

package/src/mcpl/conversation-router.ts

@@ -34,6 +34,7 @@
  * follow-up.
  */
 
+import { NOTICE_TAG } from '../notice-tags.js';
 import { createHash } from 'node:crypto';
 import type { ContextStrategy } from '@animalabs/context-manager';
 import type { ChannelDescriptor } from './types.js';
@@ -144,7 +145,7 @@ export type RoutingDecision =
 const DEFAULT_IDLE_TTL_MS = 12 * 60 * 60 * 1000;
 
 export const DEFAULT_CLOSURE_PROMPT =
-  '[system] This engagement is closing due to inactivity. Finalize your ' +
+  `[${NOTICE_TAG.system}] This engagement is closing due to inactivity. Finalize your ` +
   'work: post any promised results to the channel and record outstanding ' +
   'threads as unresolved. Do not ask follow-up questions.';
 

package/src/mcpl/convert-block.ts

@@ -4,6 +4,7 @@
  * about a malformed block holds on all three.
  */
 
+import { NOTICE_TAG } from '../notice-tags.js';
 import type { ContentBlock } from '@animalabs/membrane';
 import {
   AUDIO_NO_DATA_TEXT,
@@ -18,6 +19,7 @@ import {
 } from './references.js';
 import { NON_STRING_TEXT_PLACEHOLDER } from './visible-content.js';
 import type { McplContentBlock } from './types.js';
+import { markNoticeOpenings } from '../supplied-text.js';
 
 /**
  * Convert a single MCPL wire-format content block to a membrane ContentBlock.
@@ -50,7 +52,7 @@ export function convertBlock(block: McplContentBlock, provenance: string, server
         // is a claim, one the reference rejects included, as classifyBlock
         // and isInlineContradiction read it: a falsy one such as 0, false
         // or '' stubs too, rather than sending the URI as the image's source.
-        return { type: 'text', text: referenceStubOrNull(block, provenance, serverId) ?? '[reference]' };
+        return { type: 'text', text: referenceStubOrNull(block, provenance, serverId) ?? `[${NOTICE_TAG.reference}]` };
       }
       if (isFilledString(block.data) && isFilledString(block.mimeType)) {
         return {
@@ -76,7 +78,7 @@ export function convertBlock(block: McplContentBlock, provenance: string, server
         // RFC-005 uri-form media with a disposition claim, a falsy one
         // included, as for an image (above): stub, do not hand the URI to
         // the provider or inline it.
-        return { type: 'text', text: referenceStubOrNull(block, provenance, serverId) ?? '[reference]' };
+        return { type: 'text', text: referenceStubOrNull(block, provenance, serverId) ?? `[${NOTICE_TAG.reference}]` };
       }
       if (isFilledString(block.data) && isFilledString(block.mimeType)) {
         return {
@@ -95,14 +97,14 @@ export function convertBlock(block: McplContentBlock, provenance: string, server
       }
       // RFC-005: reference blocks become bounded stubs — never raw URIs
       // (a signed URL is a bearer credential that looks like a location).
-      return { type: 'text', text: referenceStubOrNull(block, provenance, serverId) ?? '[reference]' };
+      return { type: 'text', text: referenceStubOrNull(block, provenance, serverId) ?? `[${NOTICE_TAG.reference}]` };
     }
 
     default: {
       // MCP's link to a resource isn't one of MCPL's own blocks, but a server
       // can send one, and RFC-005 §8.1 makes it a reference, shown as one.
       if ((block as { type?: unknown }).type === 'resource_link') {
-        return { type: 'text', text: referenceStubOrNull(block, provenance, serverId) ?? '[reference]' };
+        return { type: 'text', text: referenceStubOrNull(block, provenance, serverId) ?? `[${NOTICE_TAG.reference}]` };
       }
       // Unknown wire block types previously fell off the exhaustive switch
       // and propagated `undefined` into ContentBlock[]. Fail visibly. A type
@@ -113,6 +115,17 @@ export function convertBlock(block: McplContentBlock, provenance: string, server
   }
 }
 
+export function convertBlocks(blocks: readonly McplContentBlock[], provenance: string, serverId: string): ContentBlock[] {
+  const converted = blocks.map((block) => convertBlock(block, provenance, serverId));
+  return markNoticeOpenings(converted, (index) => sendersText(blocks[index]));
+}
+
+function sendersText(block: McplContentBlock | undefined): boolean {
+  if (block?.type === 'text') return typeof block.text === 'string';
+  const c = classifyBlock(block);
+  return c.kind === 'embedded' && c.contents.kind === 'block' && c.contents.block.type === 'text';
+}
+
 /** A string with something in it: the only data, mimeType or uri a block's
  *  source is built from, and the only uri that makes it a reference. Anything
  *  else a sender puts there leaves the block without it, so conversion never

package/src/mcpl/hook-orchestrator.ts

@@ -14,7 +14,8 @@
  */
 
 import type { ContentBlock } from '@animalabs/membrane';
-import { convertBlock } from './convert-block.js';
+import { convertBlocks } from './convert-block.js';
+import { markedText } from '../supplied-text.js';
 import type { ContextInjection } from '@animalabs/context-manager';
 
 import type {
@@ -64,9 +65,9 @@ function withTimeout<T>(promise: Promise<T>, ms: number, label: string): Promise
  */
 function convertContent(content: string | McplContentBlock[], serverId: string): ContentBlock[] {
   if (typeof content === 'string') {
-    return [{ type: 'text', text: content }];
+    return [{ type: 'text', text: markedText(content) }];
   }
-  return content.map((block) => convertBlock(block, 'attachment on context injection', serverId));
+  return convertBlocks(content, 'attachment on context injection', serverId);
 }
 
 /**

package/src/mcpl/inbound-source.ts

@@ -217,7 +217,9 @@ function storedBlock(block: unknown): unknown {
  * The version identity of a delivered body (agreed with the receipts lane,
  * room-220 #46752–#47210): SHA-256 hex of `canonicalJson([blocks])` over the
  * ContentBlock[] the framework stores for the body — after MCPL conversion,
- * before any host decoration is added and before storage shards it — with
+ * which marks the server's text at the framework's notice openings
+ * (supplied-text.ts), before any host decoration is added and before storage
+ * shards it — with
  * each block as the store keeps it, which context-manager's `blockAsStored`
  * gives. So a body hashes alike as delivered, as handed to storage, and as
  * read back unsharded from the store with its blobs resolved, except one