@animalabs/agent-framework 0.28.0 → 0.30.0

package/dist/src/tune-out/coordinator.js

@@ -14,7 +14,10 @@
  * <backscroll> precedent), and `[Tune-out: …]` bracket notices carry
  * lifecycle facts (the [Gate: …] precedent).
  */
+import { NOTICE_TAG } from '../notice-tags.js';
+import { cutToFit, quotedValue, suppliedValue } from '../supplied-text.js';
 import { randomUUID } from 'node:crypto';
+import { authorLine, authorNamed, beginsWithAuthorLine } from '../author-presentation.js';
 import { CapabilityGrant } from '../mcpl/capability-grant.js';
 import { armAfter, armAt } from '../deadline-timer.js';
 /** Defaults for tune_out tool params. */
@@ -26,16 +29,48 @@ export const TUNE_OUT_DEFAULTS = {
 /** Coalescing window for wake invocations: a mention storm becomes one
  *  subconscious turn, and max-wakes counts invocations, not messages. */
 const WAKE_COALESCE_MS = 2_000;
+/**
+ * One backlog line: author, then the message's blocks in order — text as
+ * is, anything else named by kind (`[image]`, `[document]`), so a release
+ * never drops a block silently (#232 gap 4). The author is named once: a
+ * server that renders `Name: body` into the text itself is not doubled.
+ * A name the line adds is a value someone supplied, kept to one line with
+ * its notice openings marked (authorLine), as main's dump writes it.
+ */
+export function renderHeldLine(m) {
+    const author = authorNamed(m.metadata) ?? m.participant;
+    const parts = m.content.map((b) => b.type === 'text' ? b.text : `[${b.type}]`);
+    const line = parts.filter((p) => p.length > 0).join(' ');
+    const firstText = m.content.find((b) => b.type === 'text')?.text;
+    return firstText !== undefined && beginsWithAuthorLine(author, firstText) ? line : authorLine(author, line);
+}
+/** The deferred write a stored row landed from, when it came through the queue. */
+function writeIdOf(m) {
+    const writeId = m.metadata?.deferredWriteId;
+    return typeof writeId === 'string' ? writeId : undefined;
+}
+/**
+ * Whether a held message is one of this channel's: by its channel id, and by
+ * its server where it records one, since two servers can register the same
+ * channel id. A message recording neither is taken as the channel's, as
+ * before servers were recorded.
+ */
+function inChannelOf(serverId, channelId) {
+    return (m) => {
+        const meta = m.metadata;
+        return (meta?.channelId ?? channelId) === channelId && (meta?.serverId ?? serverId) === serverId;
+    };
+}
 /** How long after an end time whose cancel threw the cancel is tried again. */
 const EXPIRY_RETRY_MS = 60_000;
 /** Ends a backlog line cut to fit in one of the residents' messages. */
-const CUT_MARK = " [cut to fit; the whole message is in the channel's history]";
+const CUT_MARK = ` [${NOTICE_TAG.cutToFit}; the whole message is in the channel's history]`;
 /**
  * tune_out's refusal of a channel already tuned out: its settings, then what
  * its transport is now where the repeat tried to open it again (`transport`,
  * from the framework's dispatch), then how to change the settings.
  */
-export function alreadyTunedOutText(shown, p, transport) {
+export function alreadyTunedOutText(quoted, p, transport) {
     // A duration so long its end is past what a Date can hold has no time to show.
     const expires = p.expiresAtMs !== undefined ? new Date(p.expiresAtMs) : undefined;
     const until = expires && Number.isFinite(expires.getTime())
@@ -43,19 +78,12 @@ export function alreadyTunedOutText(shown, p, transport) {
         : '';
     // A thrown error's words may end without a stop.
     const now = transport === undefined ? '' : /[.!?]$/.test(transport) ? `${transport} ` : `${transport}. `;
-    return `Nothing changed${transport !== undefined ? ' in the tune-out' : ''}: ${JSON.stringify(shown)} is already `
+    return `Nothing changed${transport !== undefined ? ' in the tune-out' : ''}: ${quoted} is already `
         + `tuned out, with cadenceSeconds ${p.cadenceSeconds}, backlogCap ${p.backlogCap} and maxWakes ${p.maxWakes}${until}. `
         + now
         + 'To change those, cancel it first with tune_out mode "cancel", which delivers its backlog to you now, then call '
         + 'tune_out again with the new settings.';
 }
-/** The first `length` code units of `text`, one fewer where the last would be
- *  the first half of a surrogate pair. */
-function prefixOf(text, length) {
-    const cut = text.slice(0, Math.max(0, length));
-    const last = cut.charCodeAt(cut.length - 1);
-    return last >= 0xd800 && last <= 0xdbff ? cut.slice(0, -1) : cut;
-}
 /** What a thrown value says, without throwing: an Error's message, or the
  *  value as text, which String() can't give for an object with no prototype. */
 function thrownReason(error) {
@@ -79,8 +107,60 @@ export class TuneOutCoordinator {
     expiryTimers = new Map();
     /** Channels with a wake invocation pending inside the coalescing window. */
     pendingWakes = new Map();
-    /** Diverted-message tallies since the last subconscious invocation, per channel key. */
+    /**
+     * Held messages the channel's reader hasn't looked at, per channel key:
+     * what makes a cadence period worth a look. Counted up as messages are
+     * held and back to zero at each look; rebuilt from the held rows where
+     * memory can't know it (rebuildTally): after a restart, and when a
+     * channel's own tune-out ends while the all-except hold still holds it.
+     * A failed reader fork's messages count again (readerFailed).
+     */
     divertedSinceInvocation = new Map();
+    /**
+     * The persistent subconscious's last look at each held channel, per epoch:
+     * the store's sequence when the look was asked for. Durable, so that after
+     * a restart its next look counts only what was held since (rebuildTally).
+     * Reader forks need none: what they were handed is in memory, and after a
+     * restart the first fork of an epoch is handed all it has held.
+     */
+    lastLooksCache;
+    /**
+     * `reader: 'forks'`: the highest sequence of a held message already
+     * handed to a reader fork, per epoch and channel (handOffKey). Each held
+     * message is delivered to exactly one fork. A channel the all-except hold
+     * holds can be taken by a tune-out of its own and given back, and each
+     * epoch's readers read that epoch's messages, so what one epoch's readers
+     * were handed never moves or clears the other's. In-memory: after a
+     * restart the first fork of an epoch is handed everything the epoch has
+     * held, which is the right side to err on.
+     */
+    readerCursor = new Map();
+    /**
+     * `reader: 'forks'`: the deferred writes handed to a reader fork while
+     * still queued, per epoch and channel. Each lands in the store later as a row
+     * stamped with the same id (`metadata.deferredWriteId`), past the cursor;
+     * that row is not handed again. Cleared with the cursor.
+     */
+    readerHandedWrites = new Map();
+    /**
+     * `reader: 'forks'`: held messages a reader fork was handed but never read,
+     * per epoch and channel: its derive failed, or its run threw before it reported
+     * (readerFailed). The next invocation is handed them again, cursor or no:
+     * stored rows by id, and by write id those that were queued when handed
+     * (stored or still queued now). Cleared with the cursor.
+     */
+    readerReturned = new Map();
+    /**
+     * `reader: 'forks'`: the late forks derived for an ended epoch's messages
+     * (readerFailed), so that a late fork's own failure derives no other.
+     */
+    lateForks = new WeakSet();
+    /** The all-except scope's durable record, cached (undefined = not read yet). */
+    scopeCache;
+    /** The epoch whose release this process delivered and whose hold is not yet recorded as cleared. */
+    scopeReleased;
+    /** Timer key for the scope's cadence and expiry. */
+    static SCOPE_KEY = '\0all-except';
     constructor(channelRegistry, serverRegistry, hooks) {
         this.channelRegistry = channelRegistry;
         this.serverRegistry = serverRegistry;
@@ -89,6 +169,26 @@ export class TuneOutCoordinator {
     key(serverId, channelId) {
         return `${serverId}\0${channelId}`;
     }
+    /** The readers' hand-off bookkeeping's key: one epoch's reading of one channel. */
+    handOffKey(epochId, serverId, channelId) {
+        return `${epochId}\0${serverId}\0${channelId}`;
+    }
+    /** An ended epoch's hand-off bookkeeping goes with it, every channel's. */
+    dropHandOffs(epochId) {
+        for (const map of [this.readerCursor, this.readerHandedWrites, this.readerReturned]) {
+            for (const key of map.keys())
+                if (key.startsWith(`${epochId}\0`))
+                    map.delete(key);
+        }
+    }
+    /** A reader exists: the persistent subconscious, or forks on demand. */
+    readerAvailable() {
+        return this.hooks.subconsciousName() != null || typeof this.hooks.invokeReader === 'function';
+    }
+    /** Reader forks are the configured reader. */
+    get forkReader() {
+        return this.hooks.subconsciousName() == null && typeof this.hooks.invokeReader === 'function';
+    }
     /** A channel as the resident and the subconscious are shown it
      *  (ChannelRegistry.nameShown): its id, or, where another server registers
      *  the same id, its server-qualified name, which tune_out and
@@ -97,6 +197,9 @@ export class TuneOutCoordinator {
     shown(serverId, channelId) {
         return this.channelRegistry.nameShown({ serverId, channelId });
     }
+    quotedShown(serverId, channelId) {
+        return this.channelRegistry.quotedShown({ serverId, channelId });
+    }
     /** Restart cadence + expiry timers and re-anchor after a process restart. */
     resumeActiveEpochs() {
         let oldestAnchor = null;
@@ -114,9 +217,42 @@ export class TuneOutCoordinator {
                 oldestAnchor = params.startedAtSequence;
             }
         }
+        const scope = this.getAllExcept();
+        if (scope) {
+            if (scope.params.expiresAtMs <= Date.now()) {
+                this.cancelAllExcept('duration', 'duration elapsed');
+            }
+            else {
+                this.armScopeTimers(scope.params);
+                if (oldestAnchor === null || scope.params.startedAtSequence < oldestAnchor) {
+                    oldestAnchor = scope.params.startedAtSequence;
+                }
+            }
+        }
         if (oldestAnchor !== null) {
             this.hooks.setSubconsciousAnchor(oldestAnchor);
         }
+        // What each held channel's reader hasn't looked at was counted in
+        // memory, so it is counted again from the held rows: without it, a
+        // channel held across the restart gets no cadence look until something
+        // new arrives.
+        // Stored and still queued alike: at a quiesced boot, restored writes stay
+        // queued until the resume flushes them.
+        const held = new Set();
+        for (const m of [...this.hooks.getStoredMessages(), ...(this.hooks.getDeferredMessages?.() ?? [])]) {
+            const meta = m.metadata;
+            const epochId = meta?.tuneOut?.epochId;
+            if (!meta || !epochId || !meta.channelId)
+                continue;
+            const key = this.key(meta.serverId ?? '', meta.channelId);
+            if (!held.has(key) && this.holdFor(meta.serverId ?? '', meta.channelId)?.epochId === epochId)
+                held.add(key);
+        }
+        for (const key of held) {
+            const [serverId, channelId] = key.split('\0');
+            this.rebuildTally(serverId, channelId);
+        }
+        this.pruneLooks();
     }
     armExpiry(serverId, channelId, params) {
         if (params.expiresAtMs === undefined)
@@ -169,39 +305,19 @@ export class TuneOutCoordinator {
     // ==========================================================================
     // Enter / cancel
     // ==========================================================================
-    enter(serverId, channelId, opts, source) {
-        if (!this.hooks.subconsciousName()) {
-            return {
-                ok: false,
-                error: 'Nothing was tuned out: this host has no subconscious resident to watch a channel, so tune_out '
-                    + "isn't available here, and calling it again won't change that. If you need channels diverted, ask "
-                    + 'whoever runs this host.',
-            };
-        }
-        if (this.hooks.isForkBound({ serverId, channelId })) {
-            return {
-                ok: false,
-                error: `Nothing changed: a conversation is bound to ${JSON.stringify(this.shown(serverId, channelId))}, so its messages go to that `
-                    + "conversation, and tune_out won't divert a channel while one is. Calling tune_out on it again won't change "
-                    + 'that until the conversation ends, which happens only once the channel has been quiet for a while. Tune '
-                    + 'out a different channel, or ask whoever runs this host if this one should be diverted.',
-            };
-        }
-        const current = this.channelRegistry.getTuneOutState(serverId, channelId);
-        if (current)
-            return { ok: false, error: alreadyTunedOutText(this.shown(serverId, channelId), current.params), alreadyTunedOut: true };
-        // A tool's input reaches here as the model wrote it, and the store can't
-        // keep a NaN or an Infinity: its append would throw after the registry
-        // had marked the channel tuned out. So each option is read as a number
-        // before anything changes, a numeric string included, as the sleep tool
-        // reads its seconds; null counts as left out. A value that gives no
-        // finite number is refused.
-        const leftOut = {
-            durationSeconds: 'to stay tuned out until you cancel',
-            cadenceSeconds: `for the default, ${TUNE_OUT_DEFAULTS.cadenceSeconds}`,
-            backlogCap: `for the default, ${TUNE_OUT_DEFAULTS.backlogCap}`,
-            maxWakes: `for the default, ${TUNE_OUT_DEFAULTS.maxWakes}`,
-        };
+    /**
+     * The options a tune-out call gives, read as numbers before anything
+     * changes (F76). A tool's input reaches here as the model wrote it, and
+     * the store can't keep a NaN or an Infinity: its append would throw after
+     * the registry had marked the channel tuned out. So each option is read
+     * as a number first, a numeric string included, as the sleep tool reads
+     * its seconds; null counts as left out. A value that gives no finite
+     * number is refused, naming the option and, where it can be left out,
+     * what leaving it out means; so is a duration whose end time is too far
+     * off to store. `now` is the clock the end time was counted from. One
+     * rule for a channel's tune-out and the all-except hold.
+     */
+    readOptions(opts, leftOut) {
         const given = {};
         for (const name of Object.keys(leftOut)) {
             const value = opts[name];
@@ -215,21 +331,63 @@ export class TuneOutCoordinator {
                 return {
                     ok: false,
                     error: `Nothing was tuned out: ${name} must be a finite number${name.endsWith('Seconds') ? ' of seconds' : ''}, `
-                        + `and it was ${got}. Leave it out ${leftOut[name]}.`,
+                        + `and it was ${got}.${leftOut[name] ? ` Leave it out ${leftOut[name]}.` : ''}`,
                 };
             }
             given[name] = n;
         }
+        const now = Date.now();
         const expiresAtMs = given.durationSeconds === undefined
             ? undefined
-            : Date.now() + Math.max(60, given.durationSeconds) * 1000;
+            : now + Math.max(60, given.durationSeconds) * 1000;
         if (expiresAtMs !== undefined && !Number.isFinite(expiresAtMs)) {
             return {
                 ok: false,
-                error: `Nothing was tuned out: durationSeconds ${given.durationSeconds} is longer than an end time can be kept. `
-                    + `Leave it out ${leftOut.durationSeconds}.`,
+                error: `Nothing was tuned out: durationSeconds ${given.durationSeconds} is longer than an end time can be kept.`
+                    + (leftOut.durationSeconds ? ` Leave it out ${leftOut.durationSeconds}.` : ''),
+            };
+        }
+        return { ok: true, given, now, expiresAtMs };
+    }
+    enter(serverId, channelId, opts, source) {
+        // No reader (issue #232 §3.3): a silent hold, where the host opted into
+        // one. Nothing summarizes, nothing wakes, mentions are still
+        // acknowledged, the backlog is released on cancel; the resident is told
+        // so in the tool result. A host that didn't opt in has no tune_out
+        // without a reader.
+        if (!this.readerAvailable() && this.hooks.holdWithoutReader?.() !== true) {
+            return {
+                ok: false,
+                error: 'Nothing was tuned out: this host has no subconscious resident to watch a channel, so tune_out '
+                    + "isn't available here, and calling it again won't change that. If you need channels diverted, ask "
+                    + 'whoever runs this host.',
             };
         }
+        if (this.hooks.isForkBound({ serverId, channelId })) {
+            return {
+                ok: false,
+                error: `Nothing changed: a conversation is bound to ${this.quotedShown(serverId, channelId)}, so its messages go to that `
+                    + "conversation, and tune_out won't divert a channel while one is. Calling tune_out on it again won't change "
+                    + 'that until the conversation ends, which happens only once the channel has been quiet for a while. Tune '
+                    + 'out a different channel, or ask whoever runs this host if this one should be diverted.',
+            };
+        }
+        const current = this.channelRegistry.getTuneOutState(serverId, channelId);
+        if (current)
+            return { ok: false, error: alreadyTunedOutText(this.quotedShown(serverId, channelId), current.params), alreadyTunedOut: true };
+        const scope = this.getAllExcept();
+        if (scope && scope.params.except.serverId === serverId && scope.params.except.channelId === channelId) {
+            return { ok: false, error: `channel ${this.quotedShown(serverId, channelId)} is the excepted channel of the active all-except hold; cancel that first` };
+        }
+        const read = this.readOptions(opts, {
+            durationSeconds: 'to stay tuned out until you cancel',
+            cadenceSeconds: `for the default, ${TUNE_OUT_DEFAULTS.cadenceSeconds}`,
+            backlogCap: `for the default, ${TUNE_OUT_DEFAULTS.backlogCap}`,
+            maxWakes: `for the default, ${TUNE_OUT_DEFAULTS.maxWakes}`,
+        });
+        if (!read.ok)
+            return read;
+        const { given, expiresAtMs } = read;
         const params = {
             epochId: randomUUID(),
             cadenceSeconds: Math.max(30, given.cadenceSeconds ?? TUNE_OUT_DEFAULTS.cadenceSeconds),
@@ -249,10 +407,17 @@ export class TuneOutCoordinator {
         const oldest = this.listActive().reduce((min, e) => Math.min(min, e.params.startedAtSequence), params.startedAtSequence);
         this.hooks.setSubconsciousAnchor(oldest);
         this.divertedSinceInvocation.set(this.key(serverId, channelId), 0);
-        this.startCadence(serverId, channelId, params.cadenceSeconds);
-        this.hooks.emitTrace({ type: 'tune-out:entered', serverId, channelId, epochId: params.epochId });
+        if (this.readerAvailable())
+            this.startCadence(serverId, channelId, params.cadenceSeconds);
+        this.hooks.emitTrace({
+            type: 'tune-out:entered', serverId, channelId, epochId: params.epochId, reader: this.readerAvailable(),
+        });
         return { ok: true, params };
     }
+    /** Whether a reader (persistent subconscious or reader forks) attends holds. */
+    hasReader() {
+        return this.readerAvailable();
+    }
     /**
      * End a tune-out: durable flip, system-framed backlog dump into the
      * resident's window (capped), lifecycle notice, one wake for the
@@ -260,11 +425,15 @@ export class TuneOutCoordinator {
      * cancel_tuneout call) — delivered verbatim under its name, never
      * synthesized here.
      */
-    cancel(serverId, channelId, source, reason, subconsciousNote) {
-        const ended = this.channelRegistry.cancelTuneOut(serverId, channelId, 'open', source);
+    cancel(serverId, channelId, source, reason, subconsciousNote, 
+    /** `reader: 'forks'`: the reader fork whose note this is. */
+    noteAuthor, 
+    /** The lifecycle state the channel returns to (a tool close ends in 'closed'). */
+    nextState = 'open') {
+        const ended = this.channelRegistry.cancelTuneOut(serverId, channelId, nextState, source);
         if (!ended) {
             // Its reader is the resident's tune_out: cancel_tuneout finds the channel first.
-            return { ok: false, error: this.notTunedOut(this.shown(serverId, channelId), 'you') };
+            return { ok: false, error: this.notTunedOut(this.quotedShown(serverId, channelId), 'you') };
         }
         this.clearTimers(serverId, channelId);
         this.divertedSinceInvocation.delete(this.key(serverId, channelId));
@@ -284,22 +453,23 @@ export class TuneOutCoordinator {
         // Whole messages: a cap below one shows none, where slice(-0.5) would
         // start at 0 and take them all.
         const cap = Math.floor(ended.params.backlogCap);
-        const authorOf = (m) => m.metadata?.author?.name ?? m.participant;
-        const lineOf = (m) => {
-            const text = m.content
-                .filter((b) => b.type === 'text')
-                .map((b) => b.text)
-                .join('\n');
-            return `${authorOf(m)}: ${text}`;
-        };
+        const authorOf = (m) => suppliedValue(m.metadata?.author?.name ?? m.participant);
+        // A line names its author as the resident knows them and marks what a
+        // text line can't carry (`[image]`), so the dump says what it leaves out.
+        const lineOf = renderHeldLine;
+        // The tool the truncation note names (#232 gap 11): the one the resident
+        // has, when the host says; main's `fetch_history` where no host says.
+        const historyTool = this.hooks.historyTool ? this.hooks.historyTool() : 'fetch_history';
         // The channel as the resident and the subconscious are shown it.
         const name = this.shown(serverId, channelId);
-        const lifecycle = `[Tune-out: ${name} cancelled — ${reason}, ${ended.wakeCount} wake${ended.wakeCount === 1 ? '' : 's'}]`;
+        const lifecycle = `[${NOTICE_TAG.tuneOut}: ${name} cancelled — ${reason}, ${ended.wakeCount} wake${ended.wakeCount === 1 ? '' : 's'}]`;
         const render = (lines, truncated) => {
             const attrs = [
-                `channel="${name}"`,
+                `channel=${this.quotedShown(serverId, channelId)}`,
                 `messages=${backlog.length}`,
-                ...(truncated > 0 ? [`truncated=${truncated} (oldest; fetch_history covers the rest)`] : []),
+                ...(truncated > 0
+                    ? [`truncated=${truncated} (oldest; ${historyTool ? `${historyTool} covers the rest` : 'not delivered'})`]
+                    : []),
             ];
             return `${lifecycle}\n\n<tuned-out-backlog ${attrs.join(' ')}>\n${lines.join('\n')}\n</tuned-out-backlog>`;
         };
@@ -341,7 +511,7 @@ export class TuneOutCoordinator {
             // What of the newest line's text fits beside the frame and the mark. A
             // cut shows some of it or none: a room under one character, or one
             // that would split a surrogate pair, leaves the head empty.
-            const head = prefixOf(lines.at(-1) ?? '', room - frameShowing(1) - CUT_MARK.length);
+            const head = cutToFit(lines.at(-1) ?? '', room - frameShowing(1) - CUT_MARK.length);
             if (kept === 0 && head !== '') {
                 lines = [head + CUT_MARK];
                 shown = shown.slice(-1);
@@ -365,6 +535,8 @@ export class TuneOutCoordinator {
         ];
         // Host-framed system artifacts — never voiced as anyone.
         this.hooks.addMessage('user', [{ type: 'text', text: render(lines, truncated) }], { system: true, kind: 'tune-out-cancel', channelId, epochId });
+        // The epoch is already ended durably; the release must be as durable.
+        this.hooks.commitDeliveries?.();
         // The subconscious's own words, under its own name, verbatim.
         const subName = this.hooks.subconsciousName();
         if (subconsciousNote && subName) {
@@ -373,6 +545,11 @@ export class TuneOutCoordinator {
             // reads (repinChannel), where another server's channel can share the id.
             { kind: 'subconscious-note', channelId, serverId, epochId });
         }
+        else if (subconsciousNote && noteAuthor && this.hooks.deliverFromReader) {
+            // A reader fork's note: attributed mail, under the fork's name and
+            // incarnation, never the resident's voice.
+            this.hooks.deliverFromReader(noteAuthor, [{ type: 'text', text: subconsciousNote }], { kind: 'subconscious-note', channelId, epochId });
+        }
         const primary = this.hooks.primaryName();
         if (primary) {
             this.hooks.requestInference(primary, `tune-out cancelled (${reason})`, 'tune-out');
@@ -394,7 +571,7 @@ export class TuneOutCoordinator {
             const heldNote = heldForReport.length > 0
                 ? ` Still held at the cancel, so your view may not have them yet: the ${heldForReport.length} message${heldForReport.length === 1 ? '' : 's'} after this one.`
                 : '';
-            this.hooks.addMessage('user', [{ type: 'text', text: `[Tune-out cancelled: ${this.shown(serverId, channelId)} — ${reason}.${truncNote}${heldNote}]` }], { system: true, kind: 'tune-out-cancel-report', channelId }, subName);
+            this.hooks.addMessage('user', [{ type: 'text', text: `[${NOTICE_TAG.tuneOutCancelled}: ${this.shown(serverId, channelId)} — ${reason}.${truncNote}${heldNote}]` }], { system: true, kind: 'tune-out-cancel-report', channelId }, subName);
             // Each held message is a row of its own, so a per-message cap cuts each
             // one on its own, its author's label included, not the batch's newest.
             for (const m of heldForReport) {
@@ -402,6 +579,34 @@ export class TuneOutCoordinator {
             }
             this.hooks.requestInference(subName, `tune-out cancelled: ${name}`, 'tune-out');
         }
+        else if (!subName && this.forkReader) {
+            // Forks are the reader: one last fork for the epoch, handed what no
+            // fork has been handed yet, stored or still queued behind the
+            // resident's turn, plus the cancel notice; its report follows the dump.
+            // Once the epoch ends, a message still queued lands in the store
+            // view-filtered, where nothing else reads it, so it goes to this fork
+            // now. On a reader's own cancel, the reader has read what it was
+            // handed, so a fork follows only when messages arrived after that.
+            const stored = this.hooks.getStoredMessages().filter(ofEpoch);
+            const queued = this.queuedHeld(ofEpoch);
+            const rest = this.unhandedBacklog(this.handOffKey(epochId, serverId, channelId), stored, queued);
+            const unread = rest.backlog.length + rest.queued.length;
+            if (!selfCancel || unread > 0) {
+                const truncNote = truncated > 0
+                    ? ` ${truncated} of ${backlog.length} diverted messages, the oldest, weren't delivered raw to the resident.`
+                    : '';
+                const lateNote = selfCancel
+                    ? ` ${unread === 1 ? 'This message' : `These ${unread} messages`} arrived after the reader that cancelled was handed its own.`
+                    : '';
+                this.invokeReaderFork(serverId, channelId, epochId, 'cancel', `[${NOTICE_TAG.tuneOutCancelled}: ${name} — ${reason}.${truncNote}${lateNote}]`, stored, queued);
+            }
+        }
+        this.dropHandOffs(epochId);
+        this.dropLooks(epochId);
+        // Where the all-except hold still holds the channel, its own messages
+        // there that its reader hasn't looked at are counted again, as the
+        // channel's own tune-out's count stood in for theirs.
+        this.rebuildTally(serverId, channelId);
         this.hooks.emitTrace({ type: 'tune-out:cancelled', serverId, channelId, epochId, reason, wakeCount: ended.wakeCount });
         return { ok: true };
     }
@@ -417,9 +622,355 @@ export class TuneOutCoordinator {
      * suppression ack, possible auto-cancel).
      */
     onIncoming(serverId, channelId, messageId, tags, authorId, gatePass = true) {
-        const state = this.channelRegistry.getTuneOutState(serverId, channelId);
-        if (!state)
+        const hold = this.holdFor(serverId, channelId);
+        if (!hold)
             return null;
+        this.recordHeld(serverId, channelId, messageId, tags, authorId, gatePass);
+        return hold;
+    }
+    /** The epoch holding this channel, or null. Pure: the admission stage's lookup. */
+    holdFor(serverId, channelId) {
+        // Precedence: a per-channel epoch keeps its own hold (cadence, budget,
+        // stamp); the all-except scope holds whatever else is not the exception.
+        const state = this.channelRegistry.getTuneOutState(serverId, channelId);
+        if (state)
+            return { epochId: state.params.epochId };
+        const scope = this.getAllExcept();
+        if (scope && !(scope.params.except.serverId === serverId && scope.params.except.channelId === channelId)) {
+            return { epochId: scope.params.epochId };
+        }
+        return null;
+    }
+    /** The channel unprefixed speech lands in while an all-except hold is active, with its server, else null. */
+    focusChannel() {
+        const except = this.getAllExcept()?.params.except;
+        return except ? { serverId: except.serverId, channelId: except.channelId } : null;
+    }
+    // ==========================================================================
+    // All-except scope
+    // ==========================================================================
+    get scopeStateId() {
+        return `tune-out/${this.hooks.primaryName() ?? 'default'}/all-except`;
+    }
+    getAllExcept() {
+        if (this.scopeCache !== undefined)
+            return this.scopeCache;
+        // A record that can't be read, or isn't a hold's, is not taken for no
+        // hold: the error goes to the caller and nothing is cached, so the next
+        // read tries again. At create() that refuses the start, as an
+        // unreadable registry does.
+        const raw = this.channelRegistry.readCoordinatorState(this.scopeStateId);
+        if (raw !== null && raw !== undefined && !(typeof raw === 'object' && raw.params && typeof raw.params.epochId === 'string')) {
+            throw new Error(`the all-except hold's stored record (${this.scopeStateId}) is not a hold's record; it was left as it is`);
+        }
+        this.scopeCache = raw ?? null;
+        return this.scopeCache;
+    }
+    writeScope(state) {
+        // Durable first: a write that fails leaves memory as the store has it.
+        this.channelRegistry.writeCoordinatorState(this.scopeStateId, state);
+        this.scopeCache = state;
+    }
+    enterAllExcept(except, opts, source) {
+        const read = this.readOptions(opts, {
+            durationSeconds: null,
+            cadenceSeconds: `for the default, ${TUNE_OUT_DEFAULTS.cadenceSeconds}`,
+            backlogCap: `for the default, ${TUNE_OUT_DEFAULTS.backlogCap}`,
+            maxWakes: `for the default, ${TUNE_OUT_DEFAULTS.maxWakes}`,
+        });
+        if (!read.ok)
+            return read;
+        const { given, expiresAtMs } = read;
+        if (expiresAtMs === undefined) {
+            return { ok: false, error: 'an all-except hold needs `durationSeconds`: it always ends on its own' };
+        }
+        if (this.getAllExcept()) {
+            return { ok: false, error: 'an all-except hold is already active (cancel it first)' };
+        }
+        if (this.channelRegistry.getTuneOutState(except.serverId, except.channelId)) {
+            return { ok: false, error: `channel ${except.channelId} is tuned out; it cannot be the exception` };
+        }
+        if (this.hooks.isForkBound(except)) {
+            return { ok: false, error: `channel ${except.channelId} is bound to a conversation fork` };
+        }
+        const params = {
+            epochId: randomUUID(),
+            except,
+            cadenceSeconds: Math.max(30, given.cadenceSeconds ?? TUNE_OUT_DEFAULTS.cadenceSeconds),
+            // Whole messages, as a channel's cap is counted: a cap below one shows
+            // none, where slice(-0.5) would take them all.
+            backlogCap: Math.max(0, Math.floor(given.backlogCap ?? TUNE_OUT_DEFAULTS.backlogCap)),
+            maxWakes: Math.max(1, given.maxWakes ?? TUNE_OUT_DEFAULTS.maxWakes),
+            startedAtSequence: this.hooks.currentSequence(),
+            startedAtMs: read.now,
+            expiresAtMs,
+            source,
+        };
+        this.writeScope({ params, wakeCount: 0 });
+        const oldest = this.listActive().reduce((min, e) => Math.min(min, e.params.startedAtSequence), params.startedAtSequence);
+        this.hooks.setSubconsciousAnchor(oldest);
+        this.armScopeTimers(params);
+        this.hooks.emitTrace({
+            type: 'tune-out:entered', serverId: except.serverId, channelId: except.channelId, epochId: params.epochId,
+            scope: 'all-except', reader: this.readerAvailable(), expiresAtMs: params.expiresAtMs,
+        });
+        const minutes = Math.max(1, Math.round((params.expiresAtMs - params.startedAtMs) / 60_000));
+        const until = new Date(params.expiresAtMs).toISOString().slice(11, 16);
+        this.announce(except, params.epochId, 'entered', `[${NOTICE_TAG.focus}: ${this.hooks.primaryName() ?? 'the resident'} is here for ${minutes} min, until ${until} UTC; other channels are held meanwhile.]`);
+        return { ok: true, params };
+    }
+    /** Whether entry and release of the all-except scope are announced in the excepted channel. */
+    announces() {
+        return typeof this.hooks.announce === 'function';
+    }
+    /**
+     * The excepted channel hears the scope open and close: one bracketed line
+     * under the resident's name, posted through the same path as a publish.
+     * Fire-and-forget; the outcome is traced, never awaited by the epoch flip.
+     */
+    announce(target, epochId, kind, text) {
+        if (!this.hooks.announce)
+            return;
+        const base = { serverId: target.serverId, channelId: target.channelId, epochId, kind };
+        this.hooks.announce(target.serverId, target.channelId, text).then((r) => this.hooks.emitTrace(r.success
+            ? { type: 'tune-out:announced', ...base }
+            : { type: 'tune-out:announce-failed', ...base, error: r.error ?? 'publish failed' }), (err) => this.hooks.emitTrace({ type: 'tune-out:announce-failed', ...base, error: err.message }));
+    }
+    /** The scope's end time and cadence, on timers no longer than one holds
+     *  (deadline-timer), as a channel's tune-out arms its own. */
+    armScopeTimers(params) {
+        const key = TuneOutCoordinator.SCOPE_KEY;
+        const expiry = this.expiryTimers.get(key);
+        if (expiry)
+            clearTimeout(expiry);
+        // As a channel's timers: the next turn is armed before this one's work,
+        // and a throw is reported (timerFailed) rather than left to end the host.
+        const { serverId: exceptServer, channelId: exceptChannel } = params.except;
+        const holdExpiry = (timer) => { this.expiryTimers.set(key, timer); };
+        const end = () => {
+            try {
+                holdExpiry(setTimeout(end, EXPIRY_RETRY_MS));
+                if (!this.cancelAllExcept('duration', 'duration elapsed').ok)
+                    this.clearScopeTimers();
+            }
+            catch (err) {
+                this.timerFailed('expiry', exceptServer, exceptChannel, err);
+            }
+        };
+        armAt(params.expiresAtMs, holdExpiry, end);
+        if (!this.readerAvailable())
+            return;
+        const cadence = this.cadenceTimers.get(key);
+        if (cadence)
+            clearTimeout(cadence);
+        const hold = (timer) => { this.cadenceTimers.set(key, timer); };
+        const tick = () => {
+            try {
+                const scope = this.getAllExcept();
+                if (!scope)
+                    return;
+                armAfter(params.cadenceSeconds * 1000, hold, tick);
+                // One look per held channel with new traffic since the last look.
+                for (const [channelKey, diverted] of this.divertedSinceInvocation) {
+                    if (diverted <= 0)
+                        continue;
+                    const [serverId, channelId] = channelKey.split('\0');
+                    if (this.channelRegistry.getTuneOutState(serverId, channelId))
+                        continue; // a per-channel epoch's own cadence
+                    this.invokeSubconscious(serverId, channelId, 'cadence', diverted);
+                }
+            }
+            catch (err) {
+                this.timerFailed('cadence', exceptServer, exceptChannel, err);
+            }
+        };
+        armAfter(params.cadenceSeconds * 1000, hold, tick);
+    }
+    clearScopeTimers() {
+        const key = TuneOutCoordinator.SCOPE_KEY;
+        const cadence = this.cadenceTimers.get(key);
+        if (cadence)
+            clearTimeout(cadence);
+        this.cadenceTimers.delete(key);
+        const expiry = this.expiryTimers.get(key);
+        if (expiry)
+            clearTimeout(expiry);
+        this.expiryTimers.delete(key);
+    }
+    /** Channels held by the scope (not by their own epoch) with the count held under it. */
+    scopeHeldCounts(epochId) {
+        const counts = new Map();
+        const all = [...this.hooks.getStoredMessages(), ...(this.hooks.getDeferredMessages?.() ?? [])];
+        for (const m of all) {
+            const meta = m.metadata;
+            if (meta?.tuneOut?.epochId !== epochId)
+                continue;
+            const channelId = typeof meta.channelId === 'string' ? meta.channelId : '(unknown channel)';
+            const serverId = typeof meta.serverId === 'string' ? meta.serverId : '';
+            const k = this.key(serverId, channelId);
+            const entry = counts.get(k) ?? { serverId, channelId, count: 0 };
+            entry.count += 1;
+            counts.set(k, entry);
+        }
+        return counts;
+    }
+    /**
+     * End the all-except hold: durable flip, one release notice with a
+     * per-channel backlog (each capped), the reader's note if any, one wake
+     * for the resident, and the reader's own look at what it had not seen.
+     */
+    cancelAllExcept(source, reason, note, noteAuthor) {
+        const scope = this.getAllExcept();
+        if (!scope)
+            return { ok: false, error: 'no all-except hold is active' };
+        const { epochId, except, backlogCap } = scope.params;
+        const ofEpoch = (m) => m.metadata?.tuneOut?.epochId === epochId;
+        const all = [...this.hooks.getStoredMessages().filter(ofEpoch), ...(this.hooks.getDeferredMessages?.() ?? []).filter(ofEpoch)];
+        const byChannel = new Map();
+        for (const m of all) {
+            const meta = m.metadata;
+            const serverId = meta?.serverId ?? '';
+            const channelId = meta?.channelId ?? '(unknown channel)';
+            const k = this.key(serverId, channelId);
+            const entry = byChannel.get(k) ?? { serverId, channelId, backlog: [] };
+            entry.backlog.push(m);
+            byChannel.set(k, entry);
+        }
+        const historyTool = this.hooks.historyTool?.() ?? null;
+        const dumps = [...byChannel.values()].map(({ serverId, channelId, backlog }) => {
+            // Floored here too: a hold stored before entry floored its cap can hold
+            // a fraction.
+            const cap = Math.floor(backlogCap);
+            const shown = cap > 0 ? backlog.slice(-cap) : [];
+            const truncated = backlog.length - shown.length;
+            const attrs = [
+                `channel=${quotedValue(this.shown(serverId, channelId))}`,
+                `messages=${backlog.length}`,
+                ...(truncated > 0 ? [`truncated=${truncated} (oldest; ${historyTool ? `${historyTool} covers the rest` : 'not delivered'})`] : []),
+            ];
+            return `<tuned-out-backlog ${attrs.join(' ')}>\n${shown.map(renderHeldLine).join('\n')}\n</tuned-out-backlog>`;
+        });
+        const summary = byChannel.size === 0
+            ? 'Nothing was held.'
+            : `${all.length} message${all.length === 1 ? '' : 's'} held in ${byChannel.size} channel${byChannel.size === 1 ? '' : 's'}.`;
+        if (this.scopeReleased !== epochId) {
+            this.hooks.addMessage('user', [{ type: 'text', text: `[${NOTICE_TAG.tuneOut}: all channels except ${this.shown(except.serverId, except.channelId)} released — ${reason}, ${scope.wakeCount} wake${scope.wakeCount === 1 ? '' : 's'}]\n\n${summary}${dumps.length > 0 ? '\n\n' + dumps.join('\n\n') : ''}` }], { system: true, kind: 'tune-out-cancel', scope: 'all-except', channelId: except.channelId, epochId });
+            this.hooks.commitDeliveries?.();
+            this.scopeReleased = epochId;
+        }
+        // The release is recorded before the hold is: a failure past this point
+        // leaves the hold in force with its release already delivered. A retry in
+        // this process records only the hold's end; a restart between the two
+        // delivers the release again, where the other order lost it outright.
+        this.writeScope(null);
+        this.scopeReleased = undefined;
+        this.clearScopeTimers();
+        for (const [key, pending] of this.pendingWakes) {
+            const [serverId, channelId] = key.split('\0');
+            if (this.channelRegistry.getTuneOutState(serverId, channelId))
+                continue;
+            clearTimeout(pending.timer);
+            this.pendingWakes.delete(key);
+        }
+        const subName = this.hooks.subconsciousName();
+        if (note && subName) {
+            this.hooks.addMessage(subName, [{ type: 'text', text: note }], { kind: 'subconscious-note', epochId });
+        }
+        else if (note && noteAuthor && this.hooks.deliverFromReader) {
+            this.hooks.deliverFromReader(noteAuthor, [{ type: 'text', text: note }], { kind: 'subconscious-note', epochId });
+        }
+        const primary = this.hooks.primaryName();
+        if (primary)
+            this.hooks.requestInference(primary, `tune-out cancelled (${reason})`, 'tune-out');
+        const notice = `[${NOTICE_TAG.tuneOutCancelled}: all channels except ${this.shown(except.serverId, except.channelId)} — ${reason}.]`;
+        if (source !== 'subconscious' && subName) {
+            this.hooks.addMessage('user', [{ type: 'text', text: notice }], { system: true, kind: 'tune-out-cancel-report', scope: 'all-except' }, subName);
+            this.hooks.requestInference(subName, 'tune-out cancelled: all-except', 'tune-out');
+        }
+        else if (!subName && this.forkReader) {
+            // One last look per channel with messages no fork was handed, stored or
+            // still queued behind the resident's turn. That holds for a reader's
+            // own release too: the reader that released read one channel's
+            // messages, and every other channel's would otherwise reach no reader.
+            // A channel is its server and id here, as the readers' bookkeeping is.
+            const channels = new Map();
+            for (const m of all) {
+                const meta = m.metadata;
+                const ref = { serverId: meta?.serverId ?? '', channelId: meta?.channelId ?? '(unknown channel)' };
+                channels.set(this.key(ref.serverId, ref.channelId), ref);
+            }
+            for (const { serverId, channelId } of channels.values()) {
+                const ofChannel = inChannelOf(serverId, channelId);
+                const inChannel = (m) => ofEpoch(m) && ofChannel(m);
+                const stored = this.hooks.getStoredMessages().filter(inChannel);
+                const queued = this.queuedHeld(inChannel);
+                const rest = this.unhandedBacklog(this.handOffKey(epochId, serverId, channelId), stored, queued);
+                if (rest.backlog.length + rest.queued.length > 0) {
+                    this.invokeReaderFork(serverId, channelId, epochId, 'cancel', notice, stored, queued);
+                }
+            }
+        }
+        for (const key of this.divertedSinceInvocation.keys()) {
+            const [serverId, channelId] = key.split('\0');
+            if (!this.channelRegistry.getTuneOutState(serverId, channelId))
+                this.divertedSinceInvocation.delete(key);
+        }
+        this.dropHandOffs(epochId);
+        this.dropLooks(epochId);
+        this.hooks.emitTrace({ type: 'tune-out:cancelled', serverId: except.serverId, channelId: except.channelId, epochId, scope: 'all-except', reason, wakeCount: scope.wakeCount });
+        this.announce(except, epochId, 'released', `[${NOTICE_TAG.focus}: ${primary ?? 'the resident'} released — ${reason}.]`);
+        return { ok: true };
+    }
+    /** What is held right now — per-channel epochs and the scope — without releasing. */
+    check(opts = {}) {
+        const stored = this.hooks.getStoredMessages();
+        const deferred = this.hooks.getDeferredMessages?.() ?? [];
+        const countOf = (epochId) => [...stored, ...deferred].filter((m) => m.metadata?.tuneOut?.epochId === epochId).length;
+        const channels = this.listActive().map(({ serverId, channelId, params }) => ({
+            serverId, channelId, epochId: params.epochId, held: countOf(params.epochId),
+            ...(params.expiresAtMs !== undefined ? { expiresAtMs: params.expiresAtMs } : {}),
+        }));
+        const scope = this.getAllExcept();
+        let allExcept = null;
+        if (scope) {
+            const held = {};
+            for (const { serverId, channelId, count } of this.scopeHeldCounts(scope.params.epochId).values())
+                held[this.shown(serverId, channelId)] = count;
+            allExcept = { epochId: scope.params.epochId, except: scope.params.except, expiresAtMs: scope.params.expiresAtMs, wakeCount: scope.wakeCount, held };
+        }
+        const result = { allExcept, channels };
+        if (opts.peek) {
+            const limit = Math.max(1, Math.min(50, opts.peekLimit ?? 5));
+            // Only what is held NOW: the channel's own epoch, or the scope's. A
+            // released epoch's messages are delivered, not held; showing them here
+            // would be a false declaration (first live run, 2026-10-12, finding B).
+            const active = new Set();
+            for (const e of channels) {
+                if (e.channelId === opts.peek.channelId && (!opts.peek.serverId || e.serverId === opts.peek.serverId))
+                    active.add(e.epochId);
+            }
+            if (scope)
+                active.add(scope.params.epochId);
+            const lines = [...stored, ...deferred]
+                .filter((m) => {
+                const meta = m.metadata;
+                return typeof meta?.tuneOut?.epochId === 'string' && active.has(meta.tuneOut.epochId)
+                    && meta.channelId === opts.peek.channelId
+                    && (!opts.peek.serverId || meta.serverId === opts.peek.serverId);
+            })
+                .slice(-limit)
+                .map(renderHeldLine);
+            result.peek = lines;
+        }
+        return result;
+    }
+    /**
+     * Bookkeeping for one held message, after admission decided the hold:
+     * the cadence tally, the deterministic acknowledgement of a suppressed
+     * mention, and the reader wake when the resident's gate would have woken
+     * them (`gatePass` is that verdict, probed without side effects).
+     */
+    recordHeld(serverId, channelId, messageId, tags, authorId, gatePass = true) {
         const key = this.key(serverId, channelId);
         this.divertedSinceInvocation.set(key, (this.divertedSinceInvocation.get(key) ?? 0) + 1);
         // Wake classification: the resident's wake gate composes as a
@@ -439,10 +990,17 @@ export class TuneOutCoordinator {
             // standing mute to its subject.
             void this.acknowledgeSuppressed(serverId, channelId, messageId);
         }
-        if (gatePass && (addressed || privileged)) {
+        if (gatePass && (addressed || privileged) && this.readerAvailable()) {
             this.scheduleWakeInvocation(serverId, channelId);
         }
-        return { epochId: state.params.epochId };
+    }
+    /** Reader forks that reported through `deliver_summary` (so their trailing prose is not a second report). */
+    readerReports = new Set();
+    readerReported(reader) {
+        return this.readerReports.has(reader);
+    }
+    forgetReader(reader) {
+        this.readerReports.delete(reader);
     }
     async acknowledgeSuppressed(serverId, channelId, messageId) {
         try {
@@ -524,15 +1082,7 @@ export class TuneOutCoordinator {
             try {
                 const entry = this.pendingWakes.get(key);
                 this.pendingWakes.delete(key);
-                // Count ONE durable wake per coalesced invocation.
-                const counted = this.channelRegistry.recordTuneOutWake(serverId, channelId);
-                if (!counted)
-                    return; // cancelled inside the window
-                if (counted.wakeCount > counted.params.maxWakes) {
-                    this.cancel(serverId, channelId, 'tune-out-max-wakes', `wake budget exhausted (${counted.params.maxWakes})`);
-                    return;
-                }
-                this.invokeSubconscious(serverId, channelId, 'wake', entry?.count ?? 1);
+                this.fireWake(serverId, channelId, entry?.count ?? 1);
             }
             catch (err) {
                 this.timerFailed('wake', serverId, channelId, err);
@@ -540,6 +1090,37 @@ export class TuneOutCoordinator {
         }, WAKE_COALESCE_MS);
         this.pendingWakes.set(key, { count: 1, timer });
     }
+    /** One coalesced wake: counted durably against the epoch that holds the channel. */
+    fireWake(serverId, channelId, count) {
+        if (this.channelRegistry.getTuneOutState(serverId, channelId)) {
+            // Count ONE durable wake per coalesced invocation.
+            const counted = this.channelRegistry.recordTuneOutWake(serverId, channelId);
+            if (!counted)
+                return; // cancelled inside the window
+            if (counted.wakeCount > counted.params.maxWakes) {
+                this.cancel(serverId, channelId, 'tune-out-max-wakes', `wake budget exhausted (${counted.params.maxWakes})`);
+                return;
+            }
+            this.invokeSubconscious(serverId, channelId, 'wake', count);
+            return;
+        }
+        const scope = this.getAllExcept();
+        if (!scope)
+            return; // released inside the window
+        // The all-except scope: exhausting the budget pauses the reader, it does
+        // not end the hold (#232 §3.2 — the hold is the resident's bounded
+        // commitment; the deadline ends it).
+        const wakeCount = scope.wakeCount + 1;
+        this.writeScope({ ...scope, wakeCount });
+        if (wakeCount > scope.params.maxWakes) {
+            this.hooks.emitTrace({
+                type: 'tune-out:wake-budget-paused', epochId: scope.params.epochId, scope: 'all-except',
+                serverId, channelId, wakeCount, maxWakes: scope.params.maxWakes,
+            });
+            return;
+        }
+        this.invokeSubconscious(serverId, channelId, 'wake', count);
+    }
     /**
      * One subconscious turn: a system-framed trigger notice (bracket style —
      * what happened, never what to say) plus standing dispositions, then an
@@ -547,18 +1128,314 @@ export class TuneOutCoordinator {
      */
     invokeSubconscious(serverId, channelId, trigger, count) {
         const subName = this.hooks.subconsciousName();
-        if (!subName)
+        if (!subName && !this.forkReader)
             return;
         const key = this.key(serverId, channelId);
         const shown = this.shown(serverId, channelId);
         const notice = trigger === 'wake'
-            ? `[Tune-out wake: ${shown} — ${count} addressed message${count === 1 ? '' : 's'}]`
-            : `[Tune-out cadence: ${shown} — ${count} diverted message${count === 1 ? '' : 's'} since your last look]`;
+            ? `[${NOTICE_TAG.tuneOutWake}: ${shown} — ${count} addressed message${count === 1 ? '' : 's'}]`
+            : `[${NOTICE_TAG.tuneOutCadence}: ${shown} — ${count} diverted message${count === 1 ? '' : 's'} since your last look]`;
+        if (!subName) {
+            const hold = this.holdFor(serverId, channelId);
+            if (!hold)
+                return;
+            const ofChannel = inChannelOf(serverId, channelId);
+            const inChannel = (m) => m.metadata?.tuneOut?.epochId === hold.epochId && ofChannel(m);
+            // Stored and still-queued alike: while the resident's turn runs, what
+            // arrives waits in the deferred queue, and that is the traffic a reader
+            // is there for.
+            this.invokeReaderFork(serverId, channelId, hold.epochId, trigger, notice, this.hooks.getStoredMessages().filter(inChannel), this.queuedHeld(inChannel));
+            // The count restarts once the fork has been handed what was held, as it
+            // does below once the subconscious's turn has been asked for. Otherwise
+            // every later cadence period still sees this one's count and derives a
+            // fork with nothing new to read.
+            this.divertedSinceInvocation.set(key, 0);
+            return;
+        }
         this.hooks.addMessage('user', [{ type: 'text', text: notice }], { system: true, kind: `tune-out-${trigger}`, channelId }, subName);
         this.hooks.requestInference(subName, `tune-out ${trigger}: ${shown}`, 'tune-out');
         // Counted from here only once the turn has been asked for, so a turn that
         // throws leaves its messages for the next period's turn.
         this.divertedSinceInvocation.set(key, 0);
+        const epochId = this.holdFor(serverId, channelId)?.epochId;
+        if (epochId)
+            this.markLook(epochId, serverId, channelId);
+    }
+    /**
+     * Count again, from the held messages, stored or still queued behind the
+     * resident's turn, those the reader of the epoch holding this channel now
+     * hasn't looked at: for reader forks, those no fork was handed; for the
+     * persistent subconscious, the stored ones held since its last look
+     * (lastLooks) and every queued one, which no view of it can show yet.
+     * Nothing holding the channel leaves no count.
+     */
+    rebuildTally(serverId, channelId) {
+        const key = this.key(serverId, channelId);
+        const hold = this.holdFor(serverId, channelId);
+        if (!hold || !this.readerAvailable()) {
+            this.divertedSinceInvocation.delete(key);
+            return;
+        }
+        const ofChannel = inChannelOf(serverId, channelId);
+        const inEpoch = (m) => m.metadata?.tuneOut?.epochId === hold.epochId && ofChannel(m);
+        const rows = this.hooks.getStoredMessages().filter(inEpoch);
+        const queued = this.queuedHeld(inEpoch);
+        let count;
+        if (this.forkReader) {
+            const unread = this.unhandedBacklog(this.handOffKey(hold.epochId, serverId, channelId), rows, queued);
+            count = unread.backlog.length + unread.queued.length;
+        }
+        else {
+            const mark = this.lastLooks()?.[hold.epochId]?.[key];
+            count = (mark === undefined ? rows.length : rows.filter((m) => m.sequence > mark).length) + queued.length;
+        }
+        this.divertedSinceInvocation.set(key, count);
+    }
+    get lastLooksStateId() {
+        return `tune-out/${this.hooks.primaryName() ?? 'default'}/last-looks`;
+    }
+    /**
+     * The stored last looks. Where they can't be read, none: every held row
+     * counts, and nothing is cached, so the next read tries again. Nor is
+     * anything written back over the stored record then (markLook, dropLooks,
+     * pruneLooks), which would erase the other epochs' and channels' looks.
+     */
+    lastLooks() {
+        if (this.lastLooksCache !== undefined)
+            return this.lastLooksCache;
+        let raw;
+        try {
+            raw = this.channelRegistry.readCoordinatorState(this.lastLooksStateId);
+        }
+        catch (error) {
+            console.error(`[tune-out] the subconscious's last looks (${this.lastLooksStateId}) could not be read:`, error);
+            return undefined;
+        }
+        const looks = {};
+        if (raw && typeof raw === 'object' && !Array.isArray(raw)) {
+            for (const [epochId, channels] of Object.entries(raw)) {
+                if (!channels || typeof channels !== 'object' || Array.isArray(channels))
+                    continue;
+                const marks = Object.entries(channels).filter((e) => typeof e[1] === 'number');
+                if (marks.length > 0)
+                    looks[epochId] = Object.fromEntries(marks);
+            }
+        }
+        this.lastLooksCache = looks;
+        return looks;
+    }
+    writeLooks(looks) {
+        this.lastLooksCache = looks;
+        try {
+            this.channelRegistry.writeCoordinatorState(this.lastLooksStateId, looks);
+        }
+        catch (error) {
+            // The look itself stands. After a restart, this look's messages would
+            // count as unseen at the next one.
+            console.error(`[tune-out] the subconscious's last looks (${this.lastLooksStateId}) could not be stored:`, error);
+        }
+    }
+    markLook(epochId, serverId, channelId) {
+        const looks = this.lastLooks();
+        if (!looks)
+            return;
+        this.writeLooks({ ...looks, [epochId]: { ...looks[epochId], [this.key(serverId, channelId)]: this.hooks.currentSequence() } });
+    }
+    /** An ended epoch's last looks go with it. */
+    dropLooks(epochId) {
+        if (this.hooks.subconsciousName() == null)
+            return;
+        const looks = this.lastLooks();
+        if (!looks || !(epochId in looks))
+            return;
+        const { [epochId]: _ended, ...rest } = looks;
+        this.writeLooks(rest);
+    }
+    /** At boot: the last looks of epochs no longer active go. */
+    pruneLooks() {
+        if (this.hooks.subconsciousName() == null)
+            return;
+        const looks = this.lastLooks();
+        if (!looks)
+            return;
+        const active = new Set(this.listActive().map((e) => e.params.epochId));
+        const scope = this.getAllExcept();
+        if (scope)
+            active.add(scope.params.epochId);
+        const kept = Object.fromEntries(Object.entries(looks).filter(([epochId]) => active.has(epochId)));
+        if (Object.keys(kept).length !== Object.keys(looks).length)
+            this.writeLooks(kept);
+    }
+    /**
+     * `reader: 'forks'`: hand the framework one invocation. The backlog is
+     * the epoch's held messages not yet handed to any fork — each is
+     * delivered to exactly one reader — stored ones first, then those still
+     * queued behind the resident's turn, plus the standing dispositions. A
+     * cadence look with nothing new is skipped. True when a fork was asked for.
+     */
+    invokeReaderFork(serverId, channelId, epochId, trigger, notice, epochBacklog, epochQueued = []) {
+        if (!this.hooks.invokeReader)
+            return false;
+        const key = this.handOffKey(epochId, serverId, channelId);
+        const { backlog, queued } = this.unhandedBacklog(key, epochBacklog, epochQueued);
+        if (trigger === 'cadence' && backlog.length === 0 && queued.length === 0)
+            return false;
+        // The cursor only moves forward: a returned row handed again can be
+        // behind it.
+        const cursor = Math.max(this.readerCursor.get(key) ?? -1, ...backlog.map((m) => m.sequence));
+        if (backlog.length > 0)
+            this.readerCursor.set(key, cursor);
+        const handed = this.readerHandedWrites.get(key) ?? new Set();
+        for (const m of queued)
+            handed.add(m.writeId);
+        // A handed write whose row has landed behind the cursor can no longer be
+        // handed by sequence, so its id has done its work.
+        for (const m of epochBacklog) {
+            const writeId = writeIdOf(m);
+            if (writeId !== undefined && m.sequence <= cursor)
+                handed.delete(writeId);
+        }
+        if (handed.size > 0)
+            this.readerHandedWrites.set(key, handed);
+        else
+            this.readerHandedWrites.delete(key);
+        const returned = this.readerReturned.get(key);
+        if (returned) {
+            for (const m of backlog) {
+                returned.ids.delete(m.id);
+                const writeId = writeIdOf(m);
+                if (writeId !== undefined)
+                    returned.writeIds.delete(writeId);
+            }
+            for (const m of queued)
+                returned.writeIds.delete(m.writeId);
+            if (returned.ids.size === 0 && returned.writeIds.size === 0)
+                this.readerReturned.delete(key);
+        }
+        const entries = Object.entries(this.readDispositions());
+        this.hooks.invokeReader({
+            serverId,
+            channelId,
+            epochId,
+            trigger,
+            notice,
+            backlog,
+            queued,
+            dispositions: entries.length > 0 ? entries.map(([k, v]) => `- ${k}: ${v}`).join('\n') : null,
+        });
+        return true;
+    }
+    /**
+     * What no reader fork has read yet, of the given held messages: the stored
+     * ones past the epoch's cursor for the channel, less those a fork was handed while they
+     * were still queued, plus those a failed fork returned, oldest first; then
+     * the queued ones no fork was handed, or a failed fork returned.
+     */
+    unhandedBacklog(key, stored, queued) {
+        const cursor = this.readerCursor.get(key) ?? -1;
+        const handed = this.readerHandedWrites.get(key);
+        const returned = this.readerReturned.get(key);
+        const wasReturned = (id, writeId) => returned !== undefined && ((id !== undefined && returned.ids.has(id)) || (writeId !== undefined && returned.writeIds.has(writeId)));
+        const unread = (m) => {
+            const writeId = writeIdOf(m);
+            if (wasReturned(m.id, writeId))
+                return true;
+            return m.sequence > cursor && !(handed !== undefined && writeId !== undefined && handed.has(writeId));
+        };
+        return {
+            backlog: stored.filter(unread).sort((a, b) => a.sequence - b.sequence),
+            queued: queued.filter((m) => !handed?.has(m.writeId) || wasReturned(undefined, m.writeId)),
+        };
+    }
+    /**
+     * A reader fork that never read what it was handed: its derive failed, or
+     * its run threw before it reported. While the epoch that held the
+     * messages is still active, they go back to that epoch's backlog for the
+     * channel, and its next invocation for the channel is handed them: the
+     * scope's while the scope is active, though the channel's own tune-out
+     * has taken the channel meanwhile, and a channel's own tune-out's while it
+     * holds the channel. Once the epoch has ended, its cancel's last fork was
+     * handed only what no fork had been, so a fork still running then is the
+     * only reader its messages had: one late fork is handed them instead
+     * (lateFork). Returns how many went back or to the late fork.
+     */
+    readerFailed(invocation) {
+        const { serverId, channelId, epochId } = invocation;
+        const active = this.getAllExcept()?.params.epochId === epochId
+            || this.channelRegistry.getTuneOutState(serverId, channelId)?.params.epochId === epochId;
+        if (!active)
+            return this.lateFork(invocation);
+        const key = this.handOffKey(epochId, serverId, channelId);
+        const returned = this.readerReturned.get(key) ?? { ids: new Set(), writeIds: new Set() };
+        for (const m of invocation.backlog)
+            returned.ids.add(m.id);
+        for (const m of invocation.queued)
+            returned.writeIds.add(m.writeId);
+        const count = invocation.backlog.length + invocation.queued.length;
+        if (count > 0) {
+            this.readerReturned.set(key, returned);
+            // They count again toward the next cadence look of the epoch holding
+            // the channel, which hands them back. Where another epoch holds it
+            // now, they're counted again when the channel comes back to theirs
+            // (rebuildTally), and its release hands them in any case.
+            const tally = this.key(serverId, channelId);
+            if (this.holdFor(serverId, channelId)?.epochId === epochId) {
+                this.divertedSinceInvocation.set(tally, (this.divertedSinceInvocation.get(tally) ?? 0) + count);
+            }
+        }
+        return count;
+    }
+    /**
+     * A fork that failed after its epoch ended: one late fork is handed what it
+     * was, with a notice saying a reader handed them failed after the tune-out
+     * ended. Those still queued when it was handed that have landed since are
+     * handed as stored. A late fork's own failure derives no other, so a
+     * reader that keeps failing costs one more fork, not a chain of them.
+     * Returns how many the late fork was handed.
+     */
+    lateFork(invocation) {
+        if (!this.hooks.invokeReader || this.lateForks.has(invocation))
+            return 0;
+        const { serverId, channelId, epochId } = invocation;
+        const landed = new Map();
+        for (const m of this.hooks.getStoredMessages()) {
+            const writeId = writeIdOf(m);
+            if (writeId !== undefined)
+                landed.set(writeId, m);
+        }
+        const backlog = [...invocation.backlog, ...invocation.queued.flatMap((m) => landed.get(m.writeId) ?? [])]
+            .sort((a, b) => a.sequence - b.sequence);
+        const queued = invocation.queued.filter((m) => !landed.has(m.writeId));
+        const count = backlog.length + queued.length;
+        if (count === 0)
+            return 0;
+        const these = count === 1 ? 'This message was' : `These ${count} messages were`;
+        const notice = `[${NOTICE_TAG.tuneOutCancelled}: ${this.shown(serverId, channelId)} — ${these} handed to a reader that `
+            + `failed after the tune-out ended, so no reader has read ${count === 1 ? 'it' : 'them'} yet.]`;
+        const entries = Object.entries(this.readDispositions());
+        const late = {
+            serverId,
+            channelId,
+            epochId,
+            trigger: 'cancel',
+            notice,
+            backlog,
+            queued,
+            dispositions: entries.length > 0 ? entries.map(([k, v]) => `- ${k}: ${v}`).join('\n') : null,
+        };
+        this.lateForks.add(late);
+        this.hooks.invokeReader(late);
+        return count;
+    }
+    /**
+     * The held messages still queued behind the resident's turn that `keep`
+     * keeps, oldest first, with their write ids. One the host gives no id for
+     * is left to reach a reader once it is stored: without the id, its stored
+     * row couldn't be told from a message no reader has had.
+     */
+    queuedHeld(keep) {
+        return (this.hooks.getDeferredMessages?.() ?? [])
+            .filter((m) => typeof m.writeId === 'string' && keep(m));
     }
     // ==========================================================================
     // Dispositions (standing notes, snapshot slot)
@@ -585,7 +1462,7 @@ export class TuneOutCoordinator {
             position: 'system',
             content: [{
                     type: 'text',
-                    text: `[Standing dispositions]\n${entries.map(([k, v]) => `- ${k}: ${v}`).join('\n')}`,
+                    text: `[${NOTICE_TAG.standingDispositions}]\n${entries.map(([k, v]) => `- ${k}: ${v}`).join('\n')}`,
                 }],
         };
     }
@@ -629,7 +1506,12 @@ export class TuneOutCoordinator {
     // ==========================================================================
     async handleSubconsciousTool(name, input, 
     /** The calling turn's own channels, for a call made inside it (the framework's callOwnChannels). */
-    own = []) {
+    own = [], 
+    /** The calling agent: the persistent subconscious, or a reader fork. */
+    caller, 
+    /** A reader fork, with the epoch it was derived to read, if any: it ends and posts only through that epoch's
+     *  hold (forkRefusal). The persistent subconscious, which reads every epoch, passes none. */
+    fork) {
         switch (name) {
             case 'deliver_summary': {
                 const text = String(input.text ?? '').trim();
@@ -643,20 +1525,22 @@ export class TuneOutCoordinator {
                     };
                 }
                 const subName = this.hooks.subconsciousName();
-                if (!subName)
+                // Verbatim, under its own participant name, into the resident's window
+                // (or, from a reader fork, as its attributed mail), tagged with the
+                // channel the name means and its server, since the framework reads a
+                // conversational row's channel (repinChannel). The name means what it
+                // means to every channel tool: inside the calling turn, the id of one
+                // of the turn's own channels means that channel, refused where its
+                // server no longer registers it or the turn has channels with that id
+                // on two servers (ownChannelFor); otherwise a name several registered
+                // channels answer to is refused with them (sharedNameRefusalFor). So
+                // no row is left for a re-pin to read as another server's channel. A
+                // name no registered channel answers to is kept as given, with no
+                // server, which a re-pin reads by name when it weighs the row, as it
+                // reads any message without its server.
+                if (!subName && !(caller && this.hooks.deliverFromReader)) {
                     return { success: false, error: 'subconscious not configured', isError: true };
-                // Verbatim, under its own participant name, into the resident's window,
-                // tagged with the channel the name means and its server, since the
-                // framework reads a conversational row's channel (repinChannel). The
-                // name means what it means to every channel tool: inside the calling
-                // turn, the id of one of the turn's own channels means that channel,
-                // refused where its server no longer registers it or the turn has
-                // channels with that id on two servers (ownChannelFor); otherwise a
-                // name several registered channels answer to is refused with them
-                // (sharedNameRefusalFor). So no row is left for a re-pin to read as
-                // another server's channel. A name no registered channel answers to
-                // is kept as given, with no server, which a re-pin reads by name when
-                // it weighs the row, as it reads any message without its server.
+                }
                 const mine = this.channelRegistry.ownChannelFor(channelId, own, 'deliver');
                 if (mine && 'error' in mine)
                     return { success: false, error: mine.error, isError: true };
@@ -664,33 +1548,87 @@ export class TuneOutCoordinator {
                 if (shared)
                     return { success: false, error: shared, isError: true };
                 const [named] = mine ? [mine.channel] : this.channelRegistry.channelsNamed(channelId);
-                this.hooks.addMessage(subName, [{ type: 'text', text }], {
+                const metadata = {
                     kind: 'subconscious-summary',
                     ...(named ? { channelId: named.channelId, serverId: named.serverId } : { channelId }),
-                });
+                };
+                if (subName) {
+                    this.hooks.addMessage(subName, [{ type: 'text', text }], metadata);
+                    return { success: true, data: { delivered: true } };
+                }
+                // A reader fork's report: attributed mail under its own name. The fork
+                // counts as having reported only once the mail is held: a delivery
+                // that throws is an error result to the fork, and its prose is then
+                // still delivered as its report when it ends (#546, probe R14).
+                this.hooks.deliverFromReader(caller, [{ type: 'text', text }], metadata);
+                this.readerReports.add(caller);
                 return { success: true, data: { delivered: true } };
             }
             case 'cancel_tuneout': {
                 const name = String(input.channelId ?? '');
+                const note = typeof input.text === 'string' && input.text.trim() ? input.text.trim() : undefined;
+                const endScope = () => {
+                    const scope = this.getAllExcept();
+                    const refused = fork && scope
+                        ? this.forkRefusal(fork, { epochId: scope.params.epochId }, 'cancel', "the all-except hold isn't the hold you were started to read")
+                        : undefined;
+                    if (refused)
+                        return { success: false, error: refused, isError: true };
+                    const result = this.cancelAllExcept('subconscious', 'subconscious judgment', note, caller);
+                    return result.ok
+                        ? { success: true, data: { cancelled: true, scope: 'all-except' } }
+                        : { success: false, error: result.error, isError: true };
+                };
+                // A call naming the all-except scope ends that hold outright, as the
+                // tool describes it and as the resident's tune_out cancel does: the
+                // channel it names, tuned out on its own or not, doesn't turn it
+                // into that channel's cancel, and with no hold it ends nothing.
+                if (input.scope === 'all-except')
+                    return endScope();
+                const serverId = typeof input.serverId === 'string' && input.serverId ? input.serverId : undefined;
                 // The name means what it means to every channel tool, the
-                // resident's tune_out included: inside the calling turn, the id of
-                // one of the turn's own channels means that channel (ownChannelFor);
-                // otherwise a name several registered channels answer to is refused
+                // resident's tune_out included: with a serverId, that server's
+                // channel with the id; inside the calling turn, the id of one of the
+                // turn's own channels means that channel (ownChannelFor); otherwise a
+                // name several registered channels answer to picks none of them
                 // (channelsNamed), whichever of them is tuned out, never taken to be
-                // the tuned-out one.
-                const mine = this.channelRegistry.ownChannelFor(name, own);
-                if (mine && 'error' in mine)
-                    return { success: false, error: mine.error, isError: true };
-                const named = mine ? [mine.channel] : this.channelRegistry.channelsNamed(name);
-                const shared = mine ? undefined : this.channelRegistry.sharedNameRefusalFor(name);
-                if (shared)
-                    return { success: false, error: shared, isError: true };
-                const channel = named[0];
+                // the tuned-out one. A name that picks no channel, such a name or one
+                // of the turn's own channels that ownChannelFor refuses, is refused,
+                // unless the call names the all-except scope, which ends that hold
+                // below.
+                const mine = serverId ? undefined : this.channelRegistry.ownChannelFor(name, own);
+                const refusal = mine && 'error' in mine ? mine.error
+                    : serverId || mine ? undefined : this.channelRegistry.sharedNameRefusalFor(name);
+                const named = serverId ? [{ serverId, channelId: name }]
+                    : mine && 'channel' in mine ? [mine.channel] : this.channelRegistry.channelsNamed(name);
+                const channel = refusal ? undefined : named[0];
                 if (!channel || !this.channelRegistry.getTuneOutState(channel.serverId, channel.channelId)) {
-                    return { success: false, error: this.notTunedOut(name, 'the resident'), isError: true };
+                    // The reader keeps its latitude over the all-except hold too: a
+                    // channel it holds (or the scope named as the channel) ends the
+                    // scope. A call naming the scope "channel" ends only a channel's
+                    // own tune-out, so on a channel only the scope holds it ends
+                    // nothing.
+                    const scope = this.getAllExcept();
+                    const heldByScope = scope && (name === 'all-except'
+                        || (channel !== undefined && this.holdFor(channel.serverId, channel.channelId)?.epochId === scope.params.epochId));
+                    if (!heldByScope)
+                        return { success: false, error: refusal ?? this.notTunedOut(JSON.stringify(name), 'the resident'), isError: true };
+                    if (input.scope === 'channel') {
+                        const shown = channel ? this.quotedShown(channel.serverId, channel.channelId) : JSON.stringify(name);
+                        return {
+                            success: false,
+                            error: `Nothing was cancelled: ${shown} isn't tuned out on its own, and scope "channel" ends only a channel's own `
+                                + 'tune-out. The all-except hold holds it, and calling cancel_tuneout with scope "all-except" ends that hold.',
+                            isError: true,
+                        };
+                    }
+                    return endScope();
                 }
-                const note = typeof input.text === 'string' && input.text.trim() ? input.text.trim() : undefined;
-                const result = this.cancel(channel.serverId, channel.channelId, 'subconscious', 'subconscious judgment', note);
+                const held = this.channelRegistry.getTuneOutState(channel.serverId, channel.channelId);
+                const refused = fork && this.forkRefusal(fork, { epochId: held.params.epochId }, 'cancel', `the tune-out on ${this.quotedShown(channel.serverId, channel.channelId)} isn't the hold you were started to read`);
+                if (refused)
+                    return { success: false, error: refused, isError: true };
+                const result = this.cancel(channel.serverId, channel.channelId, 'subconscious', 'subconscious judgment', note, caller);
                 return result.ok
                     ? { success: true, data: { cancelled: true } }
                     : { success: false, error: result.error, isError: true };
@@ -746,14 +1684,44 @@ export class TuneOutCoordinator {
                 const mine = this.channelRegistry.ownChannelFor(channelId, own, 'publish');
                 if (mine && 'error' in mine)
                     return { success: false, error: mine.error, isError: true };
-                return this.channelRegistry.publishForAgent(mine ? mine.channel : channelId, text, this.hooks.subconsciousName() ?? 'Subconscious');
+                if (fork) {
+                    const named = mine ? [mine.channel] : this.channelRegistry.channelsNamed(channelId);
+                    const at = named.length === 1 ? named[0] : undefined;
+                    const hold = at ? this.holdFor(at.serverId, at.channelId) : null;
+                    const shown = at ? this.quotedShown(at.serverId, at.channelId) : JSON.stringify(channelId);
+                    const refused = (at || fork.epochId === undefined) && this.forkRefusal(fork, hold, 'speech', hold
+                        ? `${shown} is held by a hold other than the one you were started to read`
+                        : `${shown} isn't held now`);
+                    if (refused)
+                        return { success: false, error: refused, isError: true };
+                }
+                return this.channelRegistry.publishForAgent(mine ? mine.channel : channelId, text, this.hooks.subconsciousName() ?? caller ?? 'Subconscious');
             }
             default:
                 return { success: false, error: `unknown subconscious tool: ${name}`, isError: true };
         }
     }
     /**
-     * A cancel of a channel that isn't tuned out, by the name the caller gave
+     * Why a reader fork may not act through `hold` (the epoch holding what its
+     * call names, or null): a fork ends and posts only through the hold of the
+     * epoch it was derived to read, and one derived for none acts through no
+     * hold. Undefined where the hold is its own. `why` says, for the fork, how
+     * what its call names isn't its own hold; its reports stay open to it.
+     */
+    forkRefusal(fork, hold, act, why) {
+        if (fork.epochId !== undefined && hold?.epochId === fork.epochId)
+            return undefined;
+        const nothing = act === 'cancel' ? 'Nothing was cancelled' : 'Nothing was posted';
+        const report = `Your report can say what you would ${act === 'cancel' ? 'judge of it' : 'have posted'}, and the resident reads it.`;
+        if (fork.epochId === undefined) {
+            return `${nothing}: you weren't started to read a tune-out, so there's no hold you can `
+                + `${act === 'cancel' ? 'end' : 'post through'}. ${report}`;
+        }
+        const rule = act === 'cancel' ? 'a reader ends only its own' : 'a reader posts only into a channel its own hold holds';
+        return `${nothing}: ${why}, and ${rule}. ${report}`;
+    }
+    /**
+     * A cancel of a channel that isn't tuned out, by the name, quoted, the caller gave
      * or knows it by: which channels are, so the next call can name one, and
      * how a tune-out ends without one. `backlogTo`
      * names the resident as the message's reader knows it: "you" to the
@@ -763,15 +1731,28 @@ export class TuneOutCoordinator {
      * neither this list nor the name's lookup (channelsNamed, which reads the
      * registered channels too), and the text claims nothing about it.
      */
-    notTunedOut(name, backlogTo) {
-        const active = this.listActive().map((e) => JSON.stringify(this.shown(e.serverId, e.channelId)));
+    notTunedOut(quoted, backlogTo) {
+        const active = this.listActive().map((e) => this.quotedShown(e.serverId, e.channelId));
         const opening = active.length === 0
             ? 'no connected channel is tuned out now.'
-            : `no connected channel ${JSON.stringify(name)} is tuned out. Connected channels tuned out now: `
+            : `no connected channel ${quoted} is tuned out. Connected channels tuned out now: `
                 + `${active.join(', ')}.`;
         return `Nothing was cancelled: ${opening} A tune-out also ends by itself when its duration runs out, or at the `
             + `first wake past its wake budget, and its backlog goes to ${backlogTo} then.`;
     }
+    /**
+     * The reader ended, not the framework: its turns stop (cadence and
+     * coalescing wakes), and every hold keeps its end time, which releases it
+     * to the resident with no reader.
+     */
+    stopReader() {
+        for (const timer of this.cadenceTimers.values())
+            clearTimeout(timer);
+        this.cadenceTimers.clear();
+        for (const { timer } of this.pendingWakes.values())
+            clearTimeout(timer);
+        this.pendingWakes.clear();
+    }
     /** Stop all timers (framework shutdown). */
     stop() {
         for (const timer of this.cadenceTimers.values())