@animalabs/agent-framework 0.32.0 → 0.33.0

package/dist/src/tune-out/coordinator.d.ts

@@ -16,8 +16,9 @@
  */
 import type { ContentBlock } from '@animalabs/membrane';
 import type { StoredMessage } from '@animalabs/context-manager';
-import type { ChannelRef, ChannelRegistry, TuneOutParams } from '../mcpl/channel-registry.js';
+import { type ChannelRef, type ChannelRegistry, type TuneOutParams } from '../mcpl/channel-registry.js';
 import type { McplServerRegistry } from '../mcpl/server-registry.js';
+import type { TraceEventInput } from '../types/trace.js';
 /** Defaults for tune_out tool params. */
 export declare const TUNE_OUT_DEFAULTS: {
     readonly cadenceSeconds: 1800;
@@ -41,30 +42,94 @@ export interface ReaderInvocation {
     trigger: 'cadence' | 'wake' | 'cancel';
     /** The host-framed notice for this invocation (bracket style). */
     notice: string;
-    /** Held messages not yet handed to any reader fork, oldest first. */
-    backlog: StoredMessage[];
     /**
-     * Held messages not yet handed to any reader fork that are still queued
-     * behind the resident's turn (admitted, not yet stored), oldest first.
-     * They come after `backlog` in arrival order. A reader is most useful
-     * while the resident is busy, which is exactly when its traffic is here
-     * rather than in the store.
+     * Held messages not yet handed to any reader fork, oldest first. A held
+     * message is stored as it arrives, whatever the resident's turn (#291), so
+     * a reader is handed what arrives while the resident is busy, which is
+     * when a reader is most useful.
      */
-    queued: QueuedHeldMessage[];
+    backlog: StoredMessage[];
     /** Standing dispositions, as text, or null when there are none. */
     dispositions: string | null;
 }
 /**
- * A held message admitted for the resident but not yet in its store: it was
- * deferred while a turn was alive. `writeId` is the deferred write's durable
- * id, which the stored row carries as `metadata.deferredWriteId` once it
- * lands.
+ * Where the persistent subconscious's window starts (#291, AF-5): at the
+ * oldest active tune-out's start, never forward past one, so a tune-out's
+ * reader sees every message it held. `sequence` is where the tune-out
+ * started in the record (its startedAtSequence), which places the start
+ * while the subconscious's window is the record. Once its window follows the
+ * presentation index, the start is a place in that window, an index
+ * ordinal, fixed once per tune-out and recorded (`ordinal`;
+ * TuneOutCoordinator.subconsciousWindowFixed), since a row stored before
+ * the start can be presented after it, and the sequence converted again
+ * then gives another window. `epochIds` are the active tune-outs starting
+ * there: one, or a channel's and the all-except hold's begun at the same
+ * sequence.
  */
-export type QueuedHeldMessage = Pick<StoredMessage, 'participant' | 'content' | 'metadata'> & {
-    writeId: string;
-    /** When the framework first held the write, in ms since the epoch. */
-    heldAt?: number;
-};
+export interface SubconsciousWindowStart {
+    sequence: number;
+    /** The start as the subconscious's index ordinal, once fixed for one of `epochIds`. */
+    ordinal?: number;
+    epochIds: readonly string[];
+    /**
+     * At a resume: `ordinal` is the start in force before the restart (a
+     * cancelled tune-out's, earlier than the start kept for `epochIds`), set
+     * again and kept as the start in force only, never as theirs.
+     */
+    inForceOnly?: true;
+    /**
+     * At a resume that finds no start in force kept: the anchor the
+     * subconscious's strategy persisted is kept, as the start in force only,
+     * where it is earlier than `ordinal`, the one kept for `epochIds` (a
+     * cancelled tune-out's start that was set but never kept), or, with no
+     * `ordinal` (their start fixed and set, its keeping failed), wherever it
+     * is: the sequence converted again could give a later start, once rows
+     * have been presented out of record order. Their own start is then fixed
+     * without moving the window to it.
+     */
+    keepEarlierAnchor?: true;
+}
+/**
+ * The answer to a cancel that waits for held writes (deferCancel): what it
+ * waits for, and what a stop meanwhile does. `noteDropped`: the caller's
+ * note isn't delivered, as the cancel already waiting carries one.
+ * `noteKept`: the caller's note waits with the cancel, and the answer says
+ * where it goes and what the caller is told of it. It is delivered when a
+ * cancel ends the hold, or tries to, else told lost to its author
+ * (tellNoteLost), a notice that can't be written being traced and
+ * tried again (writeLossNotices) until it is written, and, for the
+ * persistent subconscious (`persistent`), kept in the store too
+ * (writeLossRecord), so the next boot writes one a stop left unwritten
+ * (restoreLossNotices). Where another cancel ends the hold and the note
+ * can't be delivered then, the loss is told in that cancel's release
+ * (queuedNoteFirst), which the subconscious's window holds. A note written
+ * while writes are held again is kept in memory with them, the hold in
+ * force; where storing it when they are stored fails, the framework says
+ * so (heldWriteLost), and the note is told lost by a notice, as above, once
+ * the hold ends, or as one that may be lost where the store can't tell
+ * whether it landed, as is the stop's notice, or a hold's that ends
+ * without the cancel, before then (`noteUnknown`); it isn't written
+ * again. Stored then, it counts as delivered (heldWriteStored), even while
+ * the cancel still waits. The waiting
+ * cancel, and the note with it, is kept in memory only: a stop before the
+ * hold ends loses both, unless the stop's own wait for an operator's
+ * operation lets the hold end, which runs the cancel first (the
+ * framework's stop calls stop() only after that wait; stopTimers before
+ * it), or the note went out already (the cancel's run delivered it and
+ * failed before the end: the stop drops the cancel alone, dropQueued; AF
+ * #844 review 5, #26), and the subconscious is told of the note's loss
+ * as of any other, by a notice kept in the store for the next boot (stop),
+ * or, where the store refuses that or the host crashes, by the next boot's
+ * notice that any cancel then waiting was lost (noteUnstampedStop).
+ * The cancel can't wait for the delivery, which comes only when a cancel
+ * ends the hold, or tries to.
+ * A reader fork's (`fork`) goes out as its mail even after its run has
+ * ended (deliverReaderNote), but a notice of its loss reaches it only while
+ * it runs: an ended fork is no agent the framework writes to, and the loss
+ * is then traced only (writeLossNotice); a stop drops a fork's notice not
+ * yet written, and a fork's note not delivered yet is lost with the cancel.
+ */
+export declare function cancelWaitsNote(what: string, noteDropped?: boolean, noteKept?: 'persistent' | 'fork', unmarked?: boolean): string;
 /**
  * The all-except scope (issue #232 §3.2; focus folded into tune-out): a
  * resident-level policy epoch holding every channel but one, for a bounded
@@ -92,7 +157,12 @@ export interface AllExceptState {
     params: AllExceptParams;
     wakeCount: number;
 }
-/** `check`: what is held right now, without releasing anything. */
+/**
+ * `check`: what is held right now, without releasing anything. A hold's
+ * messages an earlier release of it delivered (its end not recorded, the
+ * hold still in force) are delivered, not held, and are counted and peeked
+ * no more: what is held is what its next release delivers (AF #844, Oscar).
+ */
 export interface TuneOutCheck {
     allExcept: {
         epochId: string;
@@ -114,6 +184,41 @@ export interface TuneOutCheck {
     /** Up to `peekLimit` newest held lines of the peeked channel, oldest first. */
     peek?: string[];
 }
+/** A row of the persistent subconscious's window as the boot reads it (subconsciousWindow). */
+export type WindowRow = Pick<StoredMessage, 'participant' | 'content' | 'metadata' | 'sequence'> & {
+    shardIndex?: number;
+};
+/**
+ * The rows of a window (`window`, the persistent subconscious's, `author`)
+ * that `keep` keeps and that come after its last row of its own: shown to
+ * it, and no turn of its since. A note of its that a cancel delivered is a
+ * row under its name but no turn of it (`subconscious-note`), so isn't its
+ * own here. A row stored in shards is one row: its first shard.
+ */
+export declare function unansweredIn(window: readonly WindowRow[], author: string, keep: (m: WindowRow) => boolean): WindowRow[];
+/** A `cancel_tuneout` call of the persistent subconscious's (cancelAsksIn). */
+export interface CancelAsk {
+    /** Its row's sequence. */
+    sequence: number;
+    input: Record<string, unknown>;
+    /** Its result answered it as waiting (`waiting: true`). */
+    waiting: boolean;
+    /** The server its result names, where it names one. */
+    serverId?: string;
+    /** The scope its result names (`all-except`), where it names one. */
+    scope?: string;
+}
+/**
+ * The `cancel_tuneout` calls a window (`window`, the persistent
+ * subconscious's, `author`) holds, its own rows', each with what its
+ * result, where the window holds it, answered: waiting or not, and the
+ * server and scope it names. A result row that isn't an answer's JSON (the
+ * tool-result guard's placeholder, its batch not settled) is read from
+ * `archived`, the original results by tool use id (the guard's audit,
+ * subconsciousGuardedResults), where it holds one. A result that isn't
+ * there, or isn't an answer, isn't waiting.
+ */
+export declare function cancelAsksIn(window: readonly WindowRow[], author: string, archived?: ReadonlyMap<string, unknown>): CancelAsk[];
 /**
  * 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`,
@@ -137,22 +242,57 @@ export interface TuneOutFrameworkHooks {
      * `reader: 'forks'`: deliver a reader fork's own words to the resident
      * as attributed mail (its name, its incarnation). Absent in persistent
      * mode, where the subconscious writes under its own name directly.
+     * Answers the row's id where it is written as a row, empty where that
+     * write was kept in memory; nothing for mail, which the registry keeps.
      */
-    deliverFromReader?: (reader: string, content: ContentBlock[], metadata: Record<string, unknown>) => void;
+    deliverFromReader?: (reader: string, content: ContentBlock[], metadata: Record<string, unknown>) => string | void;
     /** The primary resident's registry name. */
     primaryName: () => string | null;
-    /** Read the primary's stored messages (shared slot, unfiltered). */
+    /**
+     * Read the primary's stored messages (shared slot, unfiltered). A held
+     * message is stored as it arrives, even during the resident's turn, so
+     * this is every message an epoch holds (#232 gap 7), but for those a live
+     * surgery's hold keeps in memory, or that the primary's context manager,
+     * refusing its work, keeps until a branch move re-initializes it
+     * (heldForRecovery): getSurgeryHeldMessages.
+     */
     getStoredMessages: () => StoredMessage[];
     /**
-     * Messages admitted for the primary but not yet in its store (deferred
-     * while a turn was alive), oldest first. A cancel reads them too, so a
-     * message held mid-turn is in the backlog it belongs to (#232 gap 7).
+     * The writes for the primary's store kept in memory, in arrival order:
+     * those the primary's context manager, refusing its work, keeps until a
+     * branch move re-initializes it (heldForRecovery), which come first, then
+     * those a live surgery's hold keeps, made while the operator's switch is
+     * awaited, and stored, in that order, only at its release. A check during the hold
+     * counts and peeks a tune-out's held messages among them as it does the
+     * stored ones (#232 gap 7). A cancel waits for the release (writesHeld),
+     * so a dump lists them only where writesHeld throws and the cancel goes
+     * on during the hold. Left out, none are.
+     */
+    getSurgeryHeldMessages?: () => Array<Pick<StoredMessage, 'participant' | 'content' | 'metadata'>>;
+    /**
+     * Make what was just delivered durable, and answer whether it is: a cancel
+     * stores its release and makes it durable before it records the epoch's
+     * end (#232 gap 6), and a release that can't be (false) leaves the
+     * tune-out in force, the cancel throwing. Left out, a stored release
+     * counts as durable.
      */
-    getDeferredMessages?: () => Array<Pick<StoredMessage, 'participant' | 'content' | 'metadata'> & {
-        writeId?: string;
-        heldAt?: number;
-    }>;
     commitDeliveries?: () => boolean;
+    /**
+     * Whether a write the coordinator made now would be kept in memory rather
+     * than stored: a live surgery's hold, or a context manager of the primary
+     * or the subconscious refusing its work until a branch move re-initializes it.
+     * A cancel then waits (deferCancel), the tune-out still in
+     * force, until the framework says the writes are stored again, or told of
+     * where storing one fails (runDeferredCancels), so the release is in the
+     * store before the epoch's end is recorded. With `forAgent` (a loss
+     * notice's author, a reader fork's or the subconscious's), whether a write
+     * for that agent would be kept: a surgery's hold or its replay, or that
+     * agent's own manager refusing its work or waiting for its recovery; not
+     * the primary's or the subconscious's, which keep their own agent's writes
+     * alone. The loss notices are written by that answer, even while the
+     * release's is true (AF #844 review 5, #53). Left out, never.
+     */
+    writesHeld?: (forAgent?: string) => boolean;
     /**
      * The history-reading tool the resident actually has (e.g. a server's
      * `fetch_history`), or null. A truncation note names it only when it exists
@@ -169,20 +309,80 @@ export interface TuneOutFrameworkHooks {
     residentMessageChars?: () => number | undefined;
     /** Current chronicle head sequence (window anchor for new epochs). */
     currentSequence: () => number;
-    /** Move the subconscious window anchor (never forward past active epochs). */
-    setSubconsciousAnchor: (sequence: number) => void;
+    /**
+     * The name of the store's branch now, whose sequences currentSequence
+     * counts: the stop stamp names it with its run's start (StopStamp). Left
+     * out, none is named, and a stamp's start is read on any branch.
+     */
+    currentBranch?: () => string;
+    /**
+     * The branch `name` was made from (`parent`, by name) and the sequence it
+     * was made at (`branchPoint`: it holds the parent's rows up to there, at
+     * the same sequences), where the store says; undefined for a branch made
+     * from none, or where the host can't say. A move to a branch made from
+     * this run's at a point past this run's start keeps that start for it
+     * (branchMoved). Left out, a move's destination is read from its head.
+     */
+    branchOrigin?: (name: string) => {
+        parent: string;
+        branchPoint: number;
+    } | undefined;
+    /**
+     * Move the subconscious window anchor to `start`, the oldest active
+     * tune-out's (never forward past active epochs): by its sequence while
+     * the subconscious's window is the record, by its ordinal once that is
+     * known, and else by an ordinal the framework fixes for it and reports
+     * (subconsciousWindowFixed). `others` are the other active tune-outs'
+     * starts whose ordinal isn't kept yet, which the framework fixes and
+     * reports the same way without moving the window to them.
+     */
+    setSubconsciousAnchor: (start: SubconsciousWindowStart, others?: readonly SubconsciousWindowStart[]) => void;
+    /**
+     * Whether the subconscious's window keeps index ordinals (its context
+     * manager presents rows, #291), so each tune-out's window start is kept as
+     * one (`subconscious/<primary>/window-starts`). Left out, or false, none
+     * is kept or read, and the anchor goes by sequence alone.
+     */
+    subconsciousWindowOrdinals?: () => boolean;
+    /**
+     * How many of the residents' stored messages `keep` keeps that the
+     * persistent subconscious hasn't been shown yet: with the presentation
+     * index, those its window doesn't hold; else those stored after its last
+     * compile. A cancel the subconscious makes itself gives it a report turn
+     * when any of its tune-out's are, since it wrote its note without them.
+     * Left out, none are.
+     */
+    unseenBySubconscious?: (keep: (m: Pick<StoredMessage, 'metadata'>) => boolean) => number;
+    /**
+     * The persistent subconscious's window, as written down (its presented
+     * rows): a boot reads it for the losses told to it whose turn a stop lost
+     * (askTurnsForUnreadLosses), for its own cancels of a hold the last stop
+     * didn't stamp, and for what it was told of that stop already
+     * (noteUnstampedStop). Left out, or with no subconscious, none.
+     */
+    subconsciousWindow?: () => readonly WindowRow[];
+    /**
+     * The persistent subconscious's own stored rows (its slot's record),
+     * presented or not: a boot reads them for the notices written to it
+     * already (lossNoticeId, stopUnrecorded, lostAtStop), which its window
+     * doesn't hold yet where its presentation is frozen (a quiesced boot) or
+     * a crash came before it presented them. Left out, its window alone.
+     */
+    subconsciousStoredMessages?: () => readonly WindowRow[];
+    /**
+     * The persistent subconscious's tool results as the tool-result guard
+     * archived them before it stored their placeholders (its audit's staged
+     * batches), by tool use id: a boot reads one where a crash before the
+     * guard settled left the placeholder for the result (cancelAsksIn). Left
+     * out, or with no guard's audit, none.
+     */
+    subconsciousGuardedResults?: () => ReadonlyMap<string, unknown>;
     /** True when a channel is bound to a conversation-fork agent. */
     isForkBound: (channel: ChannelRef) => boolean;
     /** Gate privileged-users list (#77: privileged authors wake, like mentions). */
     isPrivilegedAuthor: (authorId: string | null | undefined) => boolean;
     /** speak_in_channel master switch (recipe-side, canary-gated). */
     allowChannelSpeech: () => boolean;
-    /**
-     * Whether a tune-out may hold a channel with no reader at all — a silent
-     * hold (issue #232 §3.3), which the host opts into (`tuneOut.enabled`).
-     * Left out, or false, a hold with no reader is refused.
-     */
-    holdWithoutReader?: () => boolean;
     /**
      * Post a line into a channel under the resident's name. Used for the
      * all-except scope's entry and release announcements in the excepted
@@ -193,10 +393,7 @@ export interface TuneOutFrameworkHooks {
         success: boolean;
         error?: string;
     }>;
-    emitTrace: (event: {
-        type: string;
-        [key: string]: unknown;
-    }) => void;
+    emitTrace: (event: TraceEventInput) => void;
 }
 export declare class TuneOutCoordinator {
     private readonly channelRegistry;
@@ -209,6 +406,20 @@ export declare class TuneOutCoordinator {
      *  the end time does when its cancel finds the tune-out already ended,
      *  and the channel's next accepted enter does in any case. */
     private expiryTimers;
+    /** A releaseAll asked to retry its failures (a reader that ended): the next try. */
+    private releaseRetry;
+    /** stop() has run: no timer is armed after it. */
+    private stopped;
+    /**
+     * stop() has kept what it found (keepAtStop): a loss told after it (a
+     * trace listener's stop, during a cancel's run or a notice's write) is
+     * kept as it kept those (keepAfterStop).
+     */
+    private stopDone;
+    /** The holds the stop's stamp left out (writeStopStamp), which a stamp written again after it leaves out too. */
+    private stopUnaccounted;
+    /** The holds the stop left out of its stamp because a waiting cancel's note was still kept in memory (StopStamp's `notesKept`). */
+    private stopNotesKept;
     /** Channels with a wake invocation pending inside the coalescing window. */
     private pendingWakes;
     /**
@@ -239,19 +450,11 @@ export declare class TuneOutCoordinator {
      * held, which is the right side to err on.
      */
     private readerCursor;
-    /**
-     * `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.
-     */
-    private readerHandedWrites;
     /**
      * `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.
+     * per epoch and channel, by id: its derive failed, or its run threw before
+     * it reported (readerFailed). The next invocation is handed them again,
+     * cursor or no. Cleared with the cursor.
      */
     private readerReturned;
     /**
@@ -261,6 +464,110 @@ export declare class TuneOutCoordinator {
     private lateForks;
     /** The all-except scope's durable record, cached (undefined = not read yet). */
     private scopeCache;
+    /**
+     * Cancels asked for while the framework keeps writes in memory
+     * (writesHeld), by channel key, the all-except hold's under SCOPE_KEY:
+     * each runs as it was asked, with its note, or a later cancel's when it
+     * had none (deferCancel), once the writes are stored again, or told of
+     * where storing one fails (runDeferredCancels). Each is for the epoch it
+     * was asked for (`for`), and ends that one only: one whose epoch no longer
+     * holds is dropped, told (dropDeferred), never run against a later one.
+     * In memory: a restart before then finds the tune-out still in force,
+     * and an end time that passed cancels it at once (resumeActiveEpochs); a
+     * note one carries is told lost at the stop, its notice kept in the store
+     * for the persistent subconscious (stop).
+     */
+    private readonly deferredCancels;
+    /**
+     * The notices to a lost queued note's author that weren't written yet
+     * (tellNoteLost), by author, in the order the losses came: each is tried
+     * again, by runDeferredCancels, at the next release and at the retry,
+     * until it is written. Those for the persistent subconscious are kept in
+     * the store too (writeLossRecord), and stay there at stop for the next
+     * boot to write (restoreLossNotices); a reader fork's are in memory only,
+     * cleared at stop, as the deferred cancels are.
+     */
+    private readonly lossNotices;
+    /**
+     * The persistent subconscious's kept notices as the store's record was
+     * last written or read (writeLossRecord, readLossRecord), so that it is
+     * written only when they change.
+     */
+    private lossRecordShape;
+    /**
+     * The record may not hold the notices kept in memory: its write failed,
+     * or was put off while writes were held. The next change, or the stop,
+     * writes it.
+     */
+    private lossRecordStale;
+    /** The record couldn't be read: nothing is written over it until it can be (readLossRecord). */
+    private lossRecordUnread;
+    /**
+     * The store's head sequence when this run began (noteUnstampedStop), which
+     * the stop's stamp names, so that the next boot reads only this run's rows
+     * for what became of a note. Undefined until the boot, or where it
+     * couldn't be read.
+     */
+    private runStartedAt;
+    /** The branch `runStartedAt` is a place on (currentBranch), where the host names one. */
+    private runBranch;
+    /** Where this run's rows begin on each branch it has been on, by branch (branchMoved): a move back to one keeps its start. */
+    private readonly runStarts;
+    /**
+     * The bound the last stop's stamp gave this boot's reading of that run
+     * (its `runStartedAt` and `branch`), kept while a notice the boot derived
+     * from it is kept in memory only (stampNoticesUnkept): this run's stamp
+     * carries it then (runBound), so a crash meanwhile leaves the next boot
+     * reading the same rows, and telling the same.
+     */
+    private carriedBound;
+    /** The ids of the notices the store's loss record holds, as last written or read (writeLossRecord, readLossRecord). */
+    private lossRecordIds;
+    /**
+     * This run's stamp (noteUnstampedStop) where the store refused it at boot,
+     * tried again until it lands (writePendingMarker); a stop's own stamp
+     * replaces it. Meanwhile a waiting cancel's answer to the persistent
+     * subconscious says the host's death before the cancel runs may go untold.
+     */
+    private markerPending;
+    /** A write of `markerPending` failed, which was logged (once). */
+    private markerUnwritten;
+    /**
+     * The boot's telling of the last stop's stamp (tellUnstampedHolds) threw
+     * before it finished, so a hold it didn't reach may be told nothing: the
+     * carried bound stays for the run (carriedNeeded), so a crash leaves the
+     * next boot reading those rows again.
+     */
+    private carriedUntold;
+    /**
+     * The notices of an unrecorded stop (`unstamped-stop`) this boot wrote
+     * from the store's record (restoreLossNotices): told, though the
+     * subconscious's window may not hold them yet (a quiesced boot), as the
+     * boot's own reading of the stamp counts them (noteUnstampedStop).
+     */
+    private restoredTold;
+    /**
+     * The ids of the notices the boot read from the store's record whose
+     * rows it couldn't read (restoreLossNotices): each may be written already,
+     * so none is written until a try reads those rows (checkLossNoticesWritten).
+     */
+    private readonly lossNoticesUnchecked;
+    /** The authors whose loss notice is being written now (writeLossNotices): a loss told for one meanwhile waits behind it. */
+    private readonly lossNoticesWriting;
+    /** The host's stop has begun (stopTimers): a turn asked for from here on is dropped with the stop's closed queue. */
+    private timersStopped;
+    /** The release turns asked for while the stop was under way (StopStamp's `wakesOwed`), for the stop's stamp. */
+    private readonly wakesInStop;
+    /** The release turns this run asked for, by whose: a boot that asks one for its own release asks none again for the last stop's. */
+    private readonly releaseTurnsAsked;
+    /**
+     * The one retry of the deferred cancels whose run threw (a release that
+     * couldn't be made durable, a store operation that threw), and of the
+     * loss notices not written (lossNotices), armed by runDeferredCancels and
+     * tellNoteLost, unref'd, cleared at stop. A later release's
+     * runDeferredCancels runs them sooner.
+     */
+    private deferredRetry;
     /** Timer key for the scope's cadence and expiry. */
     private static readonly SCOPE_KEY;
     constructor(channelRegistry: ChannelRegistry, serverRegistry: McplServerRegistry, hooks: TuneOutFrameworkHooks);
@@ -279,9 +586,104 @@ export declare class TuneOutCoordinator {
      *  cancel_tuneout take back; or, for a channel no string picks alone, its
      *  id and its server. */
     private shown;
+    /**
+     * Every message of the primary's store, in arrival order: those stored,
+     * then those a live surgery's hold keeps in memory until its release
+     * (getSurgeryHeldMessages). What a check counts and peeks, and what a
+     * dump lists: a dump made during the hold, which a cancel makes only
+     * where writesHeld throws, still has what the tune-out held then. A
+     * reader is handed stored rows only (getStoredMessages): those the hold
+     * keeps have no id until stored, and the dump has them.
+     */
+    private residentMessages;
     private quotedShown;
     /** Restart cadence + expiry timers and re-anchor after a process restart. */
     resumeActiveEpochs(): void;
+    /**
+     * At boot (resumeActiveEpochs), after this boot's own releases (an end
+     * time passed, a wake budget spent): each hold on record then still in
+     * force whose release the resident has, stored before this boot (a
+     * `tune-out-cancel` row of its epoch), its end never recorded. The
+     * resident read "[Tune-out: … cancelled …]", and nothing said the
+     * tune-out still stood: a stop whose wait for an operator's operation ran
+     * out, the hold's release after it storing the release, or a throw
+     * between a cancel's release and its end (a store fault). It is told,
+     * once, by a row in the residents' slot (`tune-out-end-unrecorded`) that
+     * the release reached it but the end wasn't recorded, so the tune-out is
+     * still in force, what arrives there held for its next release, and how
+     * it ends; the release row stays as the record of the release. A row of
+     * that kind for the epoch after its latest release silences a later boot;
+     * a release after it (another cancel that failed at its end) is told
+     * again. The subconscious, whose window holds the residents' rows, reads
+     * it too. A write that throws is logged, and tried at the next boot
+     * (AF #844, Oscar). Never throws.
+     */
+    private tellResidentUnended;
+    /** The epochs of the tune-outs active now, a channel's and the all-except hold (the anchor's branchMoved reads them). */
+    activeEpochIds(): string[];
+    /** The tune-outs active now, a channel's and the all-except hold, with where each started in the record. */
+    private activeStarts;
+    /**
+     * Set the subconscious's window start to the oldest active tune-out's
+     * (setSubconsciousAnchor), with its ordinal when one was fixed for it. The
+     * all-except hold counts with the channels' tune-outs, wherever this is
+     * called, so a channel's tune-out entered during an older hold leaves the
+     * start at the hold's. Nothing when none is active: the anchor stays where
+     * it was, as a cancel leaves it.
+     *
+     * A cancel leaves the start where it was while another tune-out stays
+     * active too, so the subconscious's report on the one cancelled still has
+     * what it held, and the start in force is kept (`inForce`). At a resume
+     * that start is set again rather than the oldest active tune-out's, which
+     * is later than it once the oldest was cancelled: so the window is the
+     * same across a restart. An enter sets the oldest active tune-out's, as it
+     * always has. Where the window presents, the other active tune-outs whose
+     * start isn't kept yet go with it, for the framework to fix as soon as
+     * each can be: the oldest one's too, where a resume sets the start in
+     * force instead of it.
+     */
+    private anchorSubconscious;
+    /** Where each active tune-out's window start is kept, by ordinal: a snapshot state, on each branch its own. */
+    private get windowStartsStateId();
+    /** Whether the subconscious's window keeps ordinals, so its starts are kept (subconsciousWindowOrdinals). */
+    private ordinalsKept;
+    /**
+     * Each tune-out's window start as an ordinal, by epoch id, as kept on the
+     * store's branch now, and the start in force (`inForce`: the ordinal the
+     * window start was last set to while a tune-out is active), which a
+     * restart sets again (anchorSubconscious). A state that isn't this format
+     * (`{ v: 1, starts, inForce? }`) reads as none kept, and is written over
+     * at the next fix, with a line saying so. A read that throws answers null:
+     * what is kept can't be told, so nothing is written over it (a fix isn't
+     * kept, and is tried again at the next presentation), and the window
+     * start isn't moved. A state an earlier version kept, with no `inForce`,
+     * reads as one with none in force, and a restart sets the oldest active
+     * tune-out's start, or the anchor the subconscious's strategy persisted
+     * where that is earlier (keepEarlierAnchor).
+     */
+    private readWindowState;
+    /** Keep `state`, answering whether it was written; a write that fails is logged, and the anchor the strategy holds stays as it is. */
+    private writeWindowState;
+    /**
+     * The framework fixed the subconscious's window start for `epochIds` at
+     * `ordinal` (its index ordinal, #291): kept for each of them still active,
+     * so a later anchor (another tune-out's enter, a restart) sets that
+     * ordinal again rather than converting the tune-out's sequence anew, and
+     * kept as the start in force while any tune-out is active, which a
+     * restart sets again (anchorSubconscious), when it is the start in force
+     * (`inForce`; another active tune-out's start fixed beside it isn't).
+     * Answers whether it is kept, so that the anchor tries again at its next
+     * presentation when it isn't: not when the record can't be read, which
+     * is never written over then.
+     */
+    subconsciousWindowFixed(epochIds: readonly string[], ordinal: number, inForce?: boolean): boolean;
+    /**
+     * An ended tune-out's window start goes, and, once none is active, the
+     * start in force with it: the next enter sets its own.
+     */
+    private forgetWindowStart;
+    /** The window starts of tune-outs no longer active go. */
+    private pruneWindowStarts;
     private armExpiry;
     /** A timer callback's work threw. Report it on stderr and as a trace rather
      *  than throw it into the event loop, where an uncaught exception ends the
@@ -314,18 +716,638 @@ export declare class TuneOutCoordinator {
         error: string;
         alreadyTunedOut?: true;
     };
+    /**
+     * Whether a write the coordinator just made was kept in memory, by what
+     * it answered: an empty id, the framework's answer for a write it keeps
+     * (a surgery's hold, a context manager refusing its work), with writes
+     * held now, as they are while it keeps one. A write that answered an id
+     * landed, whether or not writes are held since (a hold begun as it
+     * returned); one that answered no id with nothing held (a host that
+     * answers none) isn't kept. Never judged by writesHeld alone (Weft, #844).
+     */
+    private writeKept;
+    /**
+     * Whether the resident's last word on a hold (`what`, as the log names
+     * it) is the boot's row that it still stands (toldStillStands), read from
+     * the residents' stored rows for the cancel that ends it with nothing
+     * more to deliver. A read that throws, or rows that can't be read, count
+     * as yes, said once: one redundant release line is the cheaper error
+     * against a "still stands" left as the last word on a tune-out that has
+     * ended (AF #844, Oscar). Never throws.
+     */
+    private residentToldStillStands;
+    /** Whether the framework keeps writes in memory now (writesHeld), with `forAgent`'s among them; a hook that throws counts as not. */
+    private writesHeldNow;
+    /**
+     * Keep a cancel asked for while writes are kept in memory, for
+     * runDeferredCancels, with its note, for the epoch it was asked for
+     * (`target`). The first one asked for a hold stands, with its reason and
+     * source. A later one for the same hold (an end time's retry, a wake past
+     * the budget, an agent's cancel) adds nothing, except a note: the waiting
+     * cancel takes it, with its author, when it has none or its own went out
+     * already (noteDelivered), and otherwise the
+     * later note is dropped, with a log line, and this answers 'note-dropped'
+     * so its caller can be told. One waiting for an earlier epoch there,
+     * whose hold ended without it, is dropped (dropDeferred), and this one
+     * waits in its place. Once stopped (a listener of that drop's trace, say),
+     * none waits: this one is told as the stop tells a waiting cancel.
+     */
+    private deferCancel;
+    /**
+     * Run the cancels asked for while writes were kept in memory (deferCancel),
+     * in the order asked, now that the framework stores them again: it calls
+     * this once a surgery's release has stored what its hold kept, or told of
+     * what it couldn't store, and the retry timer calls it. One whose writes
+     * are still held waits on. One whose epoch no longer holds (its hold
+     * ended without it, and a later one may hold there now) is dropped, told
+     * (dropDeferred): it ends nothing, a later hold included. One that throws
+     * (its release couldn't be made durable, a store operation threw) stays
+     * waiting, with its note, the tune-out still in force: it runs again at
+     * the next call, or EXPIRY_RETRY_MS later, which one timer arms; one that
+     * threw after it recorded its hold's end isn't kept, and a note it hadn't
+     * delivered by then is told lost (dropDeferred). Each leaves the queue
+     * just before it runs, so a stop meanwhile (a trace listener's) finds
+     * those not run yet, and tells them as it tells any (stop): none runs
+     * after it, and no retry is armed then. First, the loss notices not
+     * written yet are tried again (writeLossNotices); the retry is armed while
+     * one is left. Never throws.
+     */
+    runDeferredCancels(): void;
+    /**
+     * A write the framework kept in memory while writes were held, lost when
+     * it stored them: its replay threw (`error`), and where context-manager
+     * couldn't tell whether any of it landed (`mayBeStored`), it may be stored
+     * after all. `metadata` is the write's, as it was given: what tells the
+     * coordinator's own writes apart. The framework calls this from its
+     * release, before it runs the deferred cancels (runDeferredCancels), and
+     * tells the operator as well (`message:lost`, `store-held-lost`).
+     * A queued cancel's note delivered while writes were held (heldInMemory:
+     * by its own run, or ahead of another cancel's release, queuedNoteFirst)
+     * was answered as waiting, with the promise that its author is told if it
+     * can't be delivered, and why. Its write (`subconscious-note`, of the
+     * cancel's epoch) lost here unsettles it (lostAtRelease): the run that ends
+     * the hold tells it lost then, with this error, as it tells a note it
+     * can't write (noteNow, dropDeferred), and a stop before then tells it
+     * lost with the cancel (dropQueued). The note is never written again,
+     * since it may be stored after all. A release kept so that told a queued
+     * note's loss (`tune-out-cancel` with `lostNote`, queuedNoteFirst), lost
+     * here, told nothing: the entry it settled (lostInRelease, heldInMemory)
+     * is unsettled, that loss moved to lostAtRelease, so the run that ends
+     * the hold tells it by a notice, and the note isn't written again (AF
+     * #844 review 5, #18). The note's loss is known whether or not that
+     * release may have landed: told twice, where it did, rather than never.
+     * Any other write is left to the operator. Never throws.
+     */
+    heldWriteLost(metadata: Readonly<Record<string, unknown>> | undefined, error: unknown, mayBeStored?: boolean): void;
+    /**
+     * A write the framework kept in memory while writes were held, stored when
+     * it stored them (its replay landed), by its metadata as it was given:
+     * heldWriteLost's sibling, called from the same release. What a queued
+     * cancel kept in memory so (heldInMemory) is in the store now, so a stop
+     * no longer loses it: the queued note written by the cancel's own run or
+     * ahead of another cancel's release (`subconscious-note`, of the cancel's
+     * epoch) counts as delivered, and a release that told its loss
+     * (`tune-out-cancel` with `lostNote`, queuedNoteFirst) as told. The cancel
+     * can still wait after that (writes held again before it runs, or a run
+     * that throws before it records the end): a stop then drops it as one
+     * whose note is settled, telling the author nothing false. A loss notice
+     * whose own write was kept so (writeLossNotice: a hold begun at it) is
+     * written now, by its id (`lossNoticeId`): it leaves the notices kept, and
+     * the store's record, so it isn't written a second time (Weft, #844). Any
+     * other write changes nothing. Never throws.
+     */
+    heldWriteStored(metadata: Readonly<Record<string, unknown>> | undefined): void;
+    /**
+     * A queued cancel back on the queue (`key`) after a run that didn't end
+     * its hold: one that threw, or met writes held again (waitForWrites). A
+     * cancel queued there meanwhile, for the same epoch (a trace listener's,
+     * during the run), joins it, as a later cancel joins one waiting
+     * (deferCancel): the run's stands, with its reason and its note, as it
+     * was (settled, or told in a release), and takes the later one's askers,
+     * and its note where it has none, or where its own went out already
+     * (noteDelivered: the run delivered it, and failed before the end), the
+     * later note then going out when the hold ends; a later note beside its
+     * own still to go out is dropped,
+     * told (dropDeferred, `superseded`), its caller having been answered as
+     * waiting. One queued for a later epoch leaves the run nothing to end: it
+     * is dropped, told (dropQueued).
+     */
+    private requeue;
+    /** Where a hold is, as askTurnForLoss names it: the all-except hold's, or the channel shown. */
+    private whereOf;
+    /**
+     * A queued cancel off the queue with its work undone (`drop`), as
+     * dropDeferred tells it, its note as it stands: one whose loss a release
+     * told is told so (lossesToldInRelease), where its hold has ended
+     * (`hold-ended`); one delivered, or told lost already, isn't told lost
+     * again: its drop is logged and traced as one with no note, unless the
+     * write that settled it is kept in memory at a stop (heldInMemory), which
+     * loses it; one stored since (heldWriteStored) is settled. One whose write
+     * was lost when the writes were stored (lostAtRelease) isn't settled: it
+     * is told lost by this drop, once.
+     */
+    private dropQueued;
+    /**
+     * Queued cancels leaving the queue with their hold ended, by the run that
+     * ended it or after it: a note whose loss a release told (lostInRelease;
+     * the release this run wrote, or an earlier cancel's, not made durable
+     * then) is traced and logged as lost now, as that release says, and the
+     * subconscious is asked for a turn to read it (at `where`), once.
+     */
+    private lossesToldInRelease;
+    /**
+     * A deferred cancel taken off the queue without what it was for being
+     * done (`drop`, DeferredDrop), told on stderr and as a trace
+     * (`tune-out:deferred-cancel-dropped`) with the epoch it was asked for. A
+     * note it carried is lost: the trace names its author (noteAuthorOf), and
+     * the author is told so in its own context where it still exists, a
+     * reader fork whose run has ended being written nothing (tellNoteLost),
+     * unless the release of the cancel that ended the hold tells it already
+     * (`told` release, queuedNoteFirst): no second notice is written then. A
+     * note that may be stored after all (lostAtRelease, `mayBeStored`) is
+     * traced so (`noteMayBeStored`, with the `error`), as its notice says it.
+     */
+    private dropDeferred;
+    /**
+     * Whose a queued cancel's note is: the name deliverReaderNote would
+     * deliver it under, the persistent subconscious's, else the reader fork's
+     * that left it (`noteAuthor`). Undefined where neither is known; the
+     * fork's name where the subconscious's can't be read.
+     */
+    private noteAuthorOf;
+    /**
+     * The author of a queued cancel's lost note (`author`, noteAuthorOf), told
+     * in its own context that the note was not delivered and why (`drop`):
+     * its cancel was answered as waiting, so nothing else tells it. The
+     * notice is kept (lossNotices) and written now (writeLossNotices). One
+     * whose write fails stays kept, its first failure traced, and is tried
+     * again at the next release and at the retry, which this arms, until it
+     * is written; what dropped the cancel goes on either way. One for the
+     * persistent subconscious is kept in the store as well (writeLossRecord),
+     * so a stop leaves it for the next boot to write (restoreLossNotices); a
+     * reader fork's is lost at a stop, as the fork's run is. While writes are
+     * held it waits for their release, as the cancels do. A reader fork that
+     * has ended is no agent the framework writes to any more: it is written
+     * nothing, the loss reaching no one, which is traced (writeLossNotice),
+     * and the trace of the drop (dropDeferred) still names the fork. An
+     * author not known is logged. One told at the stop is kept, not written:
+     * the stop keeps it in the store with the others (writeLossRecord), for
+     * the next boot; one told after the stop has kept those (a trace
+     * listener's stop, during the run of a cancel it found off its queue) is
+     * added to that record (keepAfterStop). Where the store refuses that record too, the stop's
+     * stamp leaves the hold out (writeStopStamp), and the next boot tells the
+     * subconscious, for a hold still on record, what that run's rows show of
+     * a cancel of it then waiting (noteUnstampedStop); a stop that can't write
+     * its stamp either leaves the one this run's boot wrote, which covers no
+     * hold, so the next boot tells it the same, where that one landed. Where
+     * the store refused every one, this run's too, nothing in the store says
+     * the stop came: the next boot reads no stamp as a first start (#844
+     * round 8, Weft) and tells nothing. Where every
+     * write refuses through the stop (the note, the notice, the store's
+     * record) and no release carries the loss (queuedNoteFirst), for a hold
+     * that has ended, the trace of the drop, with that of the notice's
+     * failure, and the log are all that is left of it: nothing else here
+     * outlives the stop.
+     */
+    private tellNoteLost;
+    /**
+     * Write the loss notices kept (lossNotices), `author`'s or every
+     * author's, each author's in the order its losses came: one written, or
+     * whose author has ended, leaves the queue; one whose write fails stays
+     * for the next try (writeLossNotice), and that author's later ones with
+     * it, behind it. None is written while its author's writes are
+     * held (writesHeld(author)): the framework would keep it in memory and answer an
+     * empty id, which then couldn't tell a kept write from an ended author's
+     * dropped one. The release or the retry writes them. Nor is one the boot
+     * read from the store's record while whether it was written before the
+     * stop can't be read (checkLossNoticesWritten). The store's record, where
+     * it wasn't read in yet, is read first, and while it can't be, none of
+     * the persistent subconscious's is written, as one it keeps would come
+     * after it. Then the store's
+     * record of the persistent subconscious's kept notices is brought in
+     * line (writeLossRecord). A loss told for an author while its notice is
+     * being written (a listener of that write) waits behind it, written next
+     * in this pass. Each leaves its author's list just before it
+     * is written, as a deferred cancel leaves its queue, so a stop meanwhile
+     * (a listener of the write) keeps those not written yet in the store
+     * (stop), and none is written after it; one whose write that stop met and
+     * failed is kept as a loss told after the stop is (keepAfterStop). Never
+     * throws.
+     */
+    private writeLossNotices;
+    /** Where the persistent subconscious's kept loss notices are kept: a snapshot state, beside the coordinator's others. */
+    private get lossNoticesStateId();
+    /** The persistent subconscious's kept notices (lossNotices) in the record's form, in the order kept. */
+    private persistedLossNotices;
+    /**
+     * Keep the persistent subconscious's kept loss notices in the store
+     * (`tune-out/<primary>/loss-notices`, PersistedLossNotice), as they are
+     * in memory: one kept is added, one written leaves. Only when they
+     * changed since the record was last written or read, or a write of it
+     * failed; never while writes are held (writesHeld): the release, the
+     * retry or the stop writes it then. Not over a record that couldn't be
+     * read (readLossRecord, tried again first). A write that fails, or can't
+     * be made durable at once (stateDurable), is logged, and the notices stay
+     * kept in memory, written or tried again as before;
+     * a stop meanwhile loses them. At `stop`, written whenever one is kept,
+     * held writes or not, and answers whether the record holds them. At
+     * `boot`, written where they changed, held writes or not, as the boot's
+     * stamp is (noteUnstampedStop). Never throws.
+     */
+    private writeLossRecord;
+    /**
+     * Read the persistent subconscious's kept loss notices from the store
+     * (writeLossRecord) into memory (lossNotices), ahead of any kept since for
+     * the same author: at boot (restoreLossNotices), and, where it couldn't
+     * be read before (a boot's read threw, or a branch move), before the
+     * notices are written (writeLossNotices) and before the record is
+     * written. Answers whether it was read.
+     * One that throws is logged and answers false: nothing is written over it
+     * until it is read. A record not in this format (`{ v: 1,
+     * pendingLossNotices }`) reads as none kept, logged, and is written over
+     * at the next change; an entry this version can't read is logged and left
+     * out, so the next write drops it. Those read in wait to be checked
+     * against the subconscious's rows (lossNoticesUnchecked), as a boot's do.
+     */
+    private readLossRecord;
+    /**
+     * Make the coordinator's own record just written (the loss record, a
+     * stamp) durable (commitDeliveries), answering whether it is: a boot reads
+     * them after a crash, which a write the store's periodic sync hadn't
+     * reached yet doesn't outlive. Left out, a write counts as durable.
+     */
+    private stateDurable;
+    /**
+     * The persistent subconscious's rows as a boot reads them for what it was
+     * told already: its window, and its own stored rows
+     * (subconsciousStoredMessages), which hold a notice its window doesn't yet.
+     * Either read that throws is logged, with what follows (`then`), and read
+     * as none; `unread` says one did.
+     */
+    private subconsciousRows;
+    /**
+     * Of the notices read from the store's record at boot (restoreLossNotices),
+     * those the subconscious's rows hold already (`lossNoticeId`: written,
+     * the record not brought in line before the stop) leave the record, not
+     * written again. Where its rows can't be read, they stay unchecked
+     * (lossNoticesUnchecked), and none of them is written (writeLossNotices)
+     * until a later try reads them.
+     */
+    private checkLossNoticesWritten;
+    /** The epoch holding where a kept notice's cancel was (DeferredFor's `current`): the channel's tune-out, or the all-except hold. */
+    private epochHoldingAt;
+    /**
+     * The holds on record, a channel's and the all-except hold (its excepted
+     * channel, with `scope`): the registry's record of each channel's, whether
+     * or not the channel is registered yet, as at boot it isn't
+     * (tuneOutsOnRecord; the registered ones, listActive, where the registry
+     * has no such list). May throw.
+     */
+    private holdsOnRecord;
+    /** Where the last stop's stamp is kept (StopStamp): a snapshot state, beside the loss notices. */
+    private get stopStampStateId();
+    /**
+     * At the stop, once the loss notices are written or kept: the stamp
+     * (StopStamp) naming the holds on record now, a channel's and the
+     * all-except hold, whose waiting cancels this stop accounted for, written
+     * and made durable (stateDurable), as the loss record before it is. Left
+     * out are the epochs of a note whose loss couldn't be kept (`unaccounted`;
+     * every persistent notice's where the store refused the record,
+     * `recorded` false), and of one still kept in memory at the stop, which
+     * the stamp names (`notesKept`, stopNotesKept), so the next boot tells
+     * the subconscious of them (noteUnstampedStop), that a kept note may be
+     * lost where that run's rows don't hold it. A stamp the store refuses too is logged: nothing
+     * more can be done at the stop. The next boot then finds this run's own
+     * stamp, covering no hold, where it landed, and tells the subconscious of
+     * each hold; where the store refused that too, it finds none, which it
+     * reads as a first start, and tells nothing. Never throws.
+     */
+    private writeStopStamp;
+    /**
+     * At boot (resumeActiveEpochs), for the holds on record (`onRecord`, read
+     * before any is resumed or ended): those the last stop's stamp doesn't
+     * cover (writeStopStamp; after a crash the stamp is the one the boot
+     * before wrote, covering none; one the store refused at a stop is that
+     * boot's too) may have had a cancel waiting, with a note, which that stop
+     * didn't account for. No stamp at all is a first boot on this version
+     * (every boot writes one), not a crash: every hold counts as covered. A
+     * hold whose waiting cancel's loss the stop kept in the store
+     * (`stopKept`, restoreLossNotices) is accounted for. For the others, the
+     * rows from that run on (the stamp's `runStartedAt`) say what they can
+     * (UnstampedStop): a release that told the queued note's loss
+     * (`lostNote`, queuedNoteFirst) needs nothing more; a release of that
+     * epoch stored since the cancel was asked (or since the hold and the run
+     * began) is `ran`; a note of that epoch delivered with no release since,
+     * `delivered`; the subconscious's own `cancel_tuneout` of it answered as
+     * waiting (askedCancelOf), `asked`; else `unknown`, told conditionally.
+     * Each by a loss notice (`unstamped-stop`) kept and written as the others
+     * are (writeLossNotices), with a turn to read it, kept in the store and
+     * tried again where the store still refuses; traced as
+     * `tune-out:stop-unrecorded` with what was `found`. A hold already told so
+     * (its notice in the subconscious's window, or kept to be written) is told
+     * again only what says more (FOUND_RANK), or another note. A reader fork
+     * is told nothing: none outlives the stop. The stamp is then written again
+     * covering no hold and naming this run's start (`runStartedAt`, and its
+     * `branch`), so it can't cover a later stop and a crash during this run
+     * leaves it so: last, once those notices are written or kept in the store,
+     * and, while one is neither, naming the last stop's bound instead
+     * (runBound), so a crash meanwhile reads the same rows again. A write that
+     * fails is kept and tried again as the loss notices are
+     * (writePendingMarker), and meanwhile a waiting cancel's answer says so.
+     * A stamp that can't be read, or isn't in this version's form, covers
+     * nothing; one whose run start is on another branch than the store's now
+     * bounds nothing here, sequences being each branch's own, so no row is
+     * read as that run's and each hold it doesn't cover is told conditionally
+     * (`unknown`). Never throws.
+     */
+    private noteUnstampedStop;
+    /**
+     * At boot, the release turns the last stop's stamp says it dropped
+     * (StopStamp's `wakesOwed`: asked while it was under way), asked again
+     * as the boot's wake for a release row still owed asks them (the
+     * framework's `tune-out released (restored)` and `tune-out (restored)`,
+     * so a row both owed and recorded is asked once), each unless this boot
+     * asked that turn for a release of its own already. Asked once: the
+     * boot's marker is written over that stamp. Never throws.
+     */
+    private askWakesOwed;
+    /**
+     * noteUnstampedStop's telling, for the holds on record (`onRecord`) the
+     * last stop's stamp doesn't cover (`covered`), reading that run's rows
+     * from its start (`since`) to this boot's (`bootHead`), none where its
+     * start is on another branch (`elsewhere`). May throw.
+     */
+    private tellUnstampedHolds;
+    /** The store's branch now (currentBranch), or undefined where the host names none or it can't be read. */
+    private branchNow;
+    /**
+     * Whether a notice a boot derived from the last stop's stamp
+     * (`unstamped-stop`) is kept in memory only: not written to the
+     * subconscious yet, nor in the store's loss record (lossRecordIds).
+     */
+    private stampNoticesUnkept;
+    /**
+     * Whether the last stop's bound (carriedBound) is still needed: a notice
+     * this boot derived from that stamp is kept in memory only
+     * (stampNoticesUnkept), or the boot's telling of it threw before it
+     * finished (carriedUntold).
+     */
+    private carriedNeeded;
+    /**
+     * Where the next boot reads this run's rows from (StopStamp's
+     * `runStartedAt` and `branch`): this run's start, or, while that stamp's
+     * bound is needed (carriedNeeded: a notice this boot derived from the last
+     * stop's stamp is kept in memory only, or its telling threw), that bound
+     * (carriedBound), so a crash then leaves the next boot reading what this
+     * boot read.
+     */
+    private runBound;
+    /** This run's marker: a stamp covering no hold, bounded where this run's rows begin (runBound). */
+    private runMarker;
+    /**
+     * The store's branch moved under this run (the framework's
+     * followBranchMove), so the snapshot states the coordinator keeps are the
+     * destination's now. Its stamp may cover a hold this run holds, and
+     * bounds the rows by another run's sequence: this run's marker is written
+     * there (writePendingMarker, tried again as at boot where it fails),
+     * naming the destination and its head now as where this run's rows on it
+     * begin (or where they began, on a branch this run was on before: a failed
+     * surgery's restore, say; or this run's start, on a branch made from this
+     * run's past it, which holds those rows: inheritedStart), so that a crash from here on reads only what
+     * this run stored on it. The destination's kept loss notices aren't in memory: the next write
+     * of the record reads them in first (lossRecordUnread), and writes this
+     * run's kept ones there too; where this run keeps any, that write is
+     * made here, before the marker, and the last stop's bound is judged by
+     * the destination's record (carriedNeeded). Never throws.
+     */
+    branchMoved(): void;
+    /**
+     * This run's start (runStartedAt), where `branch`, moved to, was made
+     * from the branch this run was on (runBranch) at a point past that start
+     * (branchOrigin): the branch holds this run's rows since then, at their
+     * sequences. Undefined otherwise, or where the store can't say.
+     */
+    private inheritedStart;
+    /**
+     * This run's stamp (noteUnstampedStop), written; one the store refused is
+     * kept (`markerPending`) and tried again at each release and by the retry
+     * timer, as the loss notices are (runDeferredCancels), never while writes
+     * are held but at boot and at a branch move (branchMoved), until it lands
+     * or the stop writes its own. Never throws.
+     */
+    private writePendingMarker;
+    /**
+     * For a hold the last stop didn't stamp (noteUnstampedStop): the persistent
+     * subconscious's own `cancel_tuneout` of it (`asks`, cancelAsksIn),
+     * answered as waiting, since the hold began and since the last run began
+     * (`since`). One names the hold where its result says the all-except hold
+     * (`scope`, the call naming that scope or a channel only that hold held),
+     * for that hold; else, for a channel's, where it names the channel (its
+     * id, its shown name, or its server-qualified name) and its server: the
+     * result's (`serverId`), the call's, or the qualified name's. A bare name
+     * with no server that two holds on record answer to names neither. Answers
+     * the first such call's sequence, and the first line, at most
+     * NOTE_QUOTE_CHARS characters, of the first such call's note (a cancel
+     * waiting with none takes a later call's note; a later note is dropped,
+     * and its caller told so). Undefined where none is found.
+     */
+    private askedCancelOf;
+    /**
+     * At boot (resumeActiveEpochs), before this boot writes any notice: a
+     * loss told to the persistent subconscious before the stop, by a notice
+     * (`tune-out-note-undelivered`) or in a release (`lostNote`,
+     * queuedNoteFirst), asked for a turn to read it, which was kept in memory
+     * only. Shown to it at rest, such a row is in its window, so the boot's
+     * wake for rows its window is still owed doesn't count it; one with no
+     * turn of the subconscious's after it in its window (unansweredIn) gets
+     * that turn asked for again, once per hold, for the reason the notice
+     * asked it for. Never throws.
+     */
+    private askTurnsForUnreadLosses;
+    /**
+     * At boot (resumeActiveEpochs): the loss notices a stop left kept in the
+     * store for the persistent subconscious (writeLossRecord) are written now,
+     * as tellNoteLost writes them, each with a turn to read it
+     * (writeLossNotice); one written leaves the record, and one whose write
+     * fails stays, kept and tried again at the next release and at the retry,
+     * which this arms. A notice whose author is no agent the framework writes
+     * to now reaches no one, which is traced (`author-gone`), and leaves the
+     * record. One whose row the subconscious's rows hold already
+     * (`lossNoticeId`: written, its record not brought in line before the
+     * stop) leaves the record, not written again; where those rows can't be
+     * read, none is written, kept in the record, until a retry reads them
+     * (checkLossNoticesWritten). The notices of an unrecorded stop written
+     * here count as told (restoredTold). Never throws.
+     */
+    private restoreLossNotices;
+    /**
+     * One loss notice (LossNotice) written into its author's context: a
+     * host-framed notice, as the coordinator's other notices to a reader are,
+     * and for the persistent subconscious a turn to read it, as they ask: the
+     * loss can come with no turn of its (a release, a retry, a cancel it
+     * didn't make), and one asked for with a cancel's own notice is the same
+     * turn. A reader fork still alive is in its run, which takes the notice
+     * at its next point. Answers what became of it. `failed`: its write
+     * threw, or its words couldn't be put together; it is logged, traced at
+     * its first failure (`tune-out:note-loss-untold`, `write-failed`), and
+     * kept. `gone`: the framework wrote nothing, answering an empty id, as it
+     * does for a write for an agent it has no registration of, a reader fork
+     * whose run has ended among them: the loss reaches no one, which is
+     * logged and traced (`author-gone`). It is written only while writes
+     * aren't held (writeLossNotices), so an empty id is no write kept in
+     * memory, unless this write began such a hold (a context manager that
+     * refuses its work from it on), which writesHeld then says: memory alone
+     * holds it then, which a crash or a stop loses, so it answers `failed`,
+     * kept in the store's record and written again once writes are stored,
+     * unless the kept write is stored then: the framework says so
+     * (heldWriteStored), and it leaves the notices kept, written once. A stop
+     * before then keeps it in the store, and a boot that finds its row
+     * (`lossNoticeId`) leaves the record (restoreLossNotices). writesHeld is asked about
+     * the author too, so a reader fork still registered whose own context
+     * manager refuses its work is told apart from one whose run has ended:
+     * the notice stays kept for it, and isn't written while that lasts
+     * (writeLossNotices). A turn that can't be asked for is logged. Never
+     * throws.
+     */
+    private writeLossNotice;
+    /**
+     * The queued cancel of this hold (`epochId`, deferCancel), off the queue:
+     * a cancel that ends the hold first leaves it nothing to end, and
+     * delivers its note: the persistent subconscious's before its release
+     * (queuedNoteFirst), a reader fork's after the end (deliverQueuedNote). One queued for an earlier epoch
+     * there is dropped, told (dropDeferred). The retry timer goes with the
+     * last one, unless a loss notice waits for it (lossNotices).
+     */
+    private takeDeferred;
+    /**
+     * A reader's note to the resident, verbatim: the persistent subconscious's
+     * under its own name, a reader fork's (`author`) as attributed mail under
+     * the fork's name and incarnation, never the resident's voice. `metadata`
+     * is the subconscious's row's; a fork's mail has it without the server.
+     * Answers how it went, from what the write itself answered: `stored`, or
+     * `kept`, where the framework kept the write in memory (an empty id: a
+     * surgery's hold, or a context manager refusing its work), to store it at
+     * their release; false where neither is configured to deliver it. A
+     * write stored, and writes held only after it, is `stored`: whether
+     * writes are held now says nothing of a write already made (Weft, #844).
+     * A fork's mail, which the registry keeps until it is delivered, or a
+     * write whose answer isn't known, counts as `stored`.
+     */
+    private deliverReaderNote;
+    /**
+     * The note a queued cancel carries, delivered once its hold has ended, as
+     * a cancel's release delivers its caller's (deliverReaderNote): by
+     * another cancel that ended the hold first (takeDeferred, `by` another),
+     * a reader fork's, the subconscious's going out before that cancel's
+     * release instead (queuedNoteFirst), or by the queued cancel's own run
+     * (`by` itself). One that can't be is told lost, with the reason, on
+     * stderr, as a trace and to its author where it still exists
+     * (dropDeferred), and the cancel that ended the hold goes on: no caller
+     * waits on it to be told. One settled already, delivered or told lost
+     * (an earlier end whose release then failed), isn't delivered again.
+     * Answers whether it was delivered now.
+     */
+    private deliverQueuedNote;
+    /**
+     * A queued cancel's note (deliverReaderNote), delivered now and settled,
+     * or, where it can't be, why (`lost`, for the caller to tell); undefined
+     * where it has none, or one settled already. One delivered while writes
+     * were held, and lost when they were stored (lostAtRelease), is lost with
+     * that error, `by` this caller, and isn't written again.
+     */
+    private noteNow;
+    /**
+     * Before a cancel writes its release, the note of a cancel of this hold
+     * still queued (deferCancel; its own release failed since, say) for the
+     * persistent subconscious: delivered now, ahead of the release, where a
+     * reader fork's goes out after the end (deliverQueuedNote), so that the
+     * release can say so where it can't be (lossInRelease). The loss is then
+     * stored with the release and made durable with it, or not at all: the
+     * hold doesn't end without the release, which throws, the hold staying in
+     * force and the queued cancel waiting on with its note, not lost. A
+     * notice to the subconscious and the store's record of it are writes of
+     * their own, which can be refused while the release is stored, leaving
+     * nothing of the loss after a stop; the subconscious's window holds the
+     * residents' rows, the release among them, so no notice is written too.
+     * Answers the queued cancel and, where its note couldn't be delivered,
+     * why; undefined where there is no such note: none queued, one for
+     * another epoch (takeDeferred drops it), one with no note or one settled
+     * already, or no subconscious (reader forks read); nor one written while
+     * writes were held and lost when they were stored (lostAtRelease), which
+     * isn't written again: it is told lost after the end instead, as a reader
+     * fork's is (deliverQueuedNote).
+     */
+    private queuedNoteFirst;
+    /**
+     * The words a cancel's release adds for a queued cancel's note it
+     * couldn't deliver (queuedNoteFirst): whose note it was, the hold
+     * (`hold`, a `tune-out` or a `hold`), the resident it was for, and why,
+     * as a notice to the note's author says them (writeLossNotice). The
+     * residents and the subconscious read them there.
+     */
+    private lossInRelease;
+    /**
+     * The turn a release asks for (`whose`: the resident's, or the
+     * subconscious's for its report), as requestInference asks it; one asked
+     * while the host's stop is under way (stopTimers, the stop proper not
+     * yet run) is dropped with the stop's closed queue, so the stop's stamp
+     * records it (`wakesOwed`) and the next boot asks it again.
+     */
+    private askReleaseTurn;
+    /** A turn for the persistent subconscious to read the loss of its note that a release told (queuedNoteFirst), as a notice asks for one (writeLossNotice). */
+    private askTurnForLoss;
+    /**
+     * Arm the one retry of the deferred cancels and the loss notices not
+     * written (lossNotices), and of the loss record not read yet
+     * (lossRecordUnread), unless it is armed; it arms itself again while
+     * one still waits.
+     */
+    private armDeferredRetry;
+    /**
+     * A cancel that waits for the writes kept in memory (deferCancel), its
+     * hold in force: one asked for while writes are held, or one whose release
+     * met a hold as it was written. A queued cancel's own run (`asQueued`)
+     * goes back on the queue as it is, its note and askers with it (requeue).
+     */
+    private waitForWrites;
     /** Whether a reader (persistent subconscious or reader forks) attends holds. */
     hasReader(): boolean;
+    /**
+     * End a tune-out: system-framed backlog dump into the resident's window
+     * (capped), stored and made durable before the epoch's end is recorded,
+     * then the lifecycle notice and one wake for the resident.
+     * `subconsciousNote` is the subconscious's own text (from its
+     * cancel_tuneout call) — delivered verbatim under its name, never
+     * synthesized here. A dump that can't be made durable (commitDeliveries)
+     * throws, the tune-out still in force, and a later cancel dumps what no
+     * earlier dump of the epoch covered (`released`). While the framework
+     * keeps writes in memory (writesHeld: a surgery's hold, a manager refusing
+     * its work), nothing is dumped or ended yet: the cancel waits, the
+     * tune-out in force, and runs once the writes are stored, or told of
+     * where storing one fails (runDeferredCancels). It answers `deferred`
+     * then.
+     */
     cancel(serverId: string, channelId: string, source: string, reason: string, subconsciousNote?: string, 
     /** `reader: 'forks'`: the reader fork whose note this is. */
     noteAuthor?: string, 
     /** The lifecycle state the channel returns to (a tool close ends in 'closed'). */
     nextState?: 'open' | 'closed'): {
         ok: true;
+        deferred?: true;
+        noteDropped?: true;
     } | {
         ok: false;
         error: string;
     };
+    /**
+     * cancel's work. `asQueued`: the queued cancel this call runs
+     * (runDeferredCancels), whose note (`subconsciousNote`) is delivered as a
+     * queued one is (deliverQueuedNote), told lost (dropDeferred) where it
+     * can't be, the cancel going on.
+     */
+    private endTuneOut;
+    /** How many stored messages `keep` keeps the subconscious hasn't been shown (the hook's count), 0 where the host can't say. */
+    private unseenBySubconscious;
     /**
      * Consulted by the framework for every incoming channel message BEFORE
      * storage. Null = channel not tuned out (proceed normally). Otherwise the
@@ -344,6 +1366,19 @@ export declare class TuneOutCoordinator {
     /** The channel unprefixed speech lands in while an all-except hold is active, with its server, else null. */
     focusChannel(): ChannelRef | null;
     private get scopeStateId();
+    /**
+     * End every hold on record and deliver each backlog to the resident: the
+     * per-channel holds, then the all-except scope. For a host with no reader
+     * (AgentFramework.releaseTuneOutsWithoutReader) and a reader that ended; a
+     * hold whose end fails stays on record, and says so in the log. A
+     * per-channel hold ends under its own source, so an agent's tune-out keeps
+     * the agent's provenance (the housekeeping guard reads it); `source` is the
+     * all-except scope's.
+     */
+    releaseAll(source: string, reason: string, options?: {
+        retry?: boolean;
+        attempt?: number;
+    }): void;
     getAllExcept(): AllExceptState | null;
     private writeScope;
     enterAllExcept(except: {
@@ -375,12 +1410,24 @@ export declare class TuneOutCoordinator {
     private clearScopeTimers;
     /** Channels held by the scope (not by their own epoch) with the count held under it. */
     private scopeHeldCounts;
+    /**
+     * End the all-except hold: one release notice with a per-channel backlog
+     * (each capped), stored and made durable before the hold's end is
+     * recorded, as a channel's cancel does, then the reader's note if any,
+     * one wake for the resident, and the reader's own look at what it had not
+     * seen. While the framework keeps writes in memory it waits, as cancel
+     * does.
+     */
     cancelAllExcept(source: string, reason: string, note?: string, noteAuthor?: string): {
         ok: true;
+        deferred?: true;
+        noteDropped?: true;
     } | {
         ok: false;
         error: string;
     };
+    /** cancelAllExcept's work; `asQueued` as endTuneOut's. */
+    private endAllExcept;
     /** What is held right now — per-channel epochs and the scope — without releasing. */
     check(opts?: {
         peek?: {
@@ -413,16 +1460,20 @@ export declare class TuneOutCoordinator {
     /**
      * One subconscious turn: a system-framed trigger notice (bracket style —
      * what happened, never what to say) plus standing dispositions, then an
-     * inference request. The merged view supplies the actual traffic.
+     * inference request. Its view supplies the actual traffic: the merged
+     * record while its window is the record, and with the presentation index
+     * (#291) what its window holds, which takes what it hasn't been shown at
+     * the turn's start, the notice included.
      */
     private invokeSubconscious;
+    /** How many of the writes the framework keeps in memory (getSurgeryHeldMessages) `keep` keeps; 0 where they can't be read. */
+    private keptInMemory;
     /**
-     * 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.
+     * Count again, from the held messages (all stored, #291), 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, those
+     * held since its last look (lastLooks). Nothing holding the channel leaves
+     * no count.
      */
     private rebuildTally;
     private get lastLooksStateId();
@@ -442,16 +1493,14 @@ export declare class TuneOutCoordinator {
     /**
      * `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
+     * delivered to exactly one reader — plus the standing dispositions. A
      * cadence look with nothing new is skipped. True when a fork was asked for.
      */
     private invokeReaderFork;
     /**
-     * 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.
+     * What no reader fork has read yet, of the given held messages, oldest
+     * first: those past the epoch's cursor for the channel, plus those a
+     * failed fork returned.
      */
     private unhandedBacklog;
     /**
@@ -466,23 +1515,16 @@ export declare class TuneOutCoordinator {
      * 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: Pick<ReaderInvocation, 'serverId' | 'channelId' | 'epochId' | 'backlog' | 'queued'>): number;
+    readerFailed(invocation: Pick<ReaderInvocation, 'serverId' | 'channelId' | 'epochId' | 'backlog'>): number;
     /**
      * 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.
+     * ended. Every held message is stored as it arrives (#291), so what it was
+     * handed is what the late fork is. 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.
      */
     private lateFork;
-    /**
-     * 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.
-     */
-    private queuedHeld;
     private dispositionsCache;
     private get dispositionsStateId();
     /**
@@ -540,11 +1582,49 @@ export declare class TuneOutCoordinator {
     private notTunedOut;
     /**
      * 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.
+     * coalescing wakes). The framework then releases every hold with
+     * releaseAll ("its reader ended"); a hold whose release fails keeps its end
+     * time, which releases it to the resident with no reader.
      */
     stopReader(): void;
-    /** Stop all timers (framework shutdown). */
+    /**
+     * The stop's keeping of the loss notices kept (stop): the persistent
+     * subconscious's in the store (writeLossRecord), the stop stamped
+     * (writeStopStamp, leaving out `unaccounted`) at the stop (`stamp`
+     * 'stop'), or again where the store refused the record (`unrecorded`),
+     * and each logged and dropped from memory. Never throws.
+     */
+    private keepAtStop;
+    /**
+     * A loss told once the stop had kept what it found (a trace listener's
+     * stop, during a queued cancel's run or a notice's write, that found the
+     * cancel or the notice off its queue): kept as the stop keeps those
+     * (keepAtStop), the store's record read in again first, so that what the
+     * stop kept there stays, and the stamp written again, its hold left out,
+     * where the store refuses the record. Never throws.
+     */
+    private keepAfterStop;
+    /**
+     * The timers quieted, at the start of the framework's stop: a hold's end
+     * time, a reader's cadence and wake, a release's or a waiting cancel's
+     * retry. Nothing else stops: a waiting cancel still runs when the
+     * framework stores the writes it waits for (runDeferredCancels), which the
+     * stop's wait for an operator's operation can let happen; then stop()
+     * tells and keeps what is left (Weft's hold 2, #844). Never throws.
+     */
+    stopTimers(): void;
+    /**
+     * Stop all timers (framework shutdown), tell each waiting cancel's note
+     * lost (one still kept in memory left for the next boot instead, its hold
+     * out of the stamp: a release after the stop may store it), keep the
+     * persistent subconscious's notices in the store, and
+     * stamp the stop (writeStopStamp). A second stop stamps nothing: the
+     * first one's notices are no longer in memory to say what it kept. The
+     * framework calls it once its stop has waited for an operator's
+     * operations, so a hold that keeps a waiting cancel's writes, released
+     * during that wait, lets the cancel run first (stopTimers, before the
+     * wait, quiets the timers).
+     */
     stop(): void;
 }
 //# sourceMappingURL=coordinator.d.ts.map