@animalabs/agent-framework 0.32.0 → 0.33.0

package/dist/src/framework.d.ts

@@ -3,6 +3,7 @@ import { JsStore } from '@animalabs/chronicle';
 import type { Membrane, ContentBlock, NormalizedRequest } from '@animalabs/membrane';
 import { type RetrySettings } from '@animalabs/membrane/retry';
 import { ContextManager } from '@animalabs/context-manager';
+import { type TuneOutReader } from './tune-out/tools.js';
 import type { MessageMetadata, TokenBudget } from '@animalabs/context-manager';
 import type { FrameworkConfig, ErrorPolicy, ErrorAction, TraceEventListener, InferenceLogQuery, InferenceLogQueryResult, InferenceLogEntryWithId, ProcessLogQuery, ProcessLogQueryResult, ProcessLogEntryWithId, ProcessEvent, ToolCall, ToolResult, AgentConfig, InferenceRequest, Module, ContextMaintenanceSnapshot, AgentRuntimeSettingsPatch, AgentRuntimeSettingsSnapshot, SameRoundThinkTextPolicy } from './types/index.js';
 import { Agent, type RenderStats } from './agent.js';
@@ -17,10 +18,21 @@ import type { ActivationRecord, AgentEndReason, AgentRecord, AgentSpec, EndOutco
  * and every module utility is there too.
  */
 export declare const BUILTIN_TOOLSET_TOOLS: ReadonlySet<string>;
+import { type SuppressedEventRecord } from './gate/suppression-stats.js';
+import { type SuppressionReviewSummary } from './gate/suppression-review.js';
 import type { SessionUsageSnapshot } from './usage/types.js';
 import type { ContextStrategy } from '@animalabs/context-manager';
 import { type DiscordAwarenessView, type DiscordAwarenessCancelReceipt, type DiscordAwarenessMarks, type DiscordAwarenessRetractReceipt } from './recovery/discord-awareness-outbox.js';
 import { type SurgeryMarkerReceipt, type SurgeryMarksPreview, type OperatorLogEntry, type OperatorLogInput, type OperatorRequester } from './operator-log.js';
+export type { TuneOutReader };
+/**
+ * The `tune_out` tool for a host with `reader`. The text says what happens
+ * to the channel's traffic and what the reader there can do, by the name
+ * the host gave it. It says nothing of what a reader decides or why: the
+ * voice doctrine's standard (coordinator.ts), which puts no words in a
+ * model's mouth, holds for what the resident is told about its reader too.
+ */
+export declare function tuneOutTool(reader: TuneOutReader): import('./types/index.js').ToolDefinition;
 /**
  * Feasibility verdict for a runtime-settings patch, derived through the SAME
  * settings→config mapping the live apply path uses (`Agent.planRuntimeSettings`
@@ -113,8 +125,17 @@ export interface HostModeStatus {
      * they hold no turn token, so drain doesn't wait for them. Reported so the
      * operator sees what is still acting during the window. */
     backgroundScripts: number;
-    /** Context writes (module events, api message.send) withheld because the
-     * host is quiesced. Persisted while quiesced and flushed by resume(). */
+    /**
+     * Context writes kept in memory, to be stored later: those a live
+     * operator surgery's hold keeps until its release, and those kept for an
+     * agent whose context manager refuses its work after a failed
+     * re-initialization, until a branch move (switchBranch, a rollback or a
+     * suppression) re-initializes it; 0 otherwise. Before #291 it counted the writes held in the deferred queue,
+     * which this release no longer keeps: a write made while quiesced is
+     * stored at once, and no agent is shown another's until resume.
+     *
+     * @deprecated Kept for one release; removed in the next.
+     */
     deferredWrites: number;
     /** Agents whose turn `abandon` had not ended when its grace ran out: a
      * turn token held with no stream to cancel and no check ahead to stop it
@@ -145,12 +166,13 @@ export declare class ResumeBlockedError extends Error {
     }>);
 }
 /**
- * Thrown by `quiesce()` without `abandon` when the queue of deferred context
- * writes can't reach disk: it's over its cap, so its record can't hold it, or
- * its write failed, and that error is the `cause`. So the queue as it
- * stands isn't on disk. The host's mode is as it was, and the
- * message names the ways out, among them quiescing with `abandon: true`,
- * which goes on with the queue in memory.
+ * Was thrown by `quiesce()` when the queue of deferred context writes couldn't
+ * reach disk. Since #291 the framework keeps no such queue (a write is stored
+ * at once, and enters each agent's window at that agent's presentation
+ * points), so quiesce() never throws it.
+ *
+ * @deprecated Never thrown since #291; kept exported for one release so a
+ * host that tests for it still builds.
  */
 export declare class QuiesceBlockedError extends Error {
     constructor(message: string, options?: {
@@ -227,13 +249,15 @@ export declare class DefaultErrorPolicy implements ErrorPolicy {
  * grace only brings the abandon's report sooner.
  */
 export declare function setAbandonGraceForTests(framework: AgentFramework, ms: number): void;
+export { heldFromResidents } from './presentation.js';
+export { suppressedRow } from './presentation.js';
 /**
- * The admission record on a stored message: it was held from the residents
- * by a policy epoch (`metadata.tuneOut = { epochId }`). ONE predicate for
- * "held from the resident", read by the compiled-view filter and by the
- * mid-turn injection alike (#232 H1), so the window and the wire agree.
+ * The event type an MCPL server's `[toolsets]` notice (a tool change with no
+ * result or event to ride on, RFC-014 §8.3) is gated as: from the server's
+ * id, with the notice's text as its content. Only suppress rules read it,
+ * since a notice never wakes the agent.
  */
-export declare const heldFromResidents: (metadata: Record<string, unknown> | undefined) => boolean;
+export declare const TOOL_CHANGES_EVENT_TYPE = "mcpl:tool-changes";
 /** Options for {@link AgentFramework.deriveAgent}. */
 export interface DeriveAgentOptions {
     /** The new agent's name. Single-use within this framework's lifetime. */
@@ -327,7 +351,10 @@ export declare function restoreAlert(restore: {
 })): ReinitAlertText;
 export declare function disposalAlert(disposal: {
     move: ReinitMove;
+    /** The writes kept in memory for it, by the move's hold or while its manager refused its work, that it ended before storing. */
     heldWrites?: number;
+    /** How many of them went on to the primary, which takes them in its place (passesToPrimary); the rest were dropped. */
+    passedOn?: number;
     reinitFailed?: string;
     cleanupFailed?: string;
 }): ReinitAlertText;
@@ -356,8 +383,9 @@ export declare function opsWebhookText(message: string): string;
  * the shed doesn't help, and the breaker stops at its rewind cap. The 413 arm
  * takes both labels membranes have given a 413, invalid_request and
  * context_length (see the notes below). Other statuses keep the history,
- * since a shed takes the exchange out of the agent's context, which only an
- * operator's undo brings back, and the status gives no sign that a shed
+ * since a shed takes the exchange out of the agent's context for good (the
+ * record keeps it, and no later start, restart or redo of another turn
+ * presents it again), and the status gives no sign that a shed
  * would help: a 404 is a model or an endpoint that doesn't exist, and 405,
  * 409, 410 and 415 are about the HTTP request or the resource, as a rule,
  * rather than the conversation.
@@ -477,10 +505,6 @@ export declare class AgentFramework {
      * clear failed, or a quiesce whose write failed partway, memory can say
      * serving while the record says quiesced, until a resume() clears it. */
     private hostModeRecordMayBeQuiesced;
-    /** Whether a resume() is between serving and clearing the record: it has
-     * cleared `quiesced` and is flushing the deferred writes, then clearing the
-     * record. A resume() on the serving host leaves the record to it. */
-    private resumeInFlight;
     private quiesceReason?;
     private quiescedAt?;
     private traceListeners;
@@ -704,11 +728,13 @@ export declare class AgentFramework {
     private subconsciousAgentName;
     /** Its windowed strategy — the coordinator moves the anchor on tune-out entry. */
     private subconsciousStrategy;
+    /** Where the persistent subconscious's window starts, by sequence or by a fixed ordinal (#291, AF-5). */
+    private subconsciousAnchor;
     /** Its config (speak_in_channel gate, voice block provenance). */
     private subconsciousConfig;
     /** Tune-out coordinator (issue #77); non-null iff a reader is configured + channels. */
     private tuneOutCoordinator;
-    /** Residents are offered `tune_out` (a reader is configured, or `tuneOut.enabled`). */
+    /** Residents are offered `tune_out` (a reader is configured). */
     private tuneOutOffered;
     /**
      * The reply anchor a coalesced delivery would set, parked until the
@@ -728,20 +754,6 @@ export declare class AgentFramework {
     /** Agents an abandon could not cancel (token held, no stream) — surfaced
      *  in HostModeStatus until the next quiesce/resume. */
     private lastUnabandonable;
-    /** True while the deferred-write queue is mirrored to its record, so each
-     *  change of it writes it: from a write of it that reached or may reach
-     *  the record, one that failed or met the cap unless quiesce() rejected
-     *  for it (deferredWritesFellBehind), or a boot that restored it, until a
-     *  write clears the record once the queue drains. */
-    private deferredWritesPersisted;
-    /** True from a write of the queue that failed or met the cap, unless
-     *  quiesce() rejected for it, until one succeeds: a run of failures
-     *  (deferredWritesFellBehind). A quiesce({ abandon: true }) over the cap
-     *  goes on rather than rejecting, so its write begins a run too. */
-    private deferredWritesBehind;
-    /** True once the cap has been met in the current run, so its line is
-     *  logged once a run, whatever began the run. */
-    private deferredWritesCapLogged;
     /** The agent registry and its ended log, as recovery files beside the store
      *  (nissa's #546 finding 3): Chronicle state follows the store's branch, and
      *  an undo or an operator's surgery must not erase a result held for
@@ -760,39 +772,19 @@ export declare class AgentFramework {
     private endedLogIndexed;
     /** The last indexed entry's mark, so a log that changed under the index is seen. */
     private endedLogTail;
-    /** Branch-independent recovery files (see FrameworkConfig.hostModePath /
-     *  deferredWritesPath). Undefined → branch-local slot fallback. */
+    /** Branch-independent recovery file for the host's mode (see
+     *  FrameworkConfig.hostModePath). Undefined → branch-local slot fallback. */
     private hostModePath;
+    /** Where a release before #291 mirrored its deferred-write queue (see
+     *  FrameworkConfig.deferredWritesPath), read once at boot by the importer
+     *  (importPersistedDeferredWrites), for one release. Undefined → the
+     *  store's slot. */
     private deferredWritesPath;
+    /** The writes the importer left queued for the next boot, its agent's
+     *  store having failed (importPersistedDeferredWrites): reconcile doesn't
+     *  deliver again the mail one of them carries. One release. */
+    private importLeftQueued;
     private recoveryFallbackWarned;
-    /**
-     * Deferred writes that have been handed to a context manager but whose
-     * chronicle state is NOT yet durably synced. They stay in the durable
-     * recovery queue until `ackDeferredWrites()` syncs the store — chronicle
-     * persists the slot-chain head only on sync(), so acknowledging on append
-     * alone would let a hard exit forget an accepted message.
-     */
-    private unackedDeferredWrites;
-    /** Monotonic order stamp for deferred writes: the durable queue is always
-     *  written, restored, drained and flushed in `seq` order, whatever the
-     *  pending/un-acked split — a re-deferred entry keeps its place. Boot
-     *  recovery numbers the restored queue 1..N in that order, and the stamp
-     *  goes on from N (restorePersistedDeferredWrites). */
-    private deferredSeq;
-    /**
-     * Per target agent: the store's message count when the OLDEST currently
-     * un-acked entry for it was handed off. Persisted with the queue so a boot
-     * after an interrupted flush knows exactly which slot range the batch
-     * could occupy and dedups against all of it — never a fixed tail.
-     */
-    private deferredScanFrom;
-    private deferredMessages;
-    /** The marked held writes whose store couldn't be searched, each with the
-     *  failure said, said once until a lookup of them succeeds and again when
-     *  the failure changes (landedCopiesById), and those a drain has said it
-     *  holds what's queued behind (writeDrainedInOrder). */
-    private unsearchableSaid;
-    private stillUnknownSaid;
     private activeTurnTokens;
     /** Each running scheduler pass's requests, which it took from
      *  pendingRequests: it holds those of the agents it hasn't taken up yet
@@ -810,8 +802,10 @@ export declare class AgentFramework {
      *  (beginAgentTurn). */
     private settledTurns;
     /** Agents whose fresh turn's coalescing assembly is running
-     *  (beginAgentTurn): the window in which addMessage honours a write's
-     *  bypassDeferralFor naming that agent. */
+     *  (beginAgentTurn). What is stored for such an agent meanwhile is
+     *  presented before its compile (presentAtStart's 'assembly'), so
+     *  addMessage stores it with the event clock it is due, and doesn't
+     *  mark its placement unpresented. */
     private readonly assembling;
     /**
      * The InferenceRequest that started each agent's turn in progress — set and
@@ -896,6 +890,75 @@ export declare class AgentFramework {
      * roles from here instead of excluding kinds by hand.
      */
     private readonly registry;
+    /**
+     * The presentation index (#291, presentation.ts). Set once, in create(),
+     * before any agent is created; null only on a framework built from its
+     * prototype, as some suites build one. Each agent is taken on as it is
+     * registered (adoptPresentation), and from then on, for an agent whose
+     * window is presented (presents), a write enters the window at the
+     * agent's presentation points: its own rows as they are written, others'
+     * at its turn's start, at its tool boundary as the stream can carry them,
+     * at its turn's end, and at once while no turn of it is alive. Every
+     * write is stored at once.
+     */
+    private presentation;
+    private bootFreeze;
+    /** The arrival listener adoptPresentation installed for each agent, by its unsubscribe. */
+    private readonly presentationListeners;
+    /**
+     * Writes a surgery's hold kept out of every store while the operator's
+     * switch was awaited (addMessage, and the writes into a fork's store), in
+     * arrival order. They are in memory only, so a crash during the surgery
+     * loses them: the release replays them through the ordinary write path
+     * (releaseSurgeryHeldWrites).
+     */
+    private readonly surgeryHeldWrites;
+    /**
+     * Set while releaseSurgeryHeldWrites replays what a hold kept: the writes
+     * still to replay stay in surgeryHeldWrites, a write made meanwhile (a
+     * listener of a replayed write's trace) is kept behind them, and the
+     * tune-out's writesHeld reads true, as during the hold.
+     */
+    private replayingHeld;
+    /**
+     * Set by addMessage and storeInFork where the write the release replays
+     * (`replayed`) meets a hold a listener of its own traces began: the write
+     * isn't stored, and stays at the head of the queue for that hold's
+     * release (releaseSurgeryHeldWrites reads and clears it).
+     */
+    private replayHeldAgain;
+    /** A release of the tune-outs on record with no reader (releaseTuneOutsWithoutReader) that met held writes, to run once they are stored. */
+    private releaseWithoutReaderWaits;
+    /** How many writes this process has kept in memory (SurgeryHeldWrite.heldOrder): their arrival order across agents. */
+    private heldWritesKept;
+    /**
+     * Writes for an agent whose context manager refuses its work, by the
+     * agent's name, each agent's in arrival order: its re-initialization after
+     * a branch move failed (reinitializeManagers), and context-manager's
+     * initialization fence refused a write for it (refusesUntilReinitialized),
+     * at its writer or at a hold's release. Every later write for the agent
+     * waits behind them. They are in memory only, so a restart loses them: the
+     * next move that re-initializes the agent stores them, at its release, as
+     * the hold's own writes (recoverHeldWrites), and an agent that ends first
+     * passes on the ones the primary takes in its place (passHeldWritesOn).
+     */
+    private readonly heldForRecovery;
+    /**
+     * The context managers that refuse their work until a re-initialization
+     * succeeds, each with what failed: a move's re-initialization of it
+     * (reinitializeManagers), or a failed surgery's restore that selected the
+     * branch and couldn't initialize it (restoreSourceBranch).
+     */
+    private readonly managersRefusingWork;
+    /**
+     * The agents whose foreignRounds the framework sets (applyForeignRounds),
+     * each with the mode its configuration names: a resident that observes
+     * another (AgentConfig.foreignRounds), and the persistent subconscious
+     * (its config's); and an agent that takes its context from one of those
+     * (a derived agent, a conversation fork), with that agent's. Recorded at
+     * registration (configureForeignRounds).
+     */
+    private readonly foreignRoundsConfigured;
     /** Tell the first adoption candidate when task work is orphaned (config.dendrite.announceOrphans). */
     private announceOrphans;
     /**
@@ -911,8 +974,10 @@ export declare class AgentFramework {
     /** Per source agent, per kind: how many derivations, since when, and at which count the last note went. */
     private derivationTallies;
     private readonly sharedSlotAgents;
-    /** The batched-wake lines already written (placeWakeLines), so every agent a
-     *  wake was for, and every later start of it, writes each at most once. */
+    /** The batched-wake lines already written (placeWakeLines), and the agents
+     *  each was written for, so every later start of a wake writes each at
+     *  most once for its agent: the delivery agent alone, and with the
+     *  presentation index each resident a wake was for. */
     private readonly placedWakeLines;
     /** Rounds of tool calls, by their results array, that a save_recent_image
      *  in the round counted by their share of the bound: such a round is
@@ -921,10 +986,14 @@ export declare class AgentFramework {
     /** Group commit: one fsync per event-loop turn, shared by every waiter. */
     /** The windows of forks and runs deregistered while the host was quiesced,
      *  by agent name (releaseWindowNowOrAfterResume); resume() releases them
-     *  (runReleasesAfterResume), or stop() passes on what they left, unread or
-     *  queued, and clears them. While a name is here, no other flush drains
-     *  its queue (drainDeferredFor). */
+     *  (runReleasesAfterResume), or stop() passes on what they left unread,
+     *  and clears them. */
     private readonly releasesAfterResume;
+    /** Each released agent's reader facts, as the registry recorded them when
+     *  its release was asked for (releaseWindowNowOrAfterResume), before a
+     *  later agent can take its name: what its release reads as meant for it
+     *  (releasedWindow). */
+    private readonly releasedReaders;
     private readonly managerReleases;
     private readonly releasedByCleanup;
     private readonly resumesPending;
@@ -958,6 +1027,12 @@ export declare class AgentFramework {
      *  publish the call makes is credited with (publishReadThrough). Kept only
      *  while the dispatch runs (dispatchScriptToolCall). */
     private readonly scriptCallStarts;
+    /** The marks of channel_publish calls still out (publishReadThrough's,
+     *  taken at the call), by agent, until their delivery settles: a redo
+     *  gives them again (heldMarksOf, retakeMarks), as it gives a running
+     *  script's, so a script's publish that settles after the redo is credited
+     *  with the rows put back (holdPublishMark). */
+    private readonly publishMarksInFlight;
     /** Per agent, the unexpected thinking drops its last operator alert counted (noteThinkingLoss). */
     private readonly thinkingLossIncidents;
     /** Per live stream that can be noted, its rows so far after the compiled messages (noteRoundSent). */
@@ -1006,6 +1081,7 @@ export declare class AgentFramework {
     private mcplToolServers;
     /** Servers whose tools/list answered in the latest refresh. */
     private mcplListedServers;
+    private mcplPublishedConnections;
     /** refreshMcplTools' starts, and the start whose result was published
      *  last: a refresh that a later-started one has overtaken publishes
      *  nothing, since that one listed every server after it. */
@@ -1078,7 +1154,6 @@ export declare class AgentFramework {
      */
     private surgeryHold;
     private readonly conversationSpawnsInFlight;
-    private syncMoveReinit;
     private holdAlertMs;
     /** Serialize per-server drains so reconnect and an online undo cannot race. */
     private discordAwarenessDrains;
@@ -1088,6 +1163,10 @@ export declare class AgentFramework {
     private discordAwarenessDrainsJoined;
     private eventGate;
     private judgeWired;
+    /** Wake onboarding's record of the agent's decisions (null: onboarding off, or no gate). */
+    private wakeDecisions;
+    /** The periodic review of what suppress rules hid; null with no gate or with the review off. */
+    private suppressionReview;
     /** The heartbeat (FrameworkConfig.heartbeat), when the host turns it on. */
     private heartbeat;
     private usageTracker;
@@ -1198,14 +1277,11 @@ export declare class AgentFramework {
      * stop() fails with the cancel's error: that stop() doesn't wait for it,
      * even with no budget, and a later stop() waits for it as for anything an
      * earlier one left running (the last point below). After either:
-     * - an agent still registered whose stream is still running keeps its
-     *   deferred writes queued, since the stream may still write. The stream's
-     *   own turn-end flush takes them when it settles, if the process lives on,
-     *   and a later stop() takes what that leaves; a memory-only queue loses
-     *   them if the process exits first.
+     * - an agent still registered whose stream is still running may still
+     *   write; what it writes is stored as it is written, as every write is.
      * - every ephemeral run still registered is ended, as after any stop(), and
-     *   its end stores what is queued for it, as at any run's end, whatever its
-     *   stream is doing: once a run has left, its stream's late events are
+     *   its release passes on what it never read, as at any run's end, whatever
+     *   its stream is doing: once a run has left, its stream's late events are
      *   dropped, though a write the stream already had under way can still
      *   land in the run's namespace after them.
      * - an event loop still in a call, such as a module's onProcess, finishes
@@ -1216,8 +1292,7 @@ export declare class AgentFramework {
      * Each conversation fork still live ends, as a closing fork's end does,
      * whatever its stream is doing, as each run does: its channel unbinds, and
      * its window's release passes on to the primary the notices it left that
-     * the primary takes in its place, unread in its window, or still queued
-     * for it unless it read the copy that landed there. Its end settles a
+     * the primary takes in its place, unread in its window. Its end settles a
      * tool-result batch its stream still held and removes the stream's
      * entries, and once it has left, its stream's late events are dropped.
      */
@@ -1299,6 +1374,18 @@ export declare class AgentFramework {
      * them beside the gate's own timers, so it can weigh what waiting costs.
      */
     private upcomingWakesFor;
+    /**
+     * What will wake `agentName` with no new event, as healthSnapshot reports
+     * it: soonest first, the first HEALTH_UPCOMING_WAKES of them, each with its
+     * time, kind and whether the rule table lets it wake the agent (a probe:
+     * gate.js isn't asked). A wake's `what` stays out: it can quote a reminder or
+     * a queue reason, and health goes to observers granted nothing else.
+     *
+     * The field is left out when this can't say, so that it isn't taken for an
+     * agent with nothing due: when a read throws, and when the heartbeat is
+     * heartbeat-mcpl, whose next tick only its own process knows.
+     */
+    private upcomingWakesHealth;
     /**
      * The heartbeat's ticks and reminders for `agentName`, soonest first, which
      * the agent's rules decide as they decide a heartbeat push: one the rules
@@ -1342,7 +1429,7 @@ export declare class AgentFramework {
      * tick stores no prompt: its turn, when the gate triggers one, is a silent
      * heartbeat (silent-heartbeat.ts), prose suppressed. As for a stored push,
      * the wake of the agent the text was delivered to is dropped once a
-     * request of its own has carried and answered the text (readsWriteFor);
+     * request of its own has carried and answered the text (readsRowFor);
      * another resident's isn't tied to it.
      */
     private deliverHeartbeat;
@@ -1756,7 +1843,9 @@ export declare class AgentFramework {
     /** What an agent is told when a send tool's words go to a channel it tuned
      *  out, or undefined where nothing needs saying. A send keeps the tune-out
      *  (ChannelRegistry.openChannelNow), so the agent that sent there expecting
-     *  answers learns they still go to its subconscious. A send tool's answer
+     *  answers learns they are still held from it, and who reads them
+     *  meanwhile: the reader by the name it runs under, or forks of its
+     *  context (tuneOutReader). A send tool's answer
      *  carries this, send_dm's included, or for a code_execution script's send
      *  a notice in the agent's window: a tune-out diverts a DM too. The same setting
      *  turns it off, a conversation agent gets none, and a failure while
@@ -1923,17 +2012,16 @@ export declare class AgentFramework {
     static readonly QUIESCE_TIMEOUT_MAX_MS = 600000;
     static readonly QUIESCE_TIMEOUT_DEFAULT_MS = 120000;
     /**
-     * Enter quiesce mode: write the deferred-write queue, persist the flag,
-     * suppress gate deliveries, pause all MCPL data planes, and wait for
-     * in-flight turns to settle (turn-alive is a turn token, which spans
-     * dequeue → settled teardown, a continuation of the turn on its way to its
-     * start, or the turn's retry, which a provider hold keeps or which waits
-     * to start: turnHolders). Idempotent, but for the queue's write, which
-     * every call makes first: when the queue can't reach disk, because its
-     * write fails or it's over the cap, the call rejects with a
-     * QuiesceBlockedError and the host's mode as it was, unless it has
-     * `abandon`, which goes on with the queue in memory and an alert
-     * (writeDeferredWritesForQuiesce).
+     * Enter quiesce mode: persist the flag, suppress gate deliveries, pause all
+     * MCPL data planes, and wait for in-flight turns to settle (turn-alive is
+     * a turn token, which spans dequeue → settled teardown, a continuation of
+     * the turn on its way to its start, or the turn's retry, which a provider
+     * hold keeps or which waits to start: turnHolders). Idempotent. While
+     * quiesced a write is stored at once, as always, unless a surgery's hold
+     * or a context manager refusing its work keeps it in memory, and the
+     * presentation index presents no agent another's row until resume
+     * (#291): every window is frozen but for each agent's own rows, a
+     * draining turn's tool boundaries included.
      *
      * On drain timeout the host STAYS quiesced (`drained: false` in the
      * result); with `abandon: true` the undrained streams are cancelled via a
@@ -1968,49 +2056,15 @@ export declare class AgentFramework {
     }): Promise<HostModeStatus>;
     private runResume;
     /**
-     * Land every deferred write whose target has no turn alive, as one batch
-     * acknowledged once: the chronicle is synced, then the persisted queue is
-     * rewritten without the batch (ackDeferredWrites). Until then the batch
-     * stays in the durable queue, so a crash mid-flush replays it at the next
-     * boot, which skips each entry that already landed, by its deferredWriteId —
-     * no loss, no duplicates. The batch is stored in queue order, whatever its
-     * targets (writeDrainedInOrder). A write the store rejects stays queued,
-     * logged, with what is queued behind it for its target, so the flush never
-     * stores that target's later entries ahead of it, and other targets' entries
-     * go on. One the store refuses as malformed, which it would at every flush,
-     * is logged and dropped instead, and what is behind it goes on. (A write
-     * that isn't deferred can still land ahead of it, such as one for an idle
-     * agent once the host has resumed.) A boot that meets it again logs it and
-     * goes on.
-     *
-     * Per-target: an agent whose turn is still alive keeps ITS messages
-     * deferred for its own turn boundary; everyone else's flush now.
-     */
-    private flushDeferredWrites;
-    /**
-     * Acknowledge every deferred write that has been handed to a context
-     * manager: sync the chronicle so the appended slots are durable, and only
-     * then drop them from the recovery queue. If the sync fails they stay in
-     * the durable queue (the next ack, or stop(), retries); a reboot in that
-     * state replays them, deduplicated by `deferredWriteId` for any that did
-     * reach disk. Idempotent and cheap when nothing is un-acked.
-     */
-    private ackDeferredWrites;
-    /**
-     * Move drained entries into the un-acked set and record, per target
-     * agent, the store position they will be appended after — then persist
-     * that receipt BEFORE any of them is written. Boot recovery scans from the
-     * recorded position to the tail, so every member of an interrupted batch
-     * is visible to the dedup, however large the batch.
-     */
-    private handOffDeferredWrites;
-    /**
-     * Which of `ids` already exist in some agent's store as a landed deferred
-     * write (`metadata.deferredWriteId`). Scans each context manager's recent
-     * tail blob-free — an interrupted flush is always within the last few
-     * hundred slots — and tolerates facades without windowed reads. A context
-     * that can't be read throws, naming its agent: counted as holding none, a
-     * write that landed there before its ack would land a second time.
+     * Which of `ids`, an earlier release's queued writes, already exist in
+     * some agent's store as a landed write (`metadata.deferredWriteId`): one an
+     * interrupted flush of that release stored before its ack, or one this
+     * importer stored at a boot that ended before it cleared the record. Scans
+     * each context manager from the record's per-agent position (the whole
+     * store where it names none) to the tail, blob-free, and tolerates facades
+     * without windowed reads. A context that can't be read throws, naming its
+     * agent: counted as holding none, a write that landed there would land a
+     * second time.
      */
     private landedDeferredWriteIds;
     /** Atomic, durable JSON write for the recovery files. The document goes to
@@ -2043,95 +2097,144 @@ export declare class AgentFramework {
     private readRecoveryFile;
     private warnRecoveryFallbackOnce;
     /**
-     * Mirror the deferred-write queue durably while quiesced (and until an
-     * already-persisted queue drains). The quiesce flag itself is persisted
-     * because a crash mid-surgery is an expected event; the messages withheld
-     * BECAUSE of that surgery would otherwise die with the process — and the
-     * window is operator-length, not turn-length. Lives in the
-     * branch-independent recovery file so a rollback cannot orphan it.
-     * Deferrals outside a quiesce window (turn-alive, mid-tool-cycle) are
-     * mirrored only while such a queue is still persisted; otherwise they are
-     * memory-only: they land within the turn, at a tool boundary or at its
-     * end, and a crash before then loses them. That window runs to the turn's
-     * end for a message held there and what is queued behind it, and, on a
-     * stream that doesn't declare it carries injected messages (membrane's XML
-     * prefill path declares it can't), for every message deferred during the
-     * turn.
+     * Store, once, the context writes a release before #291 left queued
+     * (src/deferred-import.ts reads its record), and clear the record. One
+     * release only: the release after this one deletes it. A host boots this
+     * release until its record is empty (the `deferred-import` alert says
+     * when writes stay queued, such as those for an agent a move cut), and
+     * doesn't upgrade past it from a release that kept a queue.
+     *
+     * Such a release held a write while its agent's turn was alive or the host
+     * was quiesced, and mirrored the queue to its recovery file (or the
+     * store's slot) while quiesced, or from a flush that might not have
+     * reached disk, until the queue drained. This release keeps no queue, so
+     * create() calls this once, after the quiesced flags are restored and
+     * every agent's window was written down at its registration, and before
+     * the boot's pass over the windows (repairAndRest) and the registry's
+     * reconcile:
+     *
+     * - A record that can't be read, or that isn't a queue, fails create()
+     *   (deferredWritesRefusal), and so does a context that can't be checked
+     *   for writes that already landed: taken as empty, the writes would never
+     *   be stored, or would be stored twice.
+     * - Each write is stored in the order it arrived, across agents, under
+     *   its own id (`metadata.deferredWriteId`, addMessage's `imported`), so a
+     *   later boot finds it. One that already landed is skipped by that id: an
+     *   interrupted flush of the earlier release stored it before its ack, or
+     *   a boot of this one stored it and ended before it cleared the record.
+     *   One whose earlier write may have landed (`landing: 'unknown'`) is
+     *   looked up across its agent's whole branch first: found, it isn't
+     *   stored again; where the branch can't be searched, that agent is cut
+     *   there.
+     * - A write keeps the audience it was queued with. One queued with none,
+     *   by a release before the stamp, is stamped as addMessage stamps any
+     *   write, and a tool-block pair (the puppet's) as its agent's own row.
+     * - A write for an agent no longer registered goes to the primary, as its
+     *   by-name notice under the write's own id, when it is a failed reply, a
+     *   channel notice its reader could act on, or a module's write for a run
+     *   or a fork (passesToPrimary); anything else is dropped, logged. The
+     *   notice is stamped for the primary alone, whatever stamp the write was
+     *   queued with: one for the gone agent would put it in no window.
+     * - A write that can't be stored cuts its agent: it and that agent's later
+     *   writes stay in the record for the next boot, and the other agents' go
+     *   on. One context-manager refuses as malformed, which it would at every
+     *   boot, is dropped, logged.
+     * - A tune-out's release (`kind: 'tune-out-cancel'`) stored here owes its
+     *   agent the wake its cancel requested (#232 gap 6).
+     * - Mail an imported write carries is released as it is stored
+     *   (releaseLandedMail), so reconcile doesn't deliver it again; the
+     *   boot's pass after the import asks its recipient's wake
+     *   (wakeForUnpresentedMail), as the delivery did.
      *
-     * A write that fails, or a queue over the cap, which writes nothing,
-     * leaves the record as it last held it, except that store only, a write
-     * whose sync failed is in the store, where a later sync can still put it
-     * on disk (writeDeferredWritesSlot). The queue stays in memory and
-     * mirrored, so its next change writes it again. Until a write succeeds, a
-     * restart restores what the record holds, or doesn't start if it can't
-     * read the record: it loses writes queued since, and brings back an entry
-     * withdrawn since (removePlacement, RFC-006's removal of an unread
-     * deferred write) that it still lists. The callers go on: a
-     * deferral's caller has already answered its source, so failing it would
-     * lose a write that can still land at resume. The first such write after
-     * one that succeeded raises an ops alert, and a line says when a write
-     * succeeds again (deferredWritesFellBehind). quiesce() writes the queue
-     * itself before it changes the host's mode, and refuses instead, unless
-     * the call has `abandon` (writeDeferredWritesForQuiesce).
-     */
-    private persistDeferredWrites;
-    /**
-     * Write the queue to its record as it stands, when the host is quiesced
-     * (`quiesced`, which quiesce() passes before it sets the flag) or the
-     * queue is mirrored: the queue when it holds anything, and an empty one
-     * over a record that held one. What the write throws is thrown. A queue
-     * whose JSON is longer than the cap writes nothing.
-     */
-    private writeDeferredWrites;
-    /** Store only, the slot is the record, and a write isn't on disk until the
-     *  store syncs, so a sync that fails is the write's failure, as in
-     *  persistHostMode. The slot is set by then, and a later sync can still
-     *  put it on disk, so writeDeferredWrites marks the queue mirrored before
-     *  it writes; a boot that restores such a queue skips each entry that
-     *  already landed. */
-    private writeDeferredWritesSlot;
-    /** The durable queue: every deferred write not yet acked, pending and
-     *  un-acked, in deferral order. */
-    private durableDeferredWrites;
-    /** Where the queue is recorded, as an operator would look for it. */
-    private deferredWritesRecord;
-    /**
-     * quiesce()'s write of the queue, before it changes the host's mode, as a
-     * quiesced host keeps it: a write held only in memory, such as one
-     * deferred behind a turn still alive, is on disk before quiesce() goes on,
-     * as its record is. When the queue can't reach disk, because its write
-     * fails or it's over the cap, which writes nothing, a call with `abandon`
-     * goes on with the queue in memory and the failure's or the cap's alert.
-     * Any other throws a QuiesceBlockedError naming the ways out, so quiesce()
-     * rejects with the host's mode as it was (store only, the slot set before
-     * a sync that failed leaves the queue mirrored: writeDeferredWritesSlot).
-     * Writes a flush landed stay in the queue until a store sync acks them, so
-     * it first retries an ack whose sync failed: once a sync succeeds they're
-     * on disk, and they leave the queue rather than count against the cap.
-     */
-    private writeDeferredWritesForQuiesce;
-    /**
-     * A write of the queue failed, or met the cap, and quiesce() didn't reject
-     * for it. The queue stays mirrored, so its next change writes it again.
-     * The first such write since one that succeeded raises an ops alert naming
-     * the record, and the rest of the run raises none. A failed write's own
-     * line is logged each time (persistDeferredWrites), and the cap's line the
-     * first time the cap is met in a run, whatever began it. On a host that is
-     * or is about to be quiesced, both say to resume before any restart, since
-     * a quiesced host lands its deferred writes only at a resume.
-     */
-    private deferredWritesFellBehind;
-    /** A write of the queue succeeded after a run of failures: say that the
-     *  record has caught up. */
-    private deferredWritesCaughtUp;
-    /**
-     * Restore the deferred-write queue a crash or a stop left durable. Nothing
-     * stored is an empty queue. A queue that can't be read, or that reads as
-     * anything but a queue, throws, since taken as empty the next deferral
-     * would replace the stored one; so does a context that can't be checked
-     * for writes that already landed (see landedDeferredWriteIds).
-     */
-    private restorePersistedDeferredWrites;
+     * - A write with no id is given one as it is read (readPersistedDeferredWrites),
+     *   and the record is written with it before anything is stored, so the
+     *   next boot finds a copy that landed by it. Where that write fails,
+     *   such a write cuts its agent.
+     *
+     * What is stored is presented to no window here: the pass after the
+     * import presents each agent its own rows and what it is owed at rest, and
+     * a quiesced host's other rows wait for resume. Once every write is stored
+     * the store is synced, and only then is the record cleared, or written
+     * again with the writes cut for the next boot; a sync that fails leaves
+     * the record as it was, and the next boot skips what landed.
+     */
+    private importPersistedDeferredWrites;
+    /**
+     * At boot, the wakes a tune-out's rows still owe their agents (#232 gap
+     * 6). A tune-out's release for the resident (`kind: 'tune-out-cancel'`)
+     * and its notices for the subconscious (`tune-out-wake`,
+     * `tune-out-cadence`, `tune-out-cancel-report`,
+     * `tune-out-note-undelivered`) are stored at once and
+     * made durable (commitDeliveries), but the wake each asks for is in
+     * memory. One stored while a turn of its agent's was alive stays out of
+     * that agent's window until its next tool boundary or the turn's end,
+     * and its wake runs after; a
+     * process that ended before then lost the wake, and the row is still not
+     * in the window at the next boot. So each such row owes its agent a wake,
+     * asked for here, before the boot's pass presents what each agent is owed
+     * (repairAndRest). Earlier releases kept such a row in the deferred queue,
+     * whose restore asked for the same wake; the importer still asks for it
+     * for a release it stores (importPersistedDeferredWrites), and is not
+     * asked twice. A row in the window already was presented at rest or
+     * injected at a tool boundary, its wake run or lost with the turn as
+     * before #291. Nothing for an agent the index doesn't present for. A
+     * window that can't be read is logged and asks for nothing, and its agent
+     * is returned: the boot's pass leaves what it is owed out of its window
+     * (repairAndRest's `restExcept`), so a later boot reads it again.
+     */
+    private wakeForUnpresentedTuneOutRows;
+    /**
+     * At boot, the wakes stored mail still owes its recipients (#291). A
+     * result or a message is stored for its recipient as it is delivered,
+     * whatever the recipient's turn, and its mail released once the store has
+     * synced the row (releaseLandedMail); the wake the delivery asks for is in
+     * memory. Mail stored while a turn of its recipient's was alive stays out
+     * of that agent's window until the turn's next point (its tool boundary
+     * or its end), and its wake runs after the turn, unless a request of
+     * the turn carried the row and was answered (rowDone); a process that
+     * ended before then lost the wake, and the next boot has nothing left to
+     * deliver: the mail is no longer held (or is released there, its copy
+     * found in the store), and an interrupted job's result, stored, needs no
+     * "ended without a result" notice (resultStoredFor). So each agent the
+     * index presents for is woken, once per sender and kind, for each row of
+     * mail it is owed and its window doesn't hold, as the delivery's wake
+     * (`agent-<kind>:<sender>`, source 'dendrite'), asked for here, before the
+     * boot's pass presents what each agent is owed (repairAndRest). That
+     * covers mail an earlier release left queued, which the importer stores
+     * and releases. The row is the recipient's when it
+     * names that agent as the one it is for (`dendrite.to`); one stored before
+     * mail named its recipient counts for an agent its audience names, so a
+     * slot's observer isn't woken for a resident's mail. Mail whose sender
+     * asked for no wake (sendAgentMessage's `wake: false`, recorded on the row
+     * as `dendrite.wake: false`) asks for none; reconcile's redelivery of held
+     * mail doesn't ask, as the registry doesn't record it. Mail an earlier
+     * release left queued records no such ask (that release didn't queue
+     * it), so it is woken for whatever its sender asked, where main asked no
+     * boot wake for any queued mail.
+     * Mail in the window already was presented at rest, or sent in a request
+     * of the turn's (at its tool boundary), its wake run or lost as before
+     * #291, and asks for none; nor does a wake with the same reason already
+     * pending. A window that can't be read is logged and asks for nothing, and
+     * its agent is returned, as wakeForUnpresentedTuneOutRows returns one. The
+     * wakes are asked in memory: once the pass has presented the rows, a
+     * process that ends, or a create() that fails, before they run loses them,
+     * and the next boot, which finds the rows in the window, asks for none.
+     */
+    private wakeForUnpresentedMail;
+    /**
+     * Write the deferred-write record the importer read once it is done:
+     * empty, or holding the writes it left for the next boot, in their order.
+     * The file where it was read from the file, else the store's slot. A
+     * write that fails is logged and alerted: the next boot imports the
+     * record again, and skips what landed by its id.
+     */
+    private writeImportedRecord;
+    /**
+     * Write the deferred-write record the importer reads: empty, or holding
+     * `entries`, in their order. The file where it was read from the file,
+     * else the store's slot, synced. Throws what the write threw.
+     */
+    private recordImportQueue;
     /**
      * Operator-driven maintenance: run (or join) one bounded compression pass —
      * the same runQueuedMaintenance the timer drives, so tool definitions are
@@ -2482,13 +2585,22 @@ export declare class AgentFramework {
     private discardEphemeralCandidate;
     /**
      * The default wording for the call that derived a child: who it is, what
-     * kind, and how long — the fields the consent event names, so the fork
+     * kind, and how long — the fields the creation event names, so the fork
      * never has to infer its own lifetime from context (Linn, 10-09).
      */
     private derivedNote;
     /**
      * The parent's in-flight tool round, reproduced on the child's branch so
      * the child sees the call that made it (see `DeriveAgentOptions.pendingRound`).
+     *
+     * The results it carries are the ones the parent holds: while the round
+     * waits for its tools, those `completed` so far; once every result is in,
+     * the `ready` state's `toolResults`. A round stays pending while a boundary
+     * builds its results for storing (the ordinary tool boundary, or a stream
+     * that completed while its tools ran, which gave each call still running
+     * an error result), and the state is `ready` then, so a derive landing in
+     * that build frames the round with its results, never with a note that a
+     * call whose result is in is still running.
      */
     private framePendingRound;
     /**
@@ -2530,10 +2642,20 @@ export declare class AgentFramework {
      * - A live agent: a snapshot derived from its context — at the head, or
      *   at `atSequence` for an earlier state. The snapshot is its own branch;
      *   the agent keeps running and is not affected by anything done to it.
+     *   `atSequence` is a sequence on the store's branch that follows a
+     *   presentation into the agent's window (#291), such as
+     *   `getStore().currentSequence()` read after one, not a row's own
+     *   sequence: a row enters the window at a write after its own, so a cut
+     *   at the row's own sequence holds it in the snapshot's record
+     *   (getAllMessages) and not in its window (getPresentedMessages), where
+     *   it reads as arrived (context-manager's derive).
      * - An ended agent: the context it left, reopened where it lives.
      *
-     * The returned manager uses a passthrough strategy: it shows what is
-     * stored, raw. An ended agent's context is the real one — treat it as
+     * The returned manager uses a passthrough strategy, so nothing is
+     * folded: its compile is the agent's window as the agent's view shows it
+     * (the rows the window holds, through its view filter), and in legacy
+     * mode, where the window is the record, the record so. getAllMessages()
+     * lists the record. An ended agent's context is the real one — treat it as
      * read-only unless you mean to change what a later resume starts from.
      */
     inspectAgentContext(name: string, options?: {
@@ -2541,6 +2663,31 @@ export declare class AgentFramework {
     }): Promise<ContextManager>;
     /** Open the context an ended agent left, wherever it lives. */
     private reopenAgentContext;
+    /**
+     * The view an agent's live context was opened with, by where its rows go
+     * and what it observes (context-options.ts): a resident's, on the
+     * residents' slot, or for an isolated agent that watches that slot, the
+     * residents' view when its edge leaves held traffic out, and the
+     * subconscious's when it shows it. Undefined for an isolated agent that
+     * watches no residents' slot on its branch (a worker, a conversation
+     * fork), whose context was opened with no filter.
+     */
+    private liveViewFilterOf;
+    /**
+     * The agent a chain of shared derivations started from, whose view each
+     * derived context in it inherited: `record` itself when it isn't one, and
+     * the newest record the registry has of a parent otherwise, back to one
+     * that isn't (or one the registry no longer knows, by its name).
+     */
+    private viewOwnerOf;
+    /**
+     * The view a context derived by shared inheritance was opened with
+     * (deriveSharedContext): what the agent its chain of derivations started
+     * from sees (liveViewFilterOf), and the stored injections of each agent in
+     * the chain, which carry that agent's name and would otherwise read as
+     * another's. Undefined when the owner's context has no filter.
+     */
+    private derivedViewFilterOf;
     /** Open a derived agent's context on a branch of its own (see deriveAgent). */
     private deriveSharedContext;
     /** Flat list of registered agents with their roles, lifetime and relationships. */
@@ -2641,19 +2788,23 @@ export declare class AgentFramework {
      * else would surface it (reparentAgent delivers it).
      */
     private tellResultHeld;
-    /** A host-framed lifecycle fact in an agent's context. Never voiced as anyone. */
+    /**
+     * A host-framed lifecycle fact in an agent's context. Never voiced as
+     * anyone. Its `dendrite` detail names the agent it is for (`to`), as mail's
+     * does.
+     */
     private lifecycleNotice;
     /**
-     * The creation ("consent") event: names what kind of agent this is, what
-     * ends it and what happens to it when its spawner ends. A derived agent's
-     * creation is told to the agent it was derived from only when the host
-     * asks for it with a derivationNotice and that returns text: one
-     * host-framed line in the source's context, with no wake, given the
-     * framework's line built from the same facts as the trace. Without one the
-     * source is told nothing; the trace is emitted either way. Both derivation
-     * paths announce after the fork's branch or copy exists, so a fork never
-     * inherits the notice about itself; a source that has ended is told
-     * nothing (lifecycleNotice).
+     * The creation event: names what kind of agent this is, what ends it and
+     * what happens to it when its spawner ends. A derived agent's creation is
+     * told to the agent it was derived from only when the host asks for it
+     * with a derivationNotice and that returns text: one host-framed line in
+     * the source's context, with no wake, given the framework's line built
+     * from the same facts as the trace. Without one the source is told
+     * nothing; the trace is emitted either way. Both derivation paths announce
+     * after the fork's branch or copy exists, so a fork never inherits the
+     * notice about itself; a source that has ended is told nothing
+     * (lifecycleNotice).
      */
     private announceAgentCreated;
     /** The derivation notice's text, addressed to the agent `from` the record was derived. */
@@ -2739,6 +2890,9 @@ export declare class AgentFramework {
      * ran would be overwritten by this boot's first registration.
      */
     private restoreAgentRegistry;
+    private passOnInterruptedNotices;
+    /** The rows of the interrupted record `from` (name#incarnation@createdAt) whose pass the primary's store holds (passOnInterruptedNotices). */
+    private rowsPassedOn;
     /**
      * Boot reconciliation, once configuration has declared its agents.
      * Restart behaviour follows from lifetime: persistent agents were just
@@ -2750,11 +2904,54 @@ export declare class AgentFramework {
     /**
      * Deliver held mail that hasn't landed. Its copy may have reached the
      * recipient's store in the same sync that the release missed, and then it
-     * is released instead; and a write the deferred queue still holds for it
-     * lands at the next flush and releases it then (releaseLandedMail). Either
-     * way a second delivery would put it in the window twice under one mail id.
+     * is released instead. In the residents' shared slot the recipient's
+     * store holds every resident's mail, so a copy counts only where it was
+     * for this recipient (dendrite.to); a row stored before mail carried `to`
+     * counts by its mail id alone (isMailCopyFor).
+     *
+     * A write an earlier release queued for this mail, which the importer
+     * stored, was released as it was stored (releaseLandedMail), and one
+     * whose release missed its sync is found here. One the importer left
+     * queued for the next boot (importLeftQueued) lands then and releases the
+     * mail then; a second delivery here would put it in the window twice
+     * under one mail id. A copy for another recipient is not that write, as a
+     * stored one isn't.
+     *
+     * A copy found is released only once the store has synced, as
+     * releaseLandedMail releases: the copy may be in memory only (an import
+     * whose sync failed), and the release is written to the registry's own
+     * recovery file at once. A sync that fails leaves the mail held and
+     * undelivered, for the next boot's check.
      */
     private deliverHeldMail;
+    /**
+     * Whether `recipient`'s store holds a result the agent `record` names
+     * delivered in this incarnation, for that recipient (dendrite.to, or none
+     * on a row stored before mail named its recipient). Mail is released once
+     * its row is stored, so after a restart that interrupted the agent, its
+     * result is no longer held mail but is in the store: a recipient whose
+     * turn was alive when it arrived has it stored at once, as an idle one
+     * does (#291). It counts as handed over even while it is out of the
+     * recipient's window, the turn it arrived in cut off by the restart: the
+     * boot asked that recipient's wake for it again (wakeForUnpresentedMail),
+     * and its pass presented it.
+     *
+     * A result counts only where it was produced (dendrite.producedAt, which
+     * every delivered result carries) at or after the record was created: a
+     * single-use name whose counter aged out of the registry starts again at
+     * incarnation 1, so an earlier agent of that name and incarnation may have
+     * delivered one to the same recipient. Both times are the registry's wall
+     * clock (Date.now): the two agents are always on opposite sides of a
+     * restart, so they don't share a millisecond, but a clock stepped back
+     * between the record's creation and its result can misjudge the result
+     * as an earlier agent's.
+     *
+     * Undefined where the store can't be read, which is logged: whether the
+     * result was handed over is unknown, so the boot leaves the record out of
+     * its notice and of its settling (settleInterrupted), and the next boot
+     * asks again.
+     */
+    private resultStoredFor;
     private createDeferred;
     /** Liveness ping for an active ephemeral run (no-op otherwise). */
     private touchEphemeralRun;
@@ -2810,9 +3007,22 @@ export declare class AgentFramework {
      * Query inference logs.
      * Returns entries with summary info (doesn't resolve blobs).
      */
-    /** Tune-out (issue #77): divert a channel to your subconscious. Present
-     *  only when the subconscious resident is configured. */
-    private static readonly TUNE_OUT_TOOL;
+    /** Tune-out (issue #77): hold a channel. Offered when a reader is
+     *  configured (tuneOutOffered), its text naming the reader (tuneOutTool). */
+    private tuneOutToolDefinition;
+    /**
+     * The reader of a tuned-out channel's traffic, as the text a resident
+     * reads describes it (tuneOutTool, tunedOutSendNote, tune_out's answers
+     * and the channel registry's refusals of a tuned-out channel): the persistent
+     * subconscious by the name it runs under, which the host gives it, or
+     * reader forks as forks of the resident's context. There is no hold
+     * without a reader (0.33.0): a tune-out is on record with none running
+     * only where its release failed, after the persistent reader ended or at
+     * a start with none configured. The text names the persistent reader as
+     * configured then, or by its default name (persistentReaderName), as one
+     * not running (`running: false`), which what its messages are says.
+     */
+    private tuneOutReader;
     /** `focus`: the resident-facing alias for `tune_out` with scope "all-except" (#232 decision 2). */
     private static readonly FOCUS_TOOL;
     /** Synthesized sleep/wake tool definitions (present when a gate is wired). */
@@ -2823,7 +3033,15 @@ export declare class AgentFramework {
      *  hot-reloaded gate.json (same validation as load), so a rule takes effect
      *  immediately and survives restart. */
     private static readonly WAKE_RULE_TOOLS;
+    /** Wake onboarding's answers (gate/wake-onboarding.ts): accept an MCPL
+     *  server's suggested treatment (MCPL RFC-001 §5), all of it or some, or
+     *  decline it. Present when a gate is wired and onboarding is on. */
+    private static readonly WAKE_ONBOARDING_TOOLS;
     private static readonly JUDGED_WAKE_RULE_TOOLS;
+    /** What the agent's suppress rules have kept out of its context, read from the stamped rows (gate/suppression-stats.ts). Present when a gate is wired. */
+    private static readonly SUPPRESSION_STATS_TOOL;
+    /** Writes the stamped rows to a workspace file (gate/suppression-stats.ts). Present when a gate and a workspace are. */
+    private static readonly DUMP_SUPPRESSED_TOOL;
     /** Discoverability for event tags (MCPL RFC-001): the reserved chat:* core,
      *  each connected server's declared tag ontology, and gate.js status. */
     private static readonly EVENT_TAGS_TOOL;
@@ -2864,6 +3082,35 @@ export declare class AgentFramework {
      * skipped.
      */
     private reactToRefusal;
+    /**
+     * Shed the newest turn: take the newest message that isn't a system
+     * message, and that reached a request, out of what the agent is sent,
+     * whoever wrote it, with the rest of its exchange (the tool_use turn
+     * paired with a tool result, and the whole of a body stored in shards).
+     * With `carried` (the stored bodies a refused request's compile carried,
+     * by each body's first message id), only a message that request carried
+     * counts, or the stored result of a call it carried, which goes with that
+     * call as one exchange; a row that carries nothing a request sends
+     * (asNextRequestCarries) is passed over and left in place. It adds no
+     * marker; the caller keeps one consolidated marker for the episode
+     * (updateRewindMarker). The returned record's descriptor says what was
+     * set aside and its size, never the content. Returns null when nothing
+     * that counts is left.
+     *
+     * On a presented window (#291) the shed is the window's: the newest rows
+     * of the agent's own window, in its order, leave it as an undone turn's
+     * do (retractRows with `undone`), so no presentation point brings them
+     * back, and the record keeps them, as the marker says. No other agent's
+     * window, nor its cache prefix or signed thinking, changes. A row the
+     * agent is never sent is passed over: a system_change row, a row a
+     * tune-out holds from residents (for an agent whose window leaves them
+     * out), and another agent's stored context injection. On a window that is
+     * still the record, the rows are removed from it, as before the index,
+     * and leave every other window that held them.
+     *
+     * Shared by the refusal rewind, automatic or forced by `/unstick`, and by
+     * the shed after inference exhaustion (quarantinePoisonedHistory).
+     */
     private shedNewestTurn;
     /**
      * Maintain exactly ONE consolidated marker for the current rewind episode,
@@ -2920,8 +3167,11 @@ export declare class AgentFramework {
      * Handle a `host/command` request from an MCPL surface server (e.g. a
      * Discord slash command). Currently supports:
      *
-     *   undo — revert the last N inference turns (branch-based, see
-     *   `undoLastTurn`). The response includes the last message the agent
+     *   undo — revert the last N inference turns on the agent's window (see
+     *   `undoLastTurn`; no branch moves), or with `messages`, the last N rows
+     *   of its window that are in its own slot (the record's, on a window that
+     *   is still the record), by a rollback onto a new branch (see
+     *   `rollbackToMessage`). The response includes the last message the agent
      *   would see in its context after the undo, obtained via the transparent
      *   `previewActivation` render (no inference, no Chronicle writes).
      *
@@ -2987,73 +3237,260 @@ export declare class AgentFramework {
      * It moves the store once any maintenance already running has finished, so
      * the move can come after the call returns, and a refusal moves nothing.
      * An operator's operation: refused once stop() has begun, and waited for
-     * by stop() while it runs.
+     * by stop() while it runs. It is written to the operator log as a
+     * `checkout` (`requester` and `note` as the caller gives them), a refusal
+     * or failure with its error, but for the refusal once stop() has begun,
+     * which throws before anything is written.
      *
      * The branch moves under every agent sharing the store, so the switch
      * reserves the store as a surgery does: every agent must be idle with no
      * turn alive (no continuation or held retry of one on its way), or it is
      * refused (OperatorActionError 'agent-busy'), and no turn starts until the
-     * switch is done.
-     *
-     * Every agent's context manager is re-initialized for the branch before
-     * the store is released (reinitializeManagers). One whose
-     * re-initialization fails raises an ops alert naming its agent
+     * switch is done. Before the reservation is released every live agent's
+     * context follows the move (followBranchMove): its context manager is
+     * re-initialized for the branch (reinitializeManagers), and its window is
+     * written down there if the branch was made before its write-down. One
+     * whose re-initialization fails raises an ops alert naming its agent
      * (`context-reinit-failed`), and the switch still resolves. A switch to the
      * branch the store is already on re-initializes them too, which is how a
      * manager left refusing by a failed re-initialization is recovered without
      * a restart.
      */
-    switchBranch(name: string): Promise<void>;
-    /**
-     * Undo the last inference turn for an agent.
-     *
-     * Creates a new branch at the Chronicle sequence recorded before that turn
-     * and switches to it, atomically rolling back all state (messages, context
-     * log, inference log, MCPL checkpoints).
+    switchBranch(name: string, opts?: {
+        requester?: OperatorRequester;
+        note?: string;
+    }): Promise<void>;
+    /**
+     * After the store's branch moved, under a store reservation (a host's
+     * switchBranch, a rollback's switch, a suppression's fork, or a failed
+     * surgery's restore): every live agent's context follows the move. Its
+     * context manager is re-initialized for the branch the store is on
+     * (reinitializeManagers, #353), every one but `except`'s, the agent the
+     * move was made through, whose own switchBranch or fork initialized it,
+     * or whose failed surgery's restore left it refusing its work, which
+     * counts here as a failed re-initialization, reported by the restore and
+     * not returned (a manager that didn't make the move keeps its strategy at the old
+     * branch generation otherwise, and an AutobiographicalStrategy refuses
+     * every compile until a re-initialization). Then the presentation index
+     * rebases each agent on the new branch (#291): a window the branch has
+     * none of (a branch made before the agent's write-down, a rollback into
+     * rows the write-down presented) is written down, and the agent's own
+     * rows not in its window are presented, so an agent that presented before
+     * the move presents after it, and an agent whose configuration names how
+     * other agents' rounds go out to it is sent them so where its window is
+     * presented now, as stored where it isn't (applyForeignRounds). Arrivals
+     * wait for the reservation's release, which presents what each agent is
+     * owed. Redo entries are
+     * dropped, every agent's: each was an undo on a window of the branch the
+     * store left. A switch to the branch the store was on (`sameBranch`, a
+     * refusing manager's recovery) moves no branch, so each agent whose
+     * window is presented after the rebase keeps its redo entries: an undo is
+     * a retraction on that window, and the rebase presents no undone row
+     * (main kept redo across a switch too). Returns the managers whose re-initialization failed, for
+     * the caller to report (reportReinitFailures) before it releases the
+     * store.
      *
-     * The undone branch is saved so `redo()` can restore it.
-     * Returns the checkpoint that was undone, or null if nothing to undo.
+     * Never throws: the move has happened. A manager whose re-initialization
+     * fails stays fenced until a later one succeeds (switchBranch() to the
+     * branch the store is on), and its agent's window stays the record until
+     * the next move, traced as presentation:failed at `'rebase'`; so does an
+     * agent whose window can't be written down. The writes for it meanwhile
+     * wait in memory (heldForRecovery), and the move whose re-initialization
+     * of it succeeds stores them at its release (recoverHeldWrites).
+     */
+    private followBranchMove;
+    /**
+     * Undo the last inference turn for an agent, on its window (#291,
+     * decision 4): the rows the turn's checkpoint saw enter the window after
+     * it leave it, the agent's own as undone and others' as arrived and not
+     * yet presented, which its next start presents again. Nothing is written
+     * to the record and no branch moves, so `fromBranch` and `toBranch` are
+     * both the store's branch, `window` says how many rows left, and a
+     * `window:undone` trace is emitted. The record, the workspace and
+     * `_config` mounts, MCPL checkpoints and the inference log are left as
+     * they are: rollbackToMessage is the record-level revert. `redo()` puts
+     * the rows back. It is refused while a turn of the agent's is alive, and
+     * allowed while another agent's is, and refused for an agent whose window
+     * isn't presented (presents: a write-down that failed, at its
+     * registration or after a branch move, or a context that couldn't follow
+     * a branch move), which has no window of its own to undo on.
      *
-     * The branch moves under every agent sharing the store, so an undo
-     * reserves the store as a surgery does: every agent must be idle, or it is
-     * refused (OperatorActionError 'agent-busy'). It returns once the store has
-     * moved, and the store stays reserved until every agent's context manager
-     * is re-initialized for the new branch, so no turn starts before then. One
-     * whose re-initialization fails raises an ops alert naming its agent
-     * (`context-reinit-failed`). An undo or redo made before the managers are
-     * done moves the store again under the same reservation, and they are
-     * re-initialized for the branch the last one leaves.
+     * Returns `{ undone: false }` when there is nothing to undo. A store error
+     * before any row has left the window is thrown as it is, and the turn can
+     * still be undone. An undo that fails after rows left (cut short, or its
+     * checkpoint save failing) throws OperatorActionError 'failed', saying how
+     * many rows left, and can be redone (undoOnWindow).
      *
-     * `settled`, present when the store moved, settles once that reservation
-     * is released, every manager re-initialized or its failure alerted, and
-     * never rejects. Await it before work that needs the store free: a
-     * compile on an agent's own context manager, or a write meant to land at
-     * once, which the reservation would defer. An undo or redo that moves the
-     * store again under the same reservation settles with it.
+     * No branch moves, so nothing is reserved and no context manager is
+     * re-initialized (#353's re-initialization follows a branch move, and an
+     * undo on the window makes none): every other agent goes on compiling.
+     * Its result carries no `settled`, which an undo gives only when it moved
+     * the store.
      */
     undoLastTurn(agentName: string, requester?: OperatorRequester): {
         undone: boolean;
         turnIndex?: number;
         fromBranch?: string;
         toBranch?: string;
+        window?: {
+            retracted: number;
+            represented: number;
+        };
+        /** Present only when the undo moved the store, which an undo on the
+         *  window never does: nothing waits to settle (#291, decision 4). */
         settled?: Promise<void>;
     };
     /** undoLastTurn's work, for a host/command undo already admitted: a stop()
      *  begun by a trace of one of its turns doesn't refuse the next. */
     private runUndoLastTurn;
     /**
-     * Redo a previously undone turn for an agent.
+     * An undo on the window (undoLastTurn): the
+     * agent's newest checkpoint's tail of its window, the rows at the index
+     * length it recorded and after (checkpointLength), leaves it. The agent's
+     * own rows leave as undone, so no presentation point presents them again
+     * until a redo; others' rows leave as arrived and not presented, and its
+     * next presentation point presents them again, after what it holds then.
+     * The rows are named body by body, by the shard that names each, in
+     * window order, and kept for redo with the ordinal each held, the index
+     * length the undo left, and which of them each of the agent's marks
+     * covered (marksOverTail).
      *
-     * Switches back to the branch that was active before the last undo.
-     * Returns false if there's nothing to redo.
+     * Own rows and others' leave in two calls, each whole or not at all on a
+     * store that batches. The redo entry is kept before either, so an undo
+     * cut short after rows left (between the calls, or partway through one
+     * on a store without the batched form) is refused with
+     * OperatorActionError 'failed' and can be redone: a redo puts back what
+     * left, in its order, and its checkpoint stays for another undo to finish
+     * it. So is an undo whose rows all left and whose checkpoint save then
+     * failed: the checkpoint stays saved, and the next undo, which finds
+     * nothing of its turn left in the window past it, saves the checkpoints
+     * without it and keeps no redo of nothing (the entry kept puts the rows
+     * back). An undo that took nothing out throws its error and keeps
+     * nothing. Each refusal after rows left is traced (`window:undone`) and
+     * recorded with its error.
+     */
+    private undoOnWindow;
+    /**
+     * Where a checkpoint's turn began in the agent's window: the index length
+     * it recorded, on the branch it recorded it on. A checkpoint recorded
+     * before the window was presented (an earlier version's, or one taken
+     * while the context was in legacy mode), or on another branch, is
+     * converted: the place of the first row in the window stored after the
+     * checkpoint's sequence, or the window's end when there is none.
+     */
+    private checkpointLength;
+    /**
+     * The bodies of `cm`'s window at ordinal `from` and after, in window
+     * order: each by the shard that names it, with its ordinal and sequence,
+     * and whether it is `agent`'s own row. A stamped row is the agent's own
+     * when its stamp says so (isOwnRowOf). A row stored before the audience
+     * stamp (every turn an earlier release recorded, whose checkpoints an
+     * undo still takes) carries none, and the presentation index reads it as
+     * an arrival, so an undo that took it out as arrived would see it come
+     * back at the agent's next point: it is the agent's own when it is stored
+     * under the agent's voice (isOwnParticipant), holds only results of
+     * calls an own row of the window made, which such a release stored under
+     * `user`, or is a framework notice whose metadata names the agent as its
+     * owner (legacyNoticeOwner: a drafts notice, an `[auto-continue]` row, a
+     * stored injection), which such a release stored under `user` too.
+     */
+    private windowBodiesFrom;
+    /**
+     * The read marks held for `agent` (heldMarksOf's): its own
+     * (Agent.heldReadMarks), the marks its running scripts started with
+     * (AgentScripts.readMarksOf), which each script's sends are credited with
+     * having read (publishReadThrough), and those of its channel_publish calls
+     * still out (publishMarksInFlight). A redo gives them all again.
+     */
+    private heldMarksOf;
+    /**
+     * Hold a publish's mark (publishReadThrough's) while its call is out
+     * (publishMarksInFlight), so a redo meanwhile gives it again. `release`
+     * lets it go and returns the mark as it stands then, for notePublished.
+     */
+    private holdPublishMark;
+    /**
+     * The agent's marks (heldMarksOf: its own and its running scripts') that cover rows of `tail` by
+     * their ordinals in its window, read before an undo takes them out, each
+     * with the bodies it covers. A mark taken in legacy mode is one of them
+     * where it covers such rows: the window is presented (undo refuses one
+     * that isn't), and there it covers the rows the window held by its head
+     * where they stand (coverTest), which a redo puts back at new ordinals
+     * past it. One on another branch can't say, and isn't kept. A failure to
+     * read them is logged and keeps none: the redone rows then read as unread
+     * until the agent's next mark, as they did before redo gave marks again.
+     */
+    private marksOverTail;
+    /**
+     * A redo of an undo on the window. First the rows presented since the
+     * undo leave the window as arrived and not presented (they enter again at
+     * the agent's next point, after the redone rows), and with them any of
+     * the undo's own rows still in it (an undo cut short), so the redone
+     * rounds sit after the prefix their signed thinking was minted under.
+     * Presented since means in the window past the index length the undo
+     * left and not in it right after the undo: a body a later undo took out
+     * and its redo put back (`kept`) stays where it is, so undos redone in
+     * turn give back the window they took. Then the rows the undo took out
+     * enter it again, in their window order, but for one the store no longer
+     * holds. Each undo still to redo below this one (`below`, oldest first)
+     * notes which of the rows put back were in its window right after it
+     * (their ordinal before this undo was below the length it left), and the
+     * marks that covered the rows at the undo cover them again
+     * (retakeMarks). The checkpoint goes back, unless an undo cut short left
+     * it in place.
      *
-     * It reserves the store and re-initializes every agent's context manager
-     * as undoLastTurn() does, and its result's `settled` is undoLastTurn()'s.
+     * A step that fails once the window has changed (the retraction partway,
+     * the rows' return, the checkpoint save) refuses the redo with
+     * OperatorActionError 'failed', saying how many rows left and how many
+     * returned, traced (`window:undone`) and recorded with its error; the
+     * entry stays, and another redo finishes it, from the window as it then
+     * is. One that changed nothing throws its error as it is. The caller,
+     * redo(), takes the entry off the stack and traces and records a redo
+     * that went through, after this returns.
+     */
+    private redoOnWindow;
+    /**
+     * After a redo put `back` (the undo's rows, in window order) into the
+     * window again, at new ordinals past every mark: each mark the undo
+     * recorded (RedoEntry.marks) that the agent still holds is given again,
+     * covering the window as it stands up to the first row put back that the
+     * mark didn't cover at the undo. So a row the undone turn had read, and
+     * its reply answered, reads as read, shown and answered again, and one it
+     * hadn't reads as before; a row presented since the undo, which the redo
+     * took out and the agent's next point presents after, isn't covered. A
+     * mark the agent no longer holds (a compile moved it since the undo) is
+     * left as it is: what it covers is what the agent read later. Each undo
+     * still to redo below records the new mark in place of the old, and so
+     * does this one's entry, for a redo that finishes this one where it was
+     * cut short after the rows came back (redoOnWindow). A failure
+     * is logged and leaves the marks as they were: the rows put back then
+     * read as unread until the agent's next mark.
+     */
+    private retakeMarks;
+    /**
+     * Redo a previously undone turn for an agent, on its window (undoLastTurn):
+     * no branch moves, the rows presented since the undo leave the window,
+     * and the rows it took out enter it again, in their order, with `window`
+     * saying how many of each and a `window:undone` trace; the agent's marks
+     * that covered them at the undo cover them again. Undos are redone newest
+     * first, each giving back the window it took. Returns
+     * `{ redone: false }` if there's nothing to redo. Refused
+     * (OperatorActionError 'failed') when the store is on another branch
+     * than the undo was: its rows' places are that branch's window's. A
+     * branch move through the framework (switchBranch, a rollback, a
+     * suppression, a failed surgery's restore) drops every redo entry
+     * (followBranchMove), so this is a move made past it.
      */
     redo(agentName: string, requester?: OperatorRequester): {
         redone: boolean;
         fromBranch?: string;
         toBranch?: string;
+        window?: {
+            retracted: number;
+            represented: number;
+        };
+        /** Present only when the redo moved the store, which a redo on the
+         *  window never does: nothing waits to settle (#291, decision 4). */
         settled?: Promise<void>;
     };
     /**
@@ -3089,18 +3526,111 @@ export declare class AgentFramework {
      * Passing the gate RESERVES the store for the caller: a turn token is
      * held for every agent until the returned release runs, so no wake — via
      * the scheduler or a parked provider admission, both of which re-test
-     * turn-alive — can start a turn while the switch is awaited. Release also
-     * flushes messages that deferred behind the reservation, as the puppet
-     * does. Always release in `finally`: a token nobody clears wedges the fleet.
+     * turn-alive — can start a turn while the switch is awaited, and every
+     * write made meanwhile is held in memory (surgeryHeldWrites). Release
+     * stores what the hold kept, in arrival order, and presents each reserved
+     * agent what it is owed, as at a turn's end, but for the arrivals a
+     * rollback's cut returned, which wait for that agent's next turn start
+     * (presentation.holdUntilStart). Always release in `finally`: a token
+     * nobody clears wedges the fleet.
      */
     private reserveStoreForSurgery;
     private reinitializeManagers;
+    /**
+     * After a move's pass (reinitializeManagers): the writes kept in memory
+     * for each agent whose context manager refused its work
+     * (heldForRecovery), and whose re-initialization didn't fail this time,
+     * go back to the move's hold ahead of the writes it keeps now, which came
+     * after them, each agent's in arrival order. The release stores them
+     * through the ordinary write path and traces each as it lands
+     * (releaseSurgeryHeldWrites); one its manager still refuses there is kept
+     * for it again, and the ones after it wait behind it. An agent gone
+     * meanwhile passes them on (passHeldWritesOn). With no hold, which no
+     * move makes, they are stored now.
+     */
+    private recoverHeldWrites;
+    /**
+     * Keep `write` in memory for `agentName`, whose context manager refuses
+     * its work (heldForRecovery), behind the writes already kept for it. The
+     * first one kept is logged with the refusal that began the wait.
+     */
+    private keepForRecovery;
+    private refusesItsWork;
+    /** Whether writes for `agentName` wait in memory for its context manager's recovery (heldForRecovery). */
+    private waitsForRecovery;
+    /**
+     * At stop(), before its final sync: the writes still kept in memory, which
+     * no queue persists (#291), told of once per agent they are for, by a log
+     * line and an ops alert of kind `store-held-lost` naming how many and of
+     * what kinds. Those kept for an agent whose context manager refuses its
+     * work (heldForRecovery) are lost: no branch move follows a stop. Those
+     * a surgery's hold still keeps (surgeryHeldWrites, a hold whose operation
+     * outlived stop()'s wait for it) are stored only if it releases before the
+     * process exits. Mail among them stays held in the registry, and the next
+     * boot delivers it. Says nothing when none is kept. An alert's listeners
+     * run as it is raised, and a write one makes is kept so too, after this
+     * read of what is kept: each round tells the writes the rounds before it
+     * didn't, until one finds none new (a few rounds at most, for a listener
+     * that writes at every alert).
+     */
+    private reportHeldWritesAtStop;
+    /** One round of reportHeldWritesAtStop: tells the writes kept in memory that aren't in `told`, adding them; whether any was. */
+    private reportHeldWritesOnce;
+    /**
+     * The writes for `agentName` a surgery's release couldn't store, told of
+     * once: a log line and an ops alert of kind `store-held-lost`. Each was
+     * accepted with no id and kept in memory until the release, where its
+     * store threw. One context-manager found none of stored is lost (one it
+     * names rows of as stored, WriteLandedError, counts as stored and isn't
+     * here). One whose store couldn't be read to tell what of it landed
+     * (WriteOutcomeUnknownError: `unknown` holds one per such write) may be
+     * lost: the alert names the rows the errors name as stored, which the
+     * release presented and traced, and the rows the store may hold besides,
+     * by id and by count, and its data counts them (`mayBeStored`). The writes
+     * after them went on.
+     */
+    private tellHeldWritesLost;
+    /** How many writes wait in memory for an agent's recovery (heldForRecovery), every agent's. */
+    private writesHeldForRecovery;
+    /**
+     * Writes kept in memory for an agent that ended before they were stored
+     * (a fork a move emptied and disposed, or a fork or a run that ended while
+     * a hold kept them or while its context manager refused its work): each
+     * one the primary takes in its place, as a release of the agent's window
+     * passes it on (passesToPrimary: a failed reply, a channel notice its
+     * reader could act on, or a module's write for a run or a fork, which goes
+     * as the write itself), goes on to the primary by name
+     * (passNoticeToPrimary), in arrival order, where a hold keeps it until its
+     * release, as any write. The rest are dropped, which is logged and, unless
+     * the caller's own alert counts them (`counted`: a move's disposal of the
+     * fork), told of by an ops alert of kind `store-held-lost`: unlike a
+     * released window's unread rows, they never reach the record. Each write
+     * goes on by itself: one whose notice can't be built (passNoticeToPrimary
+     * doesn't guard that, and a channel notice's words read the store) is
+     * logged and counted among the dropped, and the rest still go on. Never
+     * throws.
+     */
+    private passHeldWritesOn;
+    /**
+     * The name a kept write names whose agent has ended, else undefined: no
+     * agent is registered under it, or another incarnation is, not the one
+     * the write was kept for (SurgeryHeldWrite.heldFor). A write that names no
+     * agent is the delivery agent's at its release, whichever that is then.
+     * `named` is the name the write was kept under, where a caller keys it.
+     */
+    private heldWriteTargetGone;
+    /**
+     * Take out of memory the writes kept for `agent`, which is ending: those
+     * kept while its context manager refused its work (heldForRecovery), then
+     * those a surgery's hold keeps that name it, in arrival order, so that
+     * neither a later move nor the hold's release meets them. Writes that
+     * name no agent stay: they are the delivery agent's at the release.
+     */
+    private takeHeldWritesFor;
     private reportLongHold;
     private disposeEmptiedForks;
     private reportReinitFailures;
     private reportReinitFailure;
-    private beginSyncMove;
-    private reinitializeAfterSyncMove;
     /**
      * A surgery's marker batch, recorded before its body change. If it can't
      * be recorded, the surgery doesn't start, and the error says what the
@@ -3126,14 +3656,21 @@ export declare class AgentFramework {
     private retireAfterRestore;
     /**
      * After a failed switch or redaction: put the store back on `sourceBranch`
-     * if it moved, and return a sentence saying what actually happened. Never
-     * throws — the caller reports the original failure with this appended.
+     * if it moved, and return a sentence saying what actually happened. The
+     * caller's release has every other live agent's context follow the store
+     * to where it ends (followBranchMove): its source, or the failed branch
+     * when the restore failed too. Never throws — the caller reports the
+     * original failure with this appended.
      */
     private restoreSourceBranch;
     /**
      * Roll the active branch back so `messageId` becomes its tail: fork the
      * chronicle at that message (origin-sequence time-travel branch) and switch
-     * to the fork. Everything after the message stays on the source branch.
+     * to the fork. Everything after the message stays on the source branch
+     * (on a presented window, but for the rows stored before the write that
+     * presented it: those the window took after that write,
+     * returnedToArrivals, and those it presented with the message,
+     * keptInWindowAfterTarget).
      *
      * The rollback is local to the resident. Marking removed Discord messages
      * with an awareness reaction is a separate, explicit publication choice
@@ -3178,6 +3715,38 @@ export declare class AgentFramework {
             role?: string;
             preview?: string;
         } | null;
+        /**
+         * On a presented window (#291), the rows after the target in the
+         * agent's window that the cut kept in the record: stored before the
+         * write that presented the target, they left the window as arrived and
+         * not presented. They wait outside it until the agent's next turn
+         * start, which presents them after what its window holds then: the
+         * surgery's release, a resume, the agent's turn ending or a row
+         * stored for it while it is idle don't bring them back, so the cut
+         * holds until the agent speaks again, on the rollback's branch: a later
+         * move of the store's branch, a suppression or rollback through another
+         * agent included, ends it. An own row of the agent's among
+         * them is the exception: it re-enters at the surgery's release, as own
+         * rows enter at every point. The hold is in memory: a restart before
+         * then presents them at its pass over every agent at rest, or, where it
+         * boots quiesced, at the resume. Not counted
+         * in `messagesRemoved`, and not marked. Set only on a presented window.
+         */
+        returnedToArrivals?: number;
+        /**
+         * On a presented window (#291), the rows after the target in the
+         * agent's window that one write presented together with the target (a
+         * batch: two Discord messages that arrived while the agent was busy,
+         * say, presented at its turn's end). The cut is at that write, so they
+         * stay in the window after the target: a branch cut can't separate
+         * them from it. Not removed, so not counted in `messagesRemoved` and
+         * not marked; suppressMessages, or, for those with a Discord message
+         * id, the host's hide by it, takes them out: a suppression through the
+         * agent whose own slot holds each, this one, or for a row of a slot it observes (a
+         * persistent subconscious's residents' rows), that slot's owner. Set
+         * only on a presented window.
+         */
+        keptInWindowAfterTarget?: number;
     }>;
     /**
      * Suppress specific messages from the live context without touching the
@@ -3192,9 +3761,16 @@ export declare class AgentFramework {
      * a marker-scheduling receipt (`markers`); delivery continues without the
      * caller waiting on it.
      *
-     * Not retroactive over derived state: a message already folded into an
-     * autobiographical summary stays in that summary — roll back to before it
-     * entered if that matters.
+     * On a presented window (#291) the removal reaches what every reader on
+     * the store folded: every other agent's context follows the fork before
+     * the removals (followBranchMove), so each one's strategy hears the rows
+     * leave, drops each summary that folded one and folds the rows it keeps
+     * again. Where a window can't be repaired, which is logged, its strategy
+     * hears at the next boot (presentation's retractAbsentRows), since the
+     * record no longer holds the rows. In legacy mode it is not retroactive
+     * over derived state: a message already folded into an autobiographical
+     * summary stays in that summary — roll back to before it entered if that
+     * matters.
      */
     suppressMessages(agentName: string, opts: {
         messageIds: string[];
@@ -3228,8 +3804,76 @@ export declare class AgentFramework {
      * changing anything. Never bisects a body group: chronicle refuses that
      * for removals and branchAt has no such guard, so the target snaps to the
      * group's last shard.
+     *
+     * The rows removed are those the branch cut leaves behind: the slot's
+     * rows after the target stored after the sequence branchAt cuts at
+     * (branchSequenceOf). That is every row after the target, but on a
+     * presented window (#291), where the cut is the write that presented the
+     * target, rows stored after the target and before that write stay in the
+     * record. Those of them the agent's window holds were presented after
+     * the target: they leave the window (`returnedToArrivals`, named by
+     * `returnedIds`); the agent's own rows among them enter it again at its
+     * next presentation point (the surgery's release), and the rest, as
+     * arrived and not presented, at the agent's next turn start on the
+     * rollback's branch (a later move of the store's branch, a suppression or
+     * rollback through another agent included, ends the hold; it is in
+     * memory: a restart presents them at its pass at rest, or, where it boots
+     * quiesced, at the resume). The rows of
+     * the agent's window after the
+     * target that the write presenting it presented too (`keptInWindow`, a
+     * batch: one write, one presentation point) stay in the window, since no
+     * branch cut separates them from the target. Both are set only on a
+     * presented window. A rollback that neither removes a row nor returns
+     * one is refused as a no-op, saying why: rows presented with the target
+     * are named, with the removals that can take them out, and through which
+     * agent a suppression does (suppressionThrough).
      */
     private planRollback;
+    /**
+     * Through which agent a suppression takes `rows` of `agentName`'s window
+     * out, for a refusal's advice, each row named by its id, which
+     * suppressMessages takes: a suppression looks for its ids in the agent's
+     * own slot (planSuppression), so a row of a slot the agent observes,
+     * merged into its window, is suppressed through an owner of that slot
+     * whose own slot holds it (observedRowOwner). Plain `suppressMessages`
+     * with the ids when every row is in the agent's own slot. Where an
+     * owner's slot holds no row but those named for it, the advice says the
+     * suppression there is refused, as planSuppression refuses one that
+     * would leave no row.
+     */
+    private suppressionThrough;
+    /**
+     * On which agent the host's hide takes each of `rows` out, for a
+     * refusal's advice, each row named by its Discord message id, which the
+     * hide matches: the hide reads the own slot of the agent it is run on, so
+     * a row of a slot `agentName` observes, merged into its window, is hidden
+     * on an owner of that slot whose own slot holds it (observedRowOwner), as
+     * suppressionThrough names one for a suppression. Grouped by agent, the
+     * groups set apart by semicolons.
+     */
+    private hideThrough;
+    /**
+     * The live agent whose own slot holds `id`, a row of a slot `agentName`
+     * observes: an owner of one of the slots its observe edges read
+     * (readerFacts' observed slots), other than itself. Undefined when none
+     * is found or the registry can't be read.
+     */
+    private observedRowOwner;
+    /** Whether a slot `cm` merges beside its own holds the row, which its own slot doesn't. */
+    private mergesObservedRow;
+    /**
+     * What a branch cut at `cut` does to the rows of `cm`'s window after the
+     * target (`tailId`), in window order: those it keeps in the record and
+     * out of the window (`returned`: stored at or before the cut, and
+     * presented by a write after it), and those it keeps in the window
+     * (`kept`: presented by the write the cut is at, the one that presented
+     * the target, so after the target only when that write presented them
+     * together, a batch). Read from the window's newest row back, to the
+     * target or the first row presented before the cut: every row's cut
+     * (branchSequenceOf, the write that presented it, or its own sequence
+     * for a row the write-down presented) grows in window order.
+     */
+    private windowAfterCut;
     /**
      * The removal intervals a suppression of `requestedIds` would apply
      * (index-ordered, newest first), validated, without changing anything. A
@@ -3249,6 +3893,18 @@ export declare class AgentFramework {
     } | {
         suppress: string[];
     }): SurgeryMarksPreview;
+    /**
+     * The live agents whose window holds a row now (#291): each whose context
+     * reads it `'in'` (windowStatusOf), every agent whose window is still the
+     * record and whose record holds it among them (`names`). A row an agent's
+     * view leaves out (agentSees) is held by no such agent, though its window
+     * holds it: one a tune-out holds from residents, or another agent's stored
+     * context injection, which a write-down from the record took in. A row a
+     * suppress rule hid is held by no agent: no view shows it. An agent
+     * whose lookup throws is in `unreadable`, with the error: whether its
+     * window holds the row isn't known.
+     */
+    private holderNames;
     /** The awareness ledger's batches and retract requests, for operator surfaces. */
     listDiscordAwareness(): DiscordAwarenessView[];
     /**
@@ -3315,7 +3971,9 @@ export declare class AgentFramework {
      * reservation. The gate picks it up by mtime; stop() still waits for it. */
     private materializeConfigMountAfterBranchSwitch;
     /**
-     * Check if undo/redo is available for an agent.
+     * Check if undo/redo is available for an agent. `canRedo` is false where
+     * the newest undo was on another branch than the store's, which redo
+     * refuses; `redoDepth` counts every undo kept all the same.
      */
     getUndoRedoState(agentName: string): {
         canUndo: boolean;
@@ -3365,6 +4023,12 @@ export declare class AgentFramework {
      * Useful for testing.
      */
     runUntilIdle(): Promise<void>;
+    /**
+     * A configured agent (a resident). `configured` is every configured
+     * agent's name: an agent its `observes` names may be registered after it,
+     * in this same pass, so its edge on that agent is admitted before then
+     * (AgentRegistry.register's `declaredWith`).
+     */
     private createAgent;
     /**
      * Create and register the subconscious resident (issue #77): a persistent
@@ -3374,6 +4038,14 @@ export declare class AgentFramework {
      * excludes; the backlog is precisely what it exists to see. Windowed
      * passthrough, no memory pyramid: its durable output is what it delivers
      * into the resident's window, which accumulates there.
+     *
+     * With the presentation index (#291) the merge is the record its window is
+     * presented from, not its compile: the residents' rows enter its window by
+     * its observe edge's rule (observedRowFor) at its own points, as any
+     * agent's arrivals do, so none lands inside its live turn; its window
+     * starts at the oldest active tune-out's start, fixed as an ordinal
+     * (SubconsciousWindowAnchor); and a resident's rounds go out to it as a
+     * transcript (foreign-rounds.ts).
      */
     private createSubconsciousAgent;
     /**
@@ -3382,6 +4054,36 @@ export declare class AgentFramework {
      * kept for the voice block, the speech switch and the strategy factory.
      */
     private configureReaderForks;
+    /**
+     * How many of the residents' stored rows `keep` keeps the persistent
+     * subconscious hasn't been shown (the coordinator's unseenBySubconscious),
+     * one per body: with the presentation index, those its window doesn't
+     * hold, which it takes at its next point; else those its consumed mark
+     * doesn't cover, stored after its last compile. 0 with no subconscious,
+     * and for a row its mark can't speak for.
+     */
+    private unseenBySubconscious;
+    /**
+     * The persistent subconscious's window as written down, its presented
+     * rows (the coordinator's subconsciousWindow): what a boot reads for the
+     * losses told to it, its own cancels, and what it was told of an
+     * unrecorded stop, where the turn a row asked for, in memory, doesn't
+     * outlast a stop, and its read marks, in memory too, don't either. Its
+     * stored rows where its window isn't presented. None with no
+     * subconscious.
+     */
+    private subconsciousWindow;
+    /**
+     * The persistent subconscious's tool results as its tool-result guard
+     * archived them (the coordinator's subconsciousGuardedResults): each
+     * `staged` record of its audit (TOOL_RESULT_GUARD_AUDIT_STATE, under the
+     * subconscious's name) holds its batch's original content, inline or as a
+     * blob, written and synced before the placeholder row's results went out,
+     * by tool use id, the placeholders' own. A crash before the guard settles
+     * the batch leaves the placeholder for the result in its record; the
+     * original is here. None with no subconscious, or no audit.
+     */
+    private subconsciousGuardedResults;
     /**
      * One reader invocation: derive a fork of the resident at its head with
      * the resident's refusals, hand it the held traffic since the last look
@@ -3390,13 +4092,11 @@ export declare class AgentFramework {
      */
     private invokeReaderFork;
     /**
-     * Held messages still queued behind the resident's turn, as rows of a
-     * reader fork's backlog: each named by its held handle, as module rows name
-     * it until it lands (heldRows), at a provisional sequence past the
-     * resident's last stored message, and timed when it was first held.
+     * A reader fork's own words to the resident: attributed mail when it has a
+     * route, else under its name. Answers the row's id for the latter (empty
+     * where the write was kept in memory), and nothing for mail, which the
+     * registry keeps until it is delivered.
      */
-    private queuedReaderRows;
-    /** A reader fork's own words to the resident: attributed mail when it has a route, else under its name. */
     private deliverFromReader;
     private runLoop;
     private processNextEvent;
@@ -3410,6 +4110,34 @@ export declare class AgentFramework {
      */
     private dispatchProcessEventToModules;
     private applyProcessResponse;
+    /**
+     * Who a module's process response's messages are for when its inference
+     * request names agents (#291's audience stamp): those of them registered
+     * here that read the slot the messages land in (readersNamed), once each,
+     * in the order named, whether or not the event gate then lets their wake
+     * through; the delivery agent when it names none registered. The messages
+     * are stored where a write that names no agent is, the delivery agent's
+     * store, whoever these are: on a residents' host the shared slot every
+     * resident reads. Undefined for a request for every agent (`true`), for
+     * none, for an empty list, or for one whose registered agents don't read
+     * that slot (an isolated job, a conversation fork), which leave the stamp
+     * to addMessage (untargetedAudience): stamped for those agents alone, the
+     * messages would be in no window.
+     */
+    private requestedAudience;
+    /**
+     * Of the agents a write that names no agent (no `forAgent`) is said to be
+     * for (`named`, non-empty), those that read the slot it lands in, the
+     * delivery agent's own: its owners and the agents that observe it (the
+     * registry's readersOf), in the order named. Undefined when none of them
+     * reads it, so the write takes addMessage's stamp for a write that names
+     * no agent in that slot (defaultAudience): a stamp naming only agents
+     * that can't read the slot puts the row in no window. Where the registry
+     * places no slot for the delivery agent, `named` as given.
+     */
+    private readersNamed;
+    /** Each event's suppression, decided once: by its MCPL lane at admission, or by the first module response that adds messages or asks for a wake (applyProcessResponse). */
+    private readonly eventSuppression;
     /** The servers and keys whose drop withoutHostKeys has logged, each as
      *  `${serverId}\u0000${key}`. */
     private readonly hostKeysDropped;
@@ -3439,6 +4167,21 @@ export declare class AgentFramework {
      * the template ("trunk") is a dormant warm checkpoint, not a listener.
      */
     private routeConversationIncoming;
+    /**
+     * A fork's channel message, routed or a correction for it, written into
+     * the fork's store (storeInFork, #291: stored at once, stamped for the fork
+     * alone, and presented at the fork's next point, at once when no turn of
+     * its is alive), and where it went: the fork, with the stored id, and
+     * `presented: false` where the row is out of the fork's window after its
+     * write, as addMessage's placement says (placedUnpresented). While a
+     * surgery holds the store, storeInFork keeps the write in memory
+     * (surgeryHeldWrites) and the hold's release stores it, and while the
+     * fork's context manager refuses its work it keeps it for the move that
+     * re-initializes it (heldForRecovery), so the placement names the fork
+     * alone, with no id yet, as not presented: no request reads it before it
+     * is stored, and the fork is woken to read it, as addMessage places a
+     * write it keeps. `mayBeStored`: storeInFork's.
+     */
     private writeToFork;
     /**
      * Spawn a persistent per-channel conversation agent ("fork") from the
@@ -3624,6 +4367,14 @@ export declare class AgentFramework {
      * editMessage keeps metadata but not this hash.
      */
     private static withStoredDigest;
+    /**
+     * Who an admitted inbound message is for (#291's audience stamp): the
+     * recipients admission delivered it to, in their view, and nobody when a
+     * tune-out holds it, since then nothing may act for them (admit.ts), or
+     * when a suppress rule took it, since then no view renders it. The
+     * stored row lands in one store, the delivery agent's, whoever these are.
+     */
+    private static inboundAudience;
     /** Source envelope of a channels/incoming event (lane facts as given). */
     private channelEventSource;
     /** Source envelope of a push event: its derived channel, else unscoped. */
@@ -3669,38 +4420,68 @@ export declare class AgentFramework {
     private assertChannelScopedPush;
     private coalescedAuthorized;
     private coalescedAudience;
-    /** Deliver through the lane's ordinary path; report where it landed. */
+    /** Deliver through the lane's ordinary path; report where it landed.
+     *  `options.mayBeStored` rides the event to its store, which looks for the
+     *  occurrence's rows first (FrameworkWriteOptions.mayBeStored). */
     private deliverCoalesced;
+    private dispatchAfterDelivery;
     private wakeForCoalescedBatch;
     /** Queue a wake for each agent of the batch's audience, when its latest
      *  occurrence triggers inference. `plain`: an ordinary push wake, without
      *  the subject a withdrawal of the batch's wakes goes by, for a render
-     *  placed in its agent's deferred queue (wakeToRead), at `readsDeferredWrite`,
-     *  marked ambient when every notice the render folds was (`allAmbient`). */
+     *  its turn being assembled doesn't read (wakeToRead), reading `readsRow`
+     *  (readsRowFor), marked ambient when every notice the render folds was
+     *  (`allAmbient`). */
     private queueCoalescedWakes;
     /** Withdraw unstarted wakes whose sole cause is this subject (§4.2), and
      *  a merged start whose every request is withdrawn. */
     private cancelCoalescedWakes;
-    /**
-     * A placement in the deferred queue is upgraded in place once the flush has
-     * stored it: the stored copy carries `metadata.deferredWriteId`, found by
-     * scanning the unread tail (above the watermark) — never below it.
-     */
-    private resolvePlacement;
     /** Unread (the coalescer's isUnread) by the consumed watermark, or, by the
-     *  shown watermark, never possibly shown (its isUnshown). A placement still
-     *  in the deferred queue is both, once settled (settleUnknownLandings): one
-     *  whose write may already be stored, its store unsearchable, is a doubt,
-     *  which counts as read and as shown. */
+     *  shown watermark, never possibly shown (its isUnshown). A placement with
+     *  no stored row, a write kept in memory (a surgery's hold, or the wait
+     *  for its agent's recovery), counts as read and as shown: it can't be
+     *  found again once it is stored. */
     private isUnreadPlacement;
     /**
-     * Unread = stored, above the agent's consumed watermark on the current
-     * branch, not a body-group shard (immutable), and not folded into any
-     * summary (compression is consumption, §3.3). Conservative on every doubt.
-     * By the shown watermark (Agent.getShownWatermark), the same test says the
-     * message may never have been shown.
+     * Unread = stored, not covered by the consumed watermark of any agent that
+     * reads it (Agent.getConsumedWatermark, read in that agent's own context:
+     * in its window as of the mark once the context presents rows, else at or
+     * below the mark on the branch), not a body-group shard (immutable), and
+     * not folded into any reader's summary (compression is consumption,
+     * §3.3). Conservative on every doubt: a reader whose mark can't say (none,
+     * or one on another branch) counts it read. By the shown watermark
+     * (Agent.getShownWatermark), the same test says the message may never
+     * have been shown.
      */
     private isUnreadStoredMessage;
+    /**
+     * The live agents whose presented window holds a row (the presentation
+     * index's holders, #291, leaving out a window that is still the whole
+     * record): each one's own place for it, or a reader fork's framing.
+     * None on a framework built without the index. Undefined when it can't be
+     * read, which is logged: one window that can't be read fails the lookup
+     * for every window, so which hold the row isn't known.
+     */
+    private windowHolders;
+    /** Whether a reader fork was handed a row as framing (the presentation
+     *  index's noteFramed, #291, AF-5): its framing row carries the row's
+     *  text, so the row is read whatever its marks say. False on a framework
+     *  built without the index. */
+    private framedToAReader;
+    /**
+     * Rows just removed from the record through `remover`, taken out of every
+     * other live agent's window that still holds them (the presentation
+     * index's retractRemoved, #291): context-manager tombstones a removal in
+     * the remover's window only. Each row leaves at its own place, so no
+     * other row's place moves; a window on a branch whose record still holds
+     * the row, and one that is still the record, keep it. A window that can't
+     * be repaired is logged and the removal stands. Called after every
+     * removal in place: a hide, a suppression on its fork, a coalescer's or a
+     * module's removal, a suppression a start finishes, and a shed from a
+     * window that is still the record. A rollback needs none: it is a branch
+     * cut, made at the same place in every window.
+     */
+    private retractRemovedElsewhere;
     private removePlacement;
     /**
      * Convert an MCPL push event to a context message.
@@ -3708,9 +4489,9 @@ export declare class AgentFramework {
     private handleMcplPushEvent;
     /**
      * Whether a batched gate wake's addressed route may become `agentName`'s
-     * speech locus. The gate broadcasts to every agent, conversation forks
-     * included. A fork speaks only in its home channel, and a channel bound to
-     * a fork is that fork's conversation, so no other agent takes it.
+     * speech locus. A batch naming no agent wakes every resident and
+     * conversation fork. A fork speaks only in its home channel, and a channel
+     * bound to a fork is that fork's conversation, so no other agent takes it.
      */
     private mayTakeGateRoute;
     /**
@@ -3744,8 +4525,8 @@ export declare class AgentFramework {
      */
     private channelOfHome;
     /**
-     * Explicit mode's typing channel for one start of a turn, which has no
-     * locus, read once as the start opens (driveStream then shows what the
+     * The typing channel for one start of a turn that has no locus, an
+     * explicit or a disabled mode turn's, read once as the start opens (driveStream then shows what the
      * start showed, TurnRouting.typing): where that start's wake came from,
      * its trigger's channel with its server (channelNamed), so a start batched
      * with a new wake shows typing where that wake came from. Not the turn's
@@ -3759,9 +4540,11 @@ export declare class AgentFramework {
      * (TurnRouting.noChannel), a wake named without its server isn't read: a
      * retry's trigger names it again, and reading it then could take a
      * channel the turn never had. A wake that gives its server, as every one
-     * the framework makes for a channel does, names that pair.
+     * the framework makes for a channel does, names that pair. A silent wake's
+     * start (InferenceRequest.suppressProse), which runs as disabled mode in
+     * every mode, shows none, though its wake names a channel.
      */
-    private explicitTypingChannel;
+    private noLocusTypingChannel;
     /**
      * Derive the MCPL composite channel id (the outbound routing locus) for a
      * push event from its server-defined `origin`, if it carries one.
@@ -3804,8 +4587,8 @@ export declare class AgentFramework {
      * Stamps for the rows the agent's reply stores in its current turn: its
      * assistant responses, its tool_result rows (through `storeResults`), and
      * the contained-wrapper row that stands in for a response. The turn's other
-     * stores (a delivery receipt, a routing notice, a deferred flush) aren't the
-     * reply's, and carry none.
+     * stores (a delivery receipt, a routing notice) aren't the reply's, and
+     * carry none.
      * - A silent heartbeat tick stamps each of them for the whole turn, with the
      *   separator text its request rendered. The stamps keep every row of the
      *   tick identifiable after the turn, for a later retention policy to find
@@ -3848,8 +4631,11 @@ export declare class AgentFramework {
      * turn whose round it came from (opts.routing). `notice: 'now'` also
      * queues a private notice naming them, which
      * the resident hears at its next tool boundary — only when the live stream
-     * presents mid-turn injections. Otherwise the turn-end receipt names them
-     * (or, after a crash, the next turn's catch-up). Drafts the journal cannot
+     * presents mid-turn injections. The notice is the agent's own row, about
+     * its own speech (#291), so an undo of the turn takes it out of the window
+     * with the turn's other rows, as it takes the receipt, and the next start
+     * names the draft again (noticeUnnoticedDrafts). Otherwise the turn-end
+     * receipt names them (or, after a crash, the next turn's catch-up). Drafts the journal cannot
      * hold are reported in the receipt: their words remain in history only.
      */
     private holdProseDrafts;
@@ -3880,17 +4666,18 @@ export declare class AgentFramework {
      * Turn start (or after a crash): name, privately and before the turn's
      * compile, any open drafts no notice on the current branch names: none
      * reached the history (a crash, an aborted turn), or a rollback or branch
-     * move took the notices away. Every draft it marks is named by id, newest
-     * first: the newest eight with their state and why each was held, the rest
-     * by id. Like every notice, it quotes none of their words; the drafts tool
-     * shows them. A draft a recent message already names is recorded as
-     * noticed rather than named again: its notice landed after its turn ended,
-     * as a bounce does when a delivery runs after a tool ends an explicit turn.
-     * It reads only the recent history (draftsNamedInHistory), so its notice
-     * claims no more than that. Left out are the open logical turn's own
-     * drafts, which its receipt names and its settlement records
-     * (settleTurnDrafts), and drafts a notice still waiting in the deferred
-     * queue names.
+     * move took the notices away, or, once the agent's context presents rows
+     * (#291), an undo took them out of its window as an undone turn's. Every
+     * draft it marks is named by id, newest first: the newest eight with their
+     * state and why each was held, the rest by id. Like every notice, it quotes
+     * none of their words; the drafts tool shows them. A draft a recent message
+     * already names is recorded as noticed rather than named again: its notice
+     * landed after its turn ended, as a bounce does when a delivery runs after
+     * a tool ends an explicit turn. It reads only the recent history
+     * (draftsNamedInHistory), so its notice claims no more than that, a notice
+     * stored and not yet presented to the agent among it, which its next start
+     * presents. Left out are the open logical turn's own drafts, which its
+     * receipt names and its settlement records (settleTurnDrafts).
      */
     private noticeUnnoticedDrafts;
     /**
@@ -3904,7 +4691,8 @@ export declare class AgentFramework {
      */
     private noticeHeadMoves;
     /**
-     * Logical turn end, after the turn's deferred notices are flushed: record
+     * Logical turn end, the turn's notices stored (each at its write since
+     * #291, with no queue to flush first): record
      * as noticed exactly the drafts a stored message names (the receipt, a
      * held-draft notice, a bounce notice), each with the message that names
      * it. One whose notice never reached the history stays unnoticed, for the
@@ -3920,8 +4708,13 @@ export declare class AgentFramework {
     /** Which of these drafts a stored notice or receipt OF THIS RESIDENT names
      *  (draft ids are unique only per resident, and residents can share one
      *  history), each with the newest message that names it, reading only the
-     *  recent history, where this turn's notices are. */
+     *  recent history of the slot's record, where this turn's notices are. A
+     *  notice stored and not presented to the agent yet counts: its next start
+     *  presents it. Once the agent's context presents rows (#291), one taken
+     *  out of its window as an undone turn's (windowStatusOf 'undone') doesn't:
+     *  the record still holds it, and the agent's window doesn't. */
     private draftsNamedInHistory;
+    private static undoneInWindow;
     /** Page size for drafts(action: "list"). */
     private static readonly DRAFTS_PAGE;
     /** Drafts with a delivery attempt in flight, `${agent}\u0000${id}`: a
@@ -3959,6 +4752,13 @@ export declare class AgentFramework {
      * for them, and the agent may send them where it chooses.
      */
     private routeLocusSpeech;
+    /**
+     * Hold a locked turn's plain speech as drafts ('no-destination'): the agent
+     * pointed its speech at drafts, or has no lock yet. Named in the turn's
+     * receipt rather than a notice per round, since holding is what the agent
+     * asked for.
+     */
+    private holdLockedProse;
     /** The mark a framework wake takes from a heartbeat's turn with no locus
      *  of its own (InferenceRequest.heartbeatTurn), so the turn it opens is a
      *  heartbeat's too; nothing for any other turn. */
@@ -3981,6 +4781,14 @@ export declare class AgentFramework {
      * ([discord-send-failed]); this is the success half.
      */
     private appendProseDeliveryReceipt;
+    /**
+     * main's [speech-not-posted] notice, the agent's own row (#291:
+     * storeOwnRow, stamped and presented as it is stored), written by the frame
+     * whose turn ends here, or by a start before its compile, each holding the
+     * agent. A dropped start (endDroppedTurn) passes `present` false: its agent
+     * may have been replaced, and a turn of the new one's may be alive, so the
+     * row waits out of the window for the agent's next point.
+     */
     private nameUnpostedSpeech;
     private noteFailedTurnEnd;
     /**
@@ -3989,9 +4797,9 @@ export declare class AgentFramework {
      * destination itself. A `>>` into a channel the agent closed or declined
      * leaves it closed, so the note goes wherever the turn's speech stayed in
      * such a channel, once per channel. It goes through addMessage, as the
-     * open notices do: held while the agent has a turn alive and written at
-     * that turn's next boundary, so it reaches the agent once and never
-     * mid-turn. No-op otherwise.
+     * open notices do: stored at once, and presented at the agent's next
+     * presentation point while a turn of its is alive, so it reaches the
+     * agent once. No-op otherwise.
      */
     private appendClosedChannelNoteAlone;
     /**
@@ -4006,6 +4814,54 @@ export declare class AgentFramework {
     /** The stored baseline's entry for the agent set (rememberAnnouncedLocus),
      *  or removed (undefined) when the agent ends without coming back. */
     private writeAnnouncedLocus;
+    /**
+     * Whether the agent's current turn has no channel of its own, so it is
+     * answering no incoming message (ChannelRegistry.incomingFor): a
+     * heartbeat's, or one woken for a channel that names none, which no re-pin
+     * or channel_open has given a channel since. A locked turn's locus is where
+     * it speaks, not a message it answers, so it never counts as one.
+     */
+    private channellessTurn;
+    /**
+     * The prose routing an agent's turns run under: its configured mode, except
+     * for a locked agent's conversation fork and ephemeral run, which have no
+     * lock of their own. A fork is bound to its home channel, so it routes as
+     * locus mode does. A run's plain speech is its caller's result, and it
+     * publishes none: run as locus mode, its narration between tool calls would
+     * post to the channel inferred for its turn, which the lock exists to
+     * prevent, so it runs disabled, as a disabled resident's run does.
+     */
+    private proseRoutingOf;
+    /**
+     * A locked agent's own choice of destination (prose_locus), as
+     * framework/state keeps it: a channel, 'drafts', or undefined when it
+     * hasn't chosen. Throws when the state can't be read.
+     */
+    private readProseLock;
+    /** Record a locked agent's choice of destination. Throws when it isn't recorded. */
+    private writeProseLock;
+    /**
+     * Where a locked agent's plain speech goes now: its own choice
+     * (prose_locus), else its recipe's proseLock, resolved as a `>>` target
+     * is, else nowhere (null: held as drafts). A stored choice that can't be
+     * read holds the speech as drafts rather than fall back to the recipe's,
+     * which the agent may have moved it away from.
+     */
+    private proseLockLocus;
+    /** Where a locked turn's plain speech goes now: its locus, or nowhere (drafts) while a move holds the rest of the turn (heldForMove). */
+    private turnSpeaksAt;
+    /** " prose_locus moves it." where the agent may call prose_locus, else nothing: a notice names only a tool the agent has. */
+    private proseLocusMoves;
+    /** Where a locked agent's plain speech goes, as the agent is told it: a verb phrase after "your plain speech". */
+    private proseLockShown;
+    /**
+     * prose_locus: read or move a locked agent's prose lock. A move is
+     * recorded before it applies, so a failed write moves nothing. It applies
+     * to the calling turn's later rounds while that turn is open (what the
+     * calling round wrote was routed with the locus it had), and to every
+     * later turn.
+     */
+    private proseLocusToolResult;
     /**
      * Announce-on-change locus notice (turn-frozen routing). Appends a durable
      * `[routing]` window message when the turn's effective outbound locus
@@ -4033,8 +4889,221 @@ export declare class AgentFramework {
      * (addressedElsewhereNotice).
      */
     private repinChannel;
+    /**
+     * Whether `agent`'s logical turn is alive: a turn token, or a continuation
+     * of its turn or a retry on its way (hasTurn: a budget restart's queued
+     * continuation, a provider hold's retry), or a live stream or a tool cycle
+     * pending (turnAlive). The one test the presentation index (its host's
+     * turnAlive) and the writes that weigh a turn share: a write stored then
+     * is marked not presented (addMessage) and takes no clock row ahead of it,
+     * and no undo or redo is made.
+     */
+    private logicalTurnAlive;
     /** Whether `agent` has a turn alive: starting, streaming or waiting on its tools. */
     private turnAlive;
+    /**
+     * Whether the presentation index presents for `agent` (#291): the agent
+     * taken on, and its context in presented mode. Every registered agent is
+     * taken on, its window written down at its registration, and again on the
+     * new branch after every move of the store's branch where that branch has
+     * none (followBranchMove: a branch made before the write-down, a rollback
+     * into rows the write-down presented), so a branch move doesn't end it.
+     * One whose window couldn't be written down (another version's index
+     * format, or a failed write), or whose context couldn't follow a branch
+     * move, stays unpresented until the next move (legacy mode: its window
+     * the whole record where the branch has none, or as the new branch holds
+     * it, writes for it then waiting in memory), traced as
+     * presentation:failed; the paths that ask this pass it by: nothing is
+     * presented for it, its tool boundaries hear nothing, and undo refuses
+     * it.
+     */
+    private presents;
+    /**
+     * Record, at an agent's registration, the mode its requests send other
+     * agents' rounds in (foreignRoundsConfigured). An agent that takes its
+     * context from another (`from`: a derived agent's parent, a conversation
+     * fork's template) is sent them in the mode configured for that agent,
+     * the one its window uses when presented (a source left in legacy mode by
+     * a failed write-down is sent them as stored meanwhile; a child it
+     * derives, presented, isn't), its inheritance holding what that agent's
+     * window held of them, a shared derivation's as a window and a copy's or
+     * a fork's seed as its own rows. The source is live here: the registry
+     * admits a derived agent only while its context source is, but for a
+     * resumption, which takes its configuration's mode as below. Otherwise, an
+     * agent that observes another is sent them as its configuration's
+     * foreignRounds says, a transcript by default, as the persistent
+     * subconscious is (foreign-rounds.ts). Any other agent reads no other
+     * agent's rounds, and is left as stored.
+     */
+    private configureForeignRounds;
+    /**
+     * How another agent's rounds go out in `agent`'s requests
+     * (Agent.setForeignRounds), for an agent whose configuration names a mode
+     * (foreignRoundsConfigured): that mode while the presentation index
+     * presents its window, and as stored (`'raw'`) while its window is the
+     * record, as before the index. Set at its registration and again after
+     * each branch move's rebase (followBranchMove), which can present a
+     * window whose write-down failed at registration, or leave one in legacy
+     * mode. Nothing for any other agent, which reads no other agent's rounds.
+     */
+    private applyForeignRounds;
+    /**
+     * Take a newly registered agent on (presentation.adopt: its window
+     * written down, its own rows stored and not in it presented, its own-row
+     * sink installed), and weigh each row of another writer that enters its
+     * window at a start, at an end or at rest as its open turn's arrival
+     * (noteArrival), as the flushes these points replace weighed what they
+     * stored. A tool boundary weighs what it hears itself.
+     */
+    private adoptPresentation;
+    /**
+     * For the workspace's head-move notice (useWindow): whether `agentName`'s
+     * window still holds the first of its own rows stored after
+     * `afterSequence`, the store's head when it wrote a mount direct during a
+     * turn of its, which is the round that made the write (one made outside
+     * any turn isn't asked here). An undo on the window leaves the record
+     * and the branch as they were and takes the turn's own rows out of the
+     * window as undone, so this is where the agent's history no longer holds
+     * the write. True for an agent the index doesn't present for, and where
+     * no own row of its came after. A row is its own by the rule an undo
+     * takes it out by (ownWindowRow), so a turn an earlier release stored,
+     * with no stamp, counts by its voice. Reads the record back from its
+     * newest row, 64 at a time, to that place, then weighs the rows after it
+     * in store order.
+     */
+    private windowHoldsOwnRowsAfter;
+    /** Let a deregistered agent go from the presentation index (forget), its arrival listener with it. */
+    private forgetPresentation;
+    /**
+     * An agent's turn's end, or a moment its turn may have ended: what it is
+     * owed is presented (presentation.presentAtEnd),
+     * unless its logical turn is still alive (a token, a continuation or
+     * retry on its way, a stream, a tool cycle), whose own points present
+     * it. Idempotent; nothing for an agent the index doesn't present for.
+     */
+    private presentAtEndOf;
+    /**
+     * Whether a write stored for `agent` now waits outside its window for a
+     * later point (#291), read before the write: while the host is quiesced,
+     * or while a logical turn of the agent's is alive (`turnLive`,
+     * logicalTurnAlive), but for a fresh tool_result (a draining turn's
+     * continuation depends on it) and a write while the agent's start is
+     * assembling, which that start presents before its compile.
+     */
+    private keptOutOfWindow;
+    /**
+     * Whether a write stored for `agent` as `id` is placed as not presented
+     * to it (`presented: false`), which a coalesced render's delivery reads
+     * to keep the render replaceable and wake its agent to read it: kept out
+     * of the agent's window by its turn or a quiesced host (`keptOut`,
+     * keptOutOfWindow), or stored while no logical turn of the agent's was
+     * alive (`atRest`) and out of its window after its presentation at rest,
+     * which failed (presentation.notPresented). Only for an agent the index
+     * presents for.
+     */
+    private placedUnpresented;
+    /**
+     * A channel message stored straight into a fork's own store, past
+     * addMessage, as the fork writes are (a correction
+     * handleMcplChannelIncoming delivers, a message routeConversationIncoming
+     * routes), stamped for the fork alone. While a surgery holds the store it
+     * is held in memory instead (surgeryHeldWrites) and '' returned, and so
+     * is it while a hold's release replays what the hold kept, but for the
+     * write the replay stores (`replayed`, called as soon as its store
+     * returns, as addMessage calls it), and while the fork's context
+     * manager refuses its work after a failed re-initialization
+     * (heldForRecovery, as addMessage keeps a write);
+     * stored, it enters the fork's window at once when no turn of the fork's
+     * is alive, else at the fork's next point (afterStore). One whose store
+     * threw after its row landed is stored as that row, and one whose store
+     * can't tell what of it landed throws that error, the rows it names
+     * presented (landedThoughThrown), as addMessage's. `mayBeStored`: as
+     * FrameworkWriteOptions.mayBeStored, read back in the fork's store.
+     */
+    private storeInFork;
+    /**
+     * The writes a surgery's hold kept (surgeryHeldWrites), replayed in the
+     * order they arrived once the hold and its tokens are released, each by
+     * the path it was held on: addMessage's, or a fork's store. Ahead of them
+     * are the writes kept for an agent whose context manager the move
+     * re-initialized after it refused its work (recoverHeldWrites). Each is
+     * traced once, as it is stored (`message:added`, source
+     * `surgery-release`, with its stored id): its arrival named none, and
+     * wasn't traced. The trace is emitted synchronously, right after that
+     * write's store and before the next write is stored, inside this call,
+     * which no await interrupts: a listener that edits or removes the row
+     * does so before any turn compiles a request with it in, though the row
+     * may be in an idle reader's window by then (each reader takes it as it
+     * is stored). The Discord module relies on that to apply the edits and
+     * deletes it kept for a message whose create the hold kept, which no
+     * module can reach before it lands (ModuleContext.addMessage). Keep it so,
+     * or give such a module a callback the release calls in its place. The
+     * writes are taken off the queue one at a time, each once it is stored or
+     * lost, and while they replay (replayingHeld) the ones still waiting, the
+     * one being stored included, stay listed (the tune-out's
+     * getSurgeryHeldMessages, HostModeStatus.deferredWrites), a write such a
+     * listener makes is kept behind them, and the tune-out's writesHeld reads
+     * true, so a cancel a listener asks for waits for the replay's end, as it
+     * does during the hold. A hold a listener begins meanwhile stops the
+     * replay, and its own release stores the rest, in order: one begun by a
+     * listener of the write being stored (its clock row's trace) leaves that
+     * write unstored at their head. A
+     * write for an agent whose context manager refuses its
+     * work is kept in memory for it again (heldForRecovery), never dropped,
+     * and is traced when a later move stores it. An agent that ends during
+     * the hold takes its writes out of it as it ends, and passes them on
+     * (releaseWindowNowOrAfterResume). One the release still meets for an
+     * agent gone, or for a name another agent is registered under since
+     * (heldWriteTargetGone), goes on to the primary if it is one the primary
+     * takes in its place, and is dropped otherwise (passHeldWritesOn), told of
+     * by an ops alert. A write whose store threw after its rows landed
+     * (context-manager's WriteLandedError) is stored as those rows by
+     * addMessage and storeInFork, presented and traced as any write stored
+     * here. One whose store threw where context-manager can't tell what of it
+     * landed (WriteOutcomeUnknownError) may be lost: the rows the error names
+     * as stored are presented (by addMessage and storeInFork) and traced, the
+     * first by its id, and the write is counted as one that may be lost, the
+     * rows the store may hold besides named. Any other throw stored none of
+     * the write: it is logged and lost. The rest go on either way. Each
+     * agent's lost writes, and those that may be, are told of once, by a log
+     * line and an ops alert of kind `store-held-lost`. Each is also given to
+     * the tune-out coordinator, by its metadata (heldWriteLost), before the
+     * deferred cancels run: a reader's note kept with a waiting cancel is
+     * told lost to the reader when that cancel ends the hold, as the cancel's
+     * waiting answer promised. So is each write stored (heldWriteStored),
+     * before its trace: such a note counts as delivered then, and a stop
+     * while its cancel still waits doesn't tell it lost.
+     */
+    private releaseSurgeryHeldWrites;
+    /**
+     * One write of releaseSurgeryHeldWrites's replay, the head of `queue`,
+     * stored by the path it was held on; one that fails is noted in `lost`,
+     * by agent, and given to the tune-out coordinator (heldWriteLost), which
+     * knows its own writes by their metadata; one stored is given to it too
+     * (heldWriteStored). It is taken off the queue once
+     * it is stored, kept for its agent's recovery, passed on or lost, before
+     * its trace; false where a
+     * hold begun during its store (a listener of its clock row's trace)
+     * keeps it at the head, unstored.
+     */
+    private replayHeldWrite;
+    /**
+     * Whether a round's turn was stopped while its results were built (a
+     * spill's workspace write), which a tool boundary and a stream that
+     * completed while its tools ran both await before they store anything:
+     * the stop's name, or null when the round goes on. `before` is the state
+     * the build began from and `stream` the round's stream.
+     *
+     * A host's cancelStream, stop() and abortInference, and an ephemeral run's
+     * disposal, replace that state (the agent is left idle): `'state-changed'`.
+     * A quiesce's abandon and stop() record their cancel of the stream and
+     * leave the state to driveStream: the record's name, once the stream is no
+     * longer waiting for these results. The stream's state is what makes the
+     * record this stream's: one left under the same key by an earlier stream,
+     * such as an earlier agent's of the same name, sits beside a stream still
+     * waiting.
+     */
+    private roundStoppedDuringBuild;
     /**
      * Store the clock row due in `agent`'s window (clock-rows.ts), if the agent
      * has clock rows and a boundary has passed since the window's last clock,
@@ -4047,10 +5116,11 @@ export declare class AgentFramework {
      * the request that follows or before every request still to come, so the
      * window and the live stream keep matching.
      *
-     * None while the host is quiesced (the window is frozen for surgery), and
-     * none in the residents' shared slot while another of its readers (the
-     * subconscious among them, through its merged view) has a turn alive: the
-     * row would sit inside that turn without joining its stream. A clock that
+     * None while the host is quiesced (the window is frozen for surgery). In
+     * the residents' shared slot another reader's turn doesn't matter (#291):
+     * the row is the agent's own, in no other resident's window unless that
+     * resident observes the agent (AgentConfig.observes), which takes it at
+     * its own points. A clock that
      * can't be planned or stored is logged and skipped: it never holds up what
      * it would have preceded. One whose write threw after it landed is the
      * window's all the same, so it's returned, and a tool boundary injects it.
@@ -4063,10 +5133,9 @@ export declare class AgentFramework {
      * that couldn't be stored (stored-injections.ts, #155 part 5). Which are
      * stored, and which skipped, is planInjectionStores'.
      *
-     * Nothing is stored while the window is held (slotHeldFrom: the host is
-     * quiesced, or another reader of the residents' shared slot has a turn
-     * alive, as for a clock row): `compile()` places what the plan would have
-     * stored, and what it skips, being in view already, isn't placed again.
+     * Nothing is stored while the host is quiesced, as for a clock row:
+     * `compile()` places what the plan would have stored, and what it skips,
+     * being in view already, isn't placed again.
      * Rows are written in the order gathered. A row whose write throws is
      * placed by `compile()` instead, with every row after it, unless the
      * read-back shows it landed; where the read-back fails, a row whose write
@@ -4089,9 +5158,10 @@ export declare class AgentFramework {
      * since costs one request, as below. A part the strategy cut at its
      * per-message cap, or stripped an image from, counts as held, since a new
      * copy would meet the same. One a fold has summarized, a strategy's window
-     * has scrolled past, a throwing write left part-stored, or that no request
-     * since this agent started has held (and no failed start since has
-     * stored), is stored again at the next start,
+     * has scrolled past, an undo has taken out of the agent's window (#291),
+     * a throwing write left part-stored, or that no request since this agent
+     * started has held (and no failed start since has stored), is stored
+     * again at the next start,
      * so the agent has the current copy at the cost of one more row: a fold
      * between two starts leaves the request after it with the summary's word,
      * and the start after that stores it again. The rows to store come in the order gathered,
@@ -4104,27 +5174,37 @@ export declare class AgentFramework {
      * Undefined when there's nothing of the stored kind.
      */
     private planInjectionStores;
-    /**
-     * Whether a write the framework makes into `agent`'s window of its own
-     * accord (a clock row, a batched wake's line) waits: while the host is
-     * quiesced, or, for a reader of the residents' shared slot (the
-     * subconscious, which reads it through a merged view, included), while
-     * another reader of it has a turn alive, where it would land inside that
-     * turn.
-     */
-    private slotHeldFrom;
     /** Rows isNewestIn reads back past clock rows and stored injections. */
     private static readonly NEWEST_SCAN_ROWS;
     /** Rows a window's last-clock scan reads at a time. */
     private static readonly CLOCK_SCAN_ROWS;
-    /** What the next clock is planned from: the window's newest row's time and
-     *  the time its last clock row reads, found by reading back from the
-     *  newest row, CLOCK_SCAN_ROWS at a time, until a clock row comes, however
-     *  far back it is. In the steady state the newest chunk holds it, unless
-     *  more rows than that have come since the last clock; a window with no
-     *  clock row is read whole once, and then takes one (planClock). */
+    /** What the agent's next clock is planned from: its window's newest row's
+     *  time and the time its last clock row reads, found by reading back from
+     *  the newest row, CLOCK_SCAN_ROWS at a time, until a clock row comes,
+     *  however far back it is. In the steady state the newest chunk holds it,
+     *  unless more rows than that have come since the last clock; a window
+     *  with no clock row is read whole once, and then takes one (planClock).
+     *  While the agent's context is in legacy mode, its window is the slot's
+     *  record, a co-resident's rows and clock rows among them. Once it
+     *  presents rows (#291), the window is the rows presented to it, in their
+     *  order: a co-resident's clock row isn't in it unless the agent observes
+     *  that co-resident (AgentConfig.observes), and then the newest clock row
+     *  the window holds is read, whosever it is; a row stored and not
+     *  presented yet comes after the clock its start writes, so it isn't read. */
     private lastClockOf;
     private agentSees;
+    /**
+     * Record `view`, the filter `contextManager` was opened with
+     * (context-options.ts: residentViewFilter, subconsciousViewFilter, or
+     * liveViewFilterOf's choice for an agent's record), as what its agent sees
+     * (storeSees), so main's checks of whether an agent sees a row (agentSees,
+     * #853: a tool boundary's injection, an arrival, an unread message's
+     * readers, the newest-row check, the recent-image scan) ask the predicate
+     * its compiles read. Both views read a row's metadata alone. A manager
+     * opened with no view keeps no record, and agentSees reads it as seeing
+     * every row, as its compiles do. Returns the manager.
+     */
+    private recordView;
     /**
      * Weigh a message that no tool boundary of the agent's open logical turn
      * will weigh: one that would re-pin the locus becomes one of the turn's
@@ -4137,18 +5217,11 @@ export declare class AgentFramework {
     private noteArrival;
     /**
      * Whether `agent`'s store is the residents' one message slot, which every
-     * ordinary resident reads (`readsSharedSlot` in the registry). The subconscious reads that
-     * slot through a merged view, but its own store is isolated, as a fork's
-     * or an ephemeral agent's is.
+     * ordinary resident reads: its own slot in the registry (`ownSlot`) is
+     * that slot. The subconscious reads that slot through an observe edge, but
+     * its own store is isolated, as a fork's or an ephemeral agent's is.
      */
     private isOrdinaryResident;
-    /**
-     * Weigh a message just stored in an ordinary resident's store for every
-     * other ordinary resident's open turn, running or not: residents read one
-     * message slot, and a tool boundary weighs only the messages drained for
-     * its own agent, so no boundary of another resident's turn weighs it.
-     */
-    private noteForOtherResidents;
     /**
      * Show the turn's typing indicator in `channel`, stopping the one it last
      * showed elsewhere: this stream's, or one an earlier stream of the turn
@@ -4179,18 +5252,20 @@ export declare class AgentFramework {
      */
     private repinTurnLocus;
     /**
-     * Under `speech.locus: 'delivery'`: tell the agent that someone addressed
-     * it from another channel while its turn was busy, since incoming traffic
-     * never moves the locus and a neutral message carries nothing that names
-     * its channel (first live run, 2026-10-12, finding C). Once per channel
+     * Under `speech.locus: 'delivery'`, and in a locked turn under either rule:
+     * tell the agent that someone addressed it from another channel while its
+     * turn was busy, since incoming traffic never moves the locus and a neutral
+     * message carries nothing that names its channel (first live run,
+     * 2026-10-12, finding C). Once per channel
      * per turn (TurnRouting.addressedElsewhere); nothing for the turn's own
-     * locus. Stored durably; returned as stored for a live stream to inject
-     * with its boundary's other messages. Undefined when nothing was stored.
+     * locus. Stored durably; returned as stored, with its id, for a live
+     * stream to inject with its boundary's other messages, so the round's note
+     * (noteRoundSent) names the stored row. Undefined when nothing was stored.
      */
     private addressedElsewhereNotice;
     /**
      * The arrivals a start of the turn consumes under `speech.locus:
-     * 'delivery'`: each one that addressed the agent, whose message is still
+     * 'delivery'`, or in a locked turn: each one that addressed the agent, whose message is still
      * in the store, gets the addressed-elsewhere notice, oldest first. A
      * follow-up in an engaged channel addressed nobody and is not announced.
      */
@@ -4207,8 +5282,9 @@ export declare class AgentFramework {
      * ensureInitialDesiredState) only where the agent it's addressed to can
      * call it for every channel it names (canCloseChannels): a conversation
      * fork may close only its home channel, and an agent's allowedTools can leave
-     * channel_close out. The other residents can read it too, where several
-     * share one slot (#291); a fork's seed leaves it out (primaryNoticeTexts).
+     * channel_close out. Where several residents share one slot it is stored
+     * in the slot they share, but stamped for the agent it's addressed to
+     * (#291); a fork's seed leaves it out (primaryNoticeTexts).
      * Where an
      * agent's own send opened a channel it can't close, the primary is told by
      * name too, if it's registered and can close it, and the agent is told
@@ -4224,14 +5300,17 @@ export declare class AgentFramework {
      * Write a builder's channel notices in order, each on its own: one that
      * can't be written is logged, and the rest are still written. A reader's
      * notice that says the primary was told comes after the primary's, and is
-     * written in its `untold` words where the primary's write failed, so it
-     * never says the primary was told of a notice that wasn't written. A write
-     * addMessage defers to the primary's next boundary, as it does any write
-     * to an agent mid-turn, counts as written: a memory-only queue loses it at
-     * exit, as it loses any deferred write. Through
-     * framework.addMessage for mid-turn safety (deferral + hear-while-acting
-     * injection): an open a delivery forces happens inside a live turn, and a
-     * direct context-manager append there would store the notice out of order.
+     * written in its `untold` words where the primary's write threw, so it
+     * never says the primary was told of a notice whose write threw. A write
+     * a surgery's hold keeps in memory, or one kept for a manager that refuses
+     * its work, counts as written (addMessage returns '' for it, without
+     * throwing): if storing the primary's fails at the release, or a restart
+     * loses it, the reader's notice, stored too, still says the primary was
+     * told. A write is stored at once (#291), and one for an agent mid-turn enters its
+     * window at its next point (its tool boundary hears it, or its turn's end
+     * presents it). Through framework.addMessage, so a notice an open forces
+     * inside a live turn is stored and presented as any write is, rather than
+     * appended to the context manager straight.
      */
     private writeChannelNotices;
     /**
@@ -4321,8 +5400,10 @@ export declare class AgentFramework {
      * channel_open as the way to try again only where the agent it's addressed
      * to can call it: a conversation fork's channel_open is refused outright
      * (dispatchChannelToolCall), and an agent's allowedTools can leave it out.
-     * The other residents can read it too, where several share one slot
-     * (#291); a fork's seed leaves it out (primaryNoticeTexts).
+     * Where several residents share one slot it is stored in the slot they
+     * share, but stamped for the agent it's addressed to (#291), the primary
+     * alone where it's told by name; a fork's seed leaves it out
+     * (primaryNoticeTexts).
      * Where the channel is selected for opening, it says so and why, as
      * speech's failure does, and what that means: where the host couldn't
      * record putting the channel's decision back, a later delivery or
@@ -4391,9 +5472,6 @@ export declare class AgentFramework {
      * agent's cap. False when it couldn't be stored.
      */
     private writeAutoContinueNotice;
-    /** Whether another reader of the residents' shared slot has a turn alive,
-     *  so no row may be written there now (as storeDueClock checks). */
-    private sharedSlotBusy;
     /** A continuation whose turn doesn't run: the run's count goes back to
      *  what it was before it was queued. */
     private giveBackAutoContinue;
@@ -4529,8 +5607,8 @@ export declare class AgentFramework {
      * the gate released). Any other drop ends it as a start dropped before it
      * sends anything ends, and settles a registered ephemeral run's turn with
      * the drop's reason. That frame, if it hasn't let go of its token yet,
-     * ends on its own and settles nothing. What was deferred for the agent
-     * lands now, or at that frame's end.
+     * ends on its own and settles nothing. What was stored for the agent
+     * meanwhile is presented now (presentAtEndOf), or at that frame's end.
      */
     private endContinuedTurn;
     /**
@@ -4672,8 +5750,10 @@ export declare class AgentFramework {
      * - Refused unless the agent is idle with no turn alive: puppeting
      *   mid-turn would corrupt the turn state machine and the live stream's
      *   wire ordering. For its own duration the puppet HOLDS the turn-alive
-     *   marker (wakes requeue, cross-turn writers defer), so a wake landing
-     *   during the tool's execution cannot start a turn underneath the pair.
+     *   marker (wakes requeue, and a write meanwhile is stored at once and
+     *   kept out of the window until the agent's next presentation point, the
+     *   puppet's end), so a wake landing during the tool's execution cannot
+     *   start a turn underneath the pair.
      * - Refused for tools outside the agent's own surface (the tools it may
      *   call, availableToolsForPresentation), and for skip_reply, by name or
      *   through a toolsets--act that reaches it, which ends the turn it's
@@ -5149,48 +6229,64 @@ export declare class AgentFramework {
     private dispatchToolCall;
     private dispatchToolCallEvent;
     private addMessage;
+    /**
+     * The agents a write's placement may name (addMessage's out-param,
+     * #291), never none: its delivery agent, or, for a write stored in that
+     * agent's slot for other agents only (its stamp names them and not it,
+     * as a coalesced render targeted to a co-resident is: inboundAudience),
+     * those of them whose own slot it is. The placement names one agent,
+     * whose store the coalescer reads the row in and removes it from
+     * (isUnreadPlacement, removePlacement), whose wake reads it, and to whom
+     * `presented` refers: the first of these the write wasn't presented to,
+     * else the first. An agent that only observes the slot (the subconscious
+     * over the residents' slot) has no copy of the row in its own store, so
+     * a write for such agents alone is placed for the delivery agent, as
+     * before.
+     */
+    private placementReaders;
     /**
      * Whether an MCPL event's own stored entry is the newest entry in the window
-     * a batched wake's line is written to (deliveryAgent(): the primary's), with
-     * no turn alive there (turnAlive: started, streaming, or waiting on its
-     * tools) and nothing waiting to be written (deferred). The gate then hands
-     * the line to the wake (WakeLine) instead of writing it, and the turn's
-     * start decides it (placeWakeLines). A channel message is found by its
-     * server, channel and message id, a push event by its server and event id.
-     * A message a tune-out holds from the residents is never "newest" here.
+     * a batched wake's line is written to, with no turn alive there (turnAlive:
+     * started, streaming, or waiting on its tools): the window of each agent a
+     * targeted event was delivered to (`recipients`), else the delivery
+     * agent's (deliveryAgent(): the primary's). The gate then hands the line to
+     * the wake (WakeLine) instead of writing it, and the turn's start decides
+     * it (placeWakeLines). A channel message is found by its server, channel
+     * and message id, a push event by its server and event id. A message a
+     * tune-out holds from the residents is never "newest" here.
      */
     private isNewestContextEntry;
     /**
      * Write the batched-wake lines the gate left to this turn's start (WakeLine)
-     * into the window they name, the delivery agent's (the residents' shared
-     * slot where it is one), on that agent's own start only. Called by a fresh
-     * start that doesn't resume a logical turn, after the turn's own inputs (a
-     * due clock row, the deferred-write and assembly flushes) and before its
-     * checkpoint, so a line lands after whatever arrived since the gate's
-     * decision, before the notices the turn's start writes itself (the locus
-     * notice among them), and before the agent's answer to the wake.
+     * into the starting agent's own window, as its own rows (#291). Called by
+     * a fresh start that doesn't resume a logical turn, after the turn's own
+     * inputs (a due clock row, and the rows its start presents) and before its
+     * checkpoint, so a line lands after whatever entered the window since the
+     * gate's decision, before the notices the turn's start writes itself (the
+     * locus notice among them), and before the agent's answer to the wake.
      *
-     * - A wake's one line whose event is still the newest entry is left out:
-     *   no message follows the wake's, so it is the wake's whole cause, and the
-     *   start's token defers an arrival into the window past its request. (The
-     *   start's own notices, written after this, aren't messages a reply could
-     *   be meant for.)
-     * - A co-resident's start places nothing. Every resident gets every
-     *   batched wake, so a co-resident writing the line would put it under the
-     *   message, the line #727 left out, or after the delivery agent's answer,
-     *   a wake line for a message already answered. Its request shows what the
-     *   slot holds, as on `main`: a reply after the message is in the message's
-     *   own channel, but a message from another channel that lands between the
-     *   gate's decision and its compile follows the message with no line.
+     * - A wake's one line whose event is still the newest entry of the
+     *   agent's window is left out: no message follows the wake's, so it is
+     *   the wake's whole cause, and an arrival stored past the start enters
+     *   the window at a later point, after its request. (The start's own
+     *   notices, written after this, aren't messages a reply could be meant
+     *   for.)
+     * - Each resident a batched wake is for (every resident, or a targeted
+     *   batch's recipients) gets it, and each one's start
+     *   decides and writes its own line: a co-resident's line, and her reply,
+     *   are her own rows and enter no other window but an observer's
+     *   (AgentConfig.observes), which takes them as it takes her rounds; in
+     *   no other can either land under the message or after another
+     *   resident's answer. For an agent whose
+     *   window isn't presented (its write-down failed, so its window is the
+     *   record), only the delivery agent's start writes the slot's one line,
+     *   and a co-resident's start places nothing.
      * - Two or more lines are all written, each naming its message, its age
      *   counted to now.
-     * - None is written while the host is quiesced or another reader of the
-     *   slot has a turn alive (slotHeldFrom, as for a clock row): written, a
-     *   line would land inside that turn, and deferred, it would wait for the
-     *   delivery agent's next boundary, never reaching this request
-     *   (overlapping turns in the slot, #286). They stay undecided, and are
-     *   written only if another fresh start of the wake comes (a provider
-     *   hold's release, a requeue): this start's request goes without them.
+     * - None is written while the host is quiesced, as for a clock row. They
+     *   stay undecided, and are written only if another fresh start of the
+     *   wake comes (a provider hold's release, a requeue): this start's
+     *   request goes without them.
      *
      * A line left out is traced. Each line is written once (placedWakeLines),
      * across the wake's retries and holds, whichever copy of its trigger a
@@ -5202,41 +6298,88 @@ export declare class AgentFramework {
      *  clock rows, stored context injections and rows the agent's own view
      *  leaves out after it aside: a channel message by its server, channel and
      *  message id, a push event by its server and event id, and never one the
-     *  agent's view leaves out, such as one a tune-out holds. Past
-     *  NEWEST_SCAN_ROWS such rows, it answers no. */
+     *  agent's view leaves out (agentSees), such as one a tune-out holds. Past
+     *  NEWEST_SCAN_ROWS such rows, it answers no. While the agent's context
+     *  is in legacy mode, its window is the slot's record, read from its
+     *  newest row. Once it presents rows (#291), the window's own order
+     *  decides, as the agent's next request will hold it (windowTail): the
+     *  rows presented to it, then its own rows and its arrivals not presented
+     *  yet (bearingOf), an observed co-resident's rounds among them, which its
+     *  next start presents; a row stored in a shared slot for another agent,
+     *  such as the own round of a co-resident it doesn't observe, isn't in
+     *  it. */
     private isNewestIn;
+    /**
+     * The newest `limit` rows of a presented window as the agent's next
+     * request will hold them, newest first: the rows it is owed and not
+     * presented yet (its own rows and its arrivals, one per body, as the
+     * presentation index reads them: owedOf, so an observed co-resident's
+     * round is among them), after the rows its window holds. A row presented
+     * later than a newer one comes after it here, as in the window.
+     */
+    private windowTail;
     /** Where addMessage delivers: the named agent, else the primary, else the
      *  first registered agent. Undefined when there is no such agent. */
     private deliveryAgent;
+    /**
+     * The audience addMessage stamps a write with when its caller gives none
+     * (#291): for one a suppress rule took (suppressedRow), nobody, as no view
+     * renders it; for one that carries a tune-out's hold, nobody, since no
+     * resident is shown it (inboundAudience), unless it names an agent whose
+     * own view keeps it (agentSees, main's #853: the subconscious, whose view
+     * keeps held traffic), which it is for; the agent a write names
+     * (`forAgent`); and for a write that names no agent, untargetedAudience
+     * of the agent it is delivered to. Undefined only for that last on a
+     * host with no agent, where addMessage stores nothing. Restore stamps an
+     * entry an earlier version queued by the same rule
+     * (restorePersistedDeferredWrites).
+     */
+    private defaultAudience;
+    /**
+     * Who a write that names no agent is for (#291's audience stamp): the
+     * agents whose role takes untargeted inbound (the registry's
+     * untargetedRecipients) and whose own slot is the slot the write lands
+     * in, its delivery agent's, in registration order. On a residents' host
+     * that is every resident, as every resident reads the shared slot the
+     * row is stored in; with one resident it is that resident, the stamp such
+     * a write had before. The delivery agent alone when there is none: a host
+     * whose only agent is an ephemeral run, or an agent the registry doesn't
+     * place. This is the rule #291's presentation index presents an
+     * untargeted row in the shared slot by, applied when the row is written,
+     * so the record tells an untargeted write from one for the primary,
+     * which is stamped with the primary alone. The slot's observers (the
+     * subconscious) aren't in it: they are a relationship in the registry
+     * (dendrite/audience.ts).
+     */
+    private untargetedAudience;
+    /** A message was said to `agentName` (main's #846): the re-send count of
+     *  its exhausted turn starts again, unless its own view leaves the
+     *  message out (agentSees), it is the agent's own schedule write, or it
+     *  isn't conversation. */
     private noteSpokenTo;
-    /** The notes addMessage takes for a message it stored: an arrival for the
-     *  agent when none of its turns is alive or the message was assembled for
-     *  the start now beginning (no tool boundary will weigh it), and one for
-     *  every other resident's open turn. */
+    /** The notes addMessage takes for a message it stored. Each agent it is
+     *  for was spoken to (noteSpokenTo): the agents its audience stamp names
+     *  (#291), which for a write that names no agent are the residents that
+     *  take untargeted inbound in its slot, as main notes every other
+     *  resident (noteForOtherResidents there), and the agent it was delivered
+     *  to where it carries no stamp. And for an agent whose window isn't
+     *  presented (a write-down of it failed), whose window is the record: an
+     *  arrival for its open turn when none of its turns is alive or its start
+     *  is assembling (no tool boundary will weigh it). An agent the
+     *  presentation index presents for weighs the row as it enters its window
+     *  (adoptPresentation's listener), or at the tool boundary that hears it,
+     *  not here. */
     private noteStored;
     /**
      * Held agent mail is released only when its message has actually entered
-     * the recipient's store — never on a deferral. Called at every site that
-     * writes a message into a context: the direct path above and the two
-     * deferred-write flushes (turn start, tool boundary). Both writes reach
-     * disk in the same sync, so a crash keeps either both or neither.
+     * the recipient's store, as a copy for that recipient — never while a
+     * surgery's hold, or the wait for the recipient's recovery, keeps the
+     * write in memory. Called where the framework stores a
+     * message (addMessage, and the importer's lookup of a write that landed).
+     * Both writes reach disk in the same sync, so a crash keeps either both or
+     * neither.
      */
     private releaseLandedMail;
-    /**
-     * Splice out the deferred messages addressed to `agentName` (explicitly
-     * via forAgent, or implicitly when it is the primary), leaving other
-     * targets' messages queued for their own boundaries. With `stopAt`, the
-     * drain ends at the first of them (in queue order) that it matches: that
-     * message and every later one stay queued, so what is drained is always a
-     * prefix of the agent's queue.
-     */
-    private drainDeferredFor;
-    /**
-     * Put drained entries back into the queue under their ids and seq: out of
-     * the un-acked set, and persisted when the queue is. A memory-only queue
-     * keeps them while the framework runs.
-     */
-    private requeueDrained;
     /**
      * What the next compile sends for each of `ids`, messages a tool boundary
      * has just stored, as the agent's strategy renders them as the newest of
@@ -5250,110 +6393,9 @@ export declare class AgentFramework {
      * strategies could say.
      */
     private renderForInjection;
-    /**
-     * Write drained entries in queue (seq) order, whatever their targets:
-     * residents share one message slot, so the order entries arrived in is the
-     * order they're stored. Each target is cut at its own first entry that
-     * can't be stored: that entry and every later one for the same target go
-     * back into the queue under their ids and seq (requeueDrained) before
-     * anything is logged, and other targets' entries go on. Left in the
-     * un-acked set, the next ack would drop them from the durable queue.
-     *
-     * So none of a target's entries lands ahead of an earlier one, and a queued
-     * tool_use that can't be stored keeps the tool_result queued behind it from
-     * being stored alone, unless context-manager refused it as malformed
-     * (below). (A tool_use that is stored, followed by a tool_result that
-     * can't be, stays stored without it until the tool_result lands at a later
-     * flush, or for good when the store refuses the tool_result as malformed.
-     * The only queued pair is puppetToolCall's, queued only when its turn's
-     * token is no longer its own once the pair is built, which its comment
-     * calls defensive.) An entry that keeps failing is logged by id at each
-     * flush, and holds its target's later queued writes rather than letting
-     * them land out of order.
-     *
-     * An entry context-manager refuses as malformed (MalformedContentError) is
-     * the exception for the store's own validation: context-manager checks
-     * content and every shard before writing. A custom synchronous strategy
-     * hook can throw the same class after append (context-manager #288);
-     * unreadable landing in that callback escape remains a limitation until
-     * the CM follow-up lands. A copy actually found still counts first. Other
-     * ambiguous errors remain queued for ID reconciliation before retry. A
-     * malformed refusal would fail every flush and hold its target's later
-     * writes for good, so it's logged and dropped instead, and its
-     * target isn't cut: left in the un-acked set, the next ack drops it from
-     * the durable queue. A tool_use dropped this way leaves a tool_result
-     * queued behind it to be stored alone. context-manager mends a tool_use
-     * whose input isn't an object, so it refuses one only when that input has
-     * no JSON form or the block itself is malformed. addMessage refuses such
-     * content before it's queued, so an entry meets this here from a queue an
-     * earlier process persisted, as puppetToolCall's pair, which it queues
-     * itself, or when the strategy's chunking splits well-formed content into a
-     * shard the store refuses, which the store's error names.
-     *
-     * From a fresh turn's start to the end of its coalescing assembly, before
-     * its checkpoint, every write deferred for its agent lands in that
-     * request, in arrival order, up to one that can't be stored and unless the
-     * host is quiesced (flushForStart). The turn-start flush writes the queue;
-     * while the assembly runs, each write it makes into the agent's own window
-     * (addMessage's bypassDeferralFor) first writes what was deferred since;
-     * and what was deferred during the assembly is written once it ends. A
-     * write the assembly makes while an entry is held waits behind it in the
-     * queue, so the hold covers the assembly's writes too, and so does one
-     * made while the host is quiesced with anything queued for the agent: a
-     * quiesce that begins while an assembly awaits a render lets that turn
-     * drain, and what is queued waits for resume(). Outside that window the
-     * hold is the queue's alone: a write that isn't deferred is stored at once
-     * and can land ahead of a held entry, as a fresh tool_result does whatever
-     * its agent's state, and any write does while its agent's turn, stream and
-     * tool cycle are all idle and the host isn't quiesced. So an entry that
-     * keeps failing holds what is deferred behind it and the assembly's writes
-     * for its agent.
-     *
-     * A write can throw after its message is stored: a store listener, the
-     * strategy's handling of the add, or a later shard of a sharded body can
-     * throw once a record is written. Before an entry that threw is put back,
-     * its target's store is read from where it stood before the write, for
-     * messages carrying the entry's `deferredWriteId`. What it finds counts as
-     * written, at most once: the entry isn't requeued and stored a second
-     * time, and what landed, as later compiles render it (asCompiled), is what
-     * it returns as the entry's content. For a sharded body, that can be its
-     * first shards alone if rollback could not remove them; context-manager
-     * from 0.15 otherwise removes shards from a failed append. (Requeued, the
-     * landed shards would be stored twice, and only the rest could not be
-     * appended later without splitting the body.) Boot's scan for landed
-     * writes counts a landed shard the same way. When the store can't be read
-     * back (storedCopiesOf logs it), or couldn't say how many messages it held
-     * before the write, the store is searched for the entry's id at once
-     * (landedCopiesById): found, it counts as written, as above. When that
-     * can't be done either, whether the entry landed is unknown: it's put back
-     * marked so (`landing`), and before it's written again the store is
-     * searched for its id. Found then, it counts as written where it was
-     * stored, ahead of what was stored since without it, a known limit
-     * (context-manager #155, named at the tool boundary's drain); not found,
-     * it's written. While the store can't be searched, it stays queued,
-     * holding what's behind it.
-     *
-     * Returns what was written (stored, or deferred again by addMessage, whose
-     * id is then empty), in queue order: for one target, its entries up to the
-     * first that couldn't be stored, less entries refused as malformed and dropped. Each comes
-     * with its content: as given, unless the store took it as more than one
-     * message (a sharded body) and can be read back, when its copies are
-     * returned joined, as later compiles render them (asCompiled), or its write
-     * threw after storing it (above). `onLanded` hears an entry whose write
-     * threw after storing it, with the id it landed under, as soon as it's
-     * found: before the writes after it, so whatever it records keeps their
-     * order.
-     */
-    private writeDrainedInOrder;
     /** How many messages the agent's store holds: undefined when its store
      *  can't say. */
     private storedCountOf;
-    /** The messages carrying `deferredWriteId` among those the agent's store
-     *  gained from position `from` on, in store order, with their blobs
-     *  resolved, as a request carries them. A sharded body's carry its
-     *  `bodyGroupId`. Undefined when the store can't be read back, which is
-     *  logged: not the same as nothing found. */
-    private storedCopiesOf;
     /** The messages `match` picks among those the agent's store gained from
      *  position `from` on, in store order, with their blobs resolved. Undefined
      *  when the store can't be read back, which is logged under `tag`, naming
@@ -5369,66 +6411,41 @@ export declare class AgentFramework {
      * is absent, and a write taken as absent is stored again.
      */
     private landedPositions;
+    /** The rows on `cm`'s current branch whose metadata `match` picks, by
+     *  position and id, in store order, scanned as landedPositions says: in
+     *  blob-free windows, throwing where a window can't be read or comes back
+     *  short. */
+    private rowsWhere;
+    /**
+     * The rows of the coalesced occurrence `metadata` is a delivery of (its
+     * `coalescingSubject` and `eventId`, the delivery identity wasPublished
+     * reads at a restore) that `agent`'s store holds on its current branch, in
+     * store order: [] for none, or for a write that carries no such identity.
+     * A delivery's recovery reads them before it stores the occurrence again
+     * (FrameworkWriteOptions.mayBeStored), after a delivery whose store
+     * couldn't tell whether it landed: context-manager gives the row of an
+     * append that threw no id, so it is found by what it carries, as
+     * findMessageByExternalId finds a module's write. Scanned blob-free
+     * (rowsWhere), so a blob missing from some row can't hide them. Undefined
+     * when the store can't be read to tell, which is logged, naming the
+     * occurrence and the duplicate its store may then make: the one case the
+     * recovery can't tell.
+     */
+    private storedOccurrenceRows;
     /**
      * The messages carrying `deferredWriteId` anywhere on the agent's current
      * branch, in store order with their blobs resolved, as a request carries
-     * them, so no position is needed. They're found with queryMessages, over
-     * context-manager's cached view, as landedRow finds a held write's row.
-     * Where that throws, as one blob missing anywhere on the branch makes it
-     * do, the branch is scanned blob-free instead (landedPositions), and only
-     * the rows that match are read with their blobs. Undefined when the store
-     * can be searched neither way, or the scan finds the write's rows but one
-     * of them can't be read. Each write whose lookup fails is said once until
-     * a lookup of it succeeds, since every path that reads held writes looks
-     * again.
+     * them, so no position is needed: where an earlier release's queued write
+     * whose landing it couldn't tell may have landed (the importer's lookup).
+     * They're found with queryMessages, over context-manager's cached view,
+     * as landedRow finds a held write's row. Where that throws, as one blob
+     * missing anywhere on the branch makes it do, the branch is scanned
+     * blob-free instead (landedPositions), and only the rows that match are
+     * read with their blobs. Undefined when the store can be searched neither
+     * way, or the scan finds the write's rows but one of them can't be read,
+     * which is logged.
      */
     private landedCopiesById;
-    /** The line naming a drained write that threw: one that couldn't be stored,
-     *  which is already back in the queue; with 'dropped', a malformed refusal
-     *  from the store's pre-write validation (see the CM #288 caveat above);
-     *  with a count, one stored before the
-     *  throw (for a sharded body, how many of its shards), or, with
-     *  `foundLater`, one an earlier write of which landed and was found by its
-     *  id; with `'unknown'`, one whose store couldn't be read to tell
-     *  whether it landed, back in the queue to be looked up first; and with
-     *  `'still-unknown'`, one that still can't be looked up. Logging mustn't
-     *  fail the flush that met it, so a thrown value that has no text is
-     *  named as such. */
-    private logDeferredWriteError;
-    /**
-     * Write what is queued for `agent` into its window past its deferral, in
-     * queue order and cut at a write that fails, though one the store refuses
-     * as malformed is dropped and what follows goes on (writeDrainedInOrder),
-     * between a fresh turn's start and its checkpoint, where what is stored is
-     * the turn's input: at the start, before each write the coalescing
-     * assembly makes for the agent, and once the assembly ends, the last two
-     * not while the host is quiesced, when what is queued waits for resume().
-     * What is stored is weighed for the start now beginning and for every
-     * other resident's open turn. Returns whether anything is still queued for
-     * the agent.
-     */
-    private flushForStart;
-    /** Whether anything is queued for `agentName`, by drainDeferredFor's
-     *  target rule. */
-    private queuedFor;
-    /** Re-add drained entries through addMessage, which stores each or defers
-     *  it again, in queue order and cut per target (writeDrainedInOrder). With
-     *  `bypassDeferral`, each is stored past its target's deferral (stop()). A
-     *  write that threw after storing missed the notes addMessage takes after a
-     *  store, so they're taken for what landed as soon as it's found, before
-     *  the writes after it: an open turn's arrivals keep the order the writes
-     *  landed in, and its newest stays the newest (remainingArrival).
-     *
-     *  A target no longer registered (a fork or a run that has ended, here or
-     *  before a crash) has no window to land in: a failed reply queued for it,
-     *  or a channel notice it could have acted on, becomes the primary's
-     *  by-name notice, and a module's write for a run or a fork goes to it as
-     *  written, each under the entry's own id and place in the queue
-     *  (passesToPrimary, queuedNoticeForPrimary), written with the rest; any
-     *  other write is dropped, logged, by addMessage. Nothing here reads the gone agent's
-     *  window, so such a notice an earlier write of which landed there, and
-     *  which the agent read, goes on too. */
-    private readdDrained;
     /**
      * Where a notice about an agent's own action belongs: its failed reply, its
      * bounced prose (beside its `{{unsent}}` clipboard), its script's wake, the
@@ -5437,8 +6454,9 @@ export declare class AgentFramework {
      * waits on that agent's own turn, stream and tool cycle: a conversation
      * fork or an ephemeral run reads only its isolated slot, and a resident's
      * notice would otherwise wait on the primary's turn rather than its own.
-     * Residents share one message slot, so a resident's notice can land there
-     * while another resident's turn is alive; agent-framework #291 covers that.
+     * Residents share one message slot, so a resident's notice can be stored
+     * there while another resident's turn is alive; since #291 it is for its
+     * agent alone, and enters no other resident's window.
      *
      * null when the agent is no longer registered (a fork or a run already
      * released): there is no window to write, so the caller writes nothing,
@@ -5452,81 +6470,65 @@ export declare class AgentFramework {
     /**
      * A conversation fork or an ephemeral run has been deregistered. A release
      * never runs while the host is quiesced: it waits for resume()
-     * (releaseWindowNowOrAfterResume), since a write could land mid-surgery.
+     * (releaseWindowNowOrAfterResume), or, when stop() comes first, stop()
+     * runs it.
      *
      * The agent never reads its window again, so every failed-reply notice it
      * never read, and every channel notice it could act on and never read, is
      * passed to the primary, by name, once, and so is every module write for
      * it that it never read, as the write itself (passesToPrimary,
-     * passOnFromReleasedWindow): each one stored in its window above its
-     * consumed watermark (flushed there at its turn's end, or stored while it
-     * was idle) and not heard at a tool boundary, and each one still queued
-     * for it, pending or un-acked. One with an entry still in the durable
-     * queue goes on only as that entry, under its own id and seq, so a crash
-     * before the ack below replays it once; a copy of it in the window decides
-     * only whether the agent read it. Writes still queued would wait for a
-     * boundary it never reaches, and a flush that finds it gone would drop all
-     * but the notices it passes on, so they land in its own window now, which
-     * Chronicle keeps for investigation. One whose earlier write may have
-     * landed (`landing` unknown) is looked up there by its id first, or, where
-     * the store can't be searched, in the window's own read: found, it isn't
-     * stored again; where neither can see the store, it's stored anyway, with
-     * a line saying it may now be stored twice, or, where storing it fails
-     * too, that it may be stored once, twice or not at all. Its stream is over
-     * or cancelled, or, when stop() ends it, may still run past its cancel, and
-     * then drops each event that comes after the agent has left (driveStream);
-     * a turn of its still assembling or compiling, as when stop() ends it,
-     * drops before it sends anything. One path still stores after these
-     * writes: a `complete` that arrived while the agent still waited for tools
-     * awaits the spill of its last tool results, and stores them once that
-     * resolves, even if a watchdog has ended the run meanwhile. A tool boundary
+     * passNoticeToPrimary): each one stored in its store for it, not for its
+     * parent or a co-resident whose record it shares, and not covered by its
+     * consumed watermark (releasedWindow): presented at its turn's end and
+     * never consumed, stored while it was idle, or never presented. A message
+     * a tool boundary injected is covered once its stream says it carried it.
+     * Its stream is over or cancelled, or, when stop() ends it, may still run
+     * past its cancel, and then drops each event that comes after the agent
+     * has left (driveStream); a turn of its still assembling or compiling, as
+     * when stop() ends it, drops before it sends anything. One path can still
+     * store after the release: a `complete` that arrived while the agent
+     * still waited for tools awaits the spill of its last tool results, and
+     * stores them once that resolves unless the agent's state was replaced
+     * meanwhile, as a run's disposal by its watchdog or its caller replaces it,
+     * or stop() or a quiesce's abandon cancelled its stream
+     * (roundStoppedDuringBuild): then it stores nothing, as a tool boundary
      * stores nothing for a round whose turn was stopped while its results were
-     * prepared.
+     * prepared. The agent's store stays in Chronicle for investigation.
      */
     private releaseWindow;
     /**
-     * The part of a released agent's pass to the primary that its release and
-     * stop() share (stop() runs it for a release the quiesce postponed). Each
-     * notice stored in its window that it never read and the primary takes in
-     * its place (passesToPrimary: a failed reply, a channel notice its reader
-     * could act on, or a module's write for a run or a fork, which goes as
-     * the write itself) goes on as stored, by name (passNoticeToPrimary),
-     * except a copy of an entry for it still in the durable queue, pending or
-     * un-acked: that entry is the notice's one identity until its ack, the one
-     * boot's check for landed writes knows, so it's the entry that goes on, as
-     * the primary's by-name notice under its own id and seq (`passOn`,
-     * queuedNoticeForPrimary), and a crash before the ack replays it once, not
-     * twice. A queued notice goes on unless the agent read a copy of it that
-     * landed in its window; where the window can't be read, it goes on, since
-     * telling the primary of a notice the agent may have read costs less than
-     * telling no one. Both callers run this before their drain, which hands
-     * pending entries to the un-acked set, so the un-acked entries for the
-     * agent here have all landed (their write went through, or a lookup found
-     * it: settleFound), and they go on here; the pending ones are the
-     * caller's. Returns the window's read, `passOn`, what it has queued so far
-     * for the primary, and how many un-acked entries the agent had.
-     */
-    private passOnFromReleasedWindow;
-    /**
-     * What a released agent's window holds that its pass to the primary reads
-     * (passOnFromReleasedWindow): `unread`, the notices stored there that it
-     * never read and the primary takes in its place (passesToPrimary: its
+     * What a released agent's window holds that its release passes to the
+     * primary (releaseWindow): `unread`, the notices stored there for it that
+     * it never read and the primary takes in its place (passesToPrimary: its
      * failed replies, the channel notices it was told it could act on, and a
      * run's or a fork's module writes), each with its participant and
      * content, a sharded body's shards joined into one text, as the
-     * autobiographical strategy joins them (asCompiled), other than
-     * copies of the entries `held` names; and `held`, for each of
-     * those entries with a copy there, its copies and whether any of them is
-     * unread. A notice is read below the lower of its consumed watermark and
-     * the point where the watermark's branch and the current one part
-     * (branchesPartAt), and unread everywhere when it has no watermark. The
-     * watermark is set when the agent is created, and moves at a compile, and
-     * at a tool boundary whose stream declares it carries the messages
+     * autobiographical strategy joins them (asCompiled). A notice is for it
+     * when the audience rule doesn't put it elsewhere (bearingOf, with the
+     * facts the registry recorded for it when its release was asked for:
+     * releasedReaders): its own row, a row whose audience names it, or a row
+     * with no stamp stored after a shared fork's derivation point. Its store
+     * may be a record it shares: a shared fork reads its parent's slot on a
+     * branch of its own, and a resident reads the slot every resident
+     * writes. A notice there for its parent or a co-resident never entered
+     * its window, and is that agent's to read, or to pass on at its own
+     * release: passed on here, it would reach the primary again at each such
+     * release, in this agent's name. A notice for it is read
+     * when the agent's consumed watermark covers it (covers): once its context
+     * presents rows (#291), when it was in the agent's window as of the mark,
+     * so a notice never presented to it, or presented and never consumed, is
+     * unread; for an agent whose window isn't presented, when it is at or
+     * below the mark, or, for a mark on another branch, at or below the lower
+     * of the mark and the point where the two branches part (branchesPartAt).
+     * A mark taken in presented mode can't say on another branch, and there,
+     * as everywhere for an agent with no watermark, every notice is unread.
+     * The watermark is set when the agent is created, and moves at a compile,
+     * and at a tool boundary whose stream declares it carries the messages
      * injected there (markContextConsumed). So a notice such a stream carried
-     * is under it. One a boundary stored without sending (a turn a tool ended,
-     * a budget restart, the direct API's boundary, which has no stream) is
-     * above it until a compile sends it, and counts as unread. null when the
-     * window can't be read, which is logged.
+     * is under it. One a boundary presented without sending (a turn a tool
+     * ended, a budget restart, the direct API's boundary, which has no stream)
+     * is above it until a compile sends it, and counts as unread. null when
+     * the window can't be read, which is logged.
      */
     private releasedWindow;
     /**
@@ -5540,15 +6542,16 @@ export declare class AgentFramework {
     private branchesPartAt;
     /**
      * Release a deregistered fork's or run's window (releaseWindow) now, or,
-     * while the host is quiesced, when it resumes. A release lands the agent's
-     * queued writes in its window, and while quiesced a write could land
-     * mid-surgery; dropping them instead would lose them from both the window
-     * and the recovery queue. Only the window waits: the agent is already
-     * deregistered, so its stream can't dispatch anything more and resume
-     * doesn't weigh its context, and a write addressed to it meanwhile is
-     * treated as for any agent no longer registered (dropped, or passed to the
-     * primary if it's a failed reply, a channel notice its reader could act
-     * on, or a module's write for a run or a fork: passesToPrimary).
+     * while the host is quiesced, when it resumes: what the release passes to
+     * the primary is judged on the window as the quiesce leaves it. Only the
+     * window waits: the agent is already deregistered, so its stream can't
+     * dispatch anything more and resume doesn't weigh its context, and a
+     * write addressed to it meanwhile is treated as for any agent no longer
+     * registered (dropped, or passed to the primary if it's a failed reply, a
+     * channel notice its reader could act on, or a module's write for a run or
+     * a fork: passesToPrimary). The writes kept in memory for it, while its
+     * context manager refused its work or by a surgery's hold still up, which
+     * no window holds, are judged so at once.
      */
     private releaseWindowNowOrAfterResume;
     /** resume(): the windows whose release the quiesce window postponed, each on its own. */
@@ -5557,28 +6560,27 @@ export declare class AgentFramework {
      * A fork or an ephemeral run ended before reading a notice the primary
      * takes in its place (passesToPrimary): it was released with the notice
      * stored in its window unread, or, for a failed reply, its delivery failed
-     * after release. (A notice still queued for it, at release or restored at
-     * boot, goes on as the queue entry itself: queuedNoticeForPrimary.) Tell
-     * the primary instead, naming the speaker, so an agent who can still act
-     * learns of it (noticeForPrimary). Never throws: it runs inside a release,
-     * which must complete whatever this write meets.
+     * after release. (One an earlier release left queued for it goes on at
+     * boot, under the queued write's own id: importPersistedDeferredWrites.)
+     * Tell the primary instead, naming the speaker, so an agent who can still act
+     * learns of it (noticeForPrimary). The notice is the primary's alone
+     * (#291's audience stamp): a co-resident sharing the primary's slot isn't
+     * the agent who takes the speaker's place. On a host with no primary it
+     * goes where a write that names no agent goes, stamped as one. A failed
+     * write is logged and returned, not thrown: it runs inside a release,
+     * which must complete whatever this write meets. Building the notice isn't
+     * guarded, so a throw there, as a store read for a channel notice's words
+     * can make at boot, reaches the caller. Whether the primary was told:
+     * `declined` when no one is, `failed` when the write failed, each logged;
+     * `held` when the write was kept in memory, not stored (a surgery's hold,
+     * or the receiving agent's manager refusing its work), which stores it at
+     * the hold's release, and loses it to a stop or a crash before then: the
+     * empty id addMessage answers for a write it keeps, and, for a write that
+     * names no agent, as this one, for nothing else. `passedOn`, the record
+     * and row a boot passes on (passOnInterruptedNotices), is stamped on the
+     * notice, so a later boot finds it passed.
      */
     private passNoticeToPrimary;
-    /**
-     * A queued entry for `speaker`, who is gone, that the primary takes in its
-     * place, as the primary's by-name notice (noticeForPrimary): the same
-     * entry, under its own id and seq, now addressed to the primary. Written
-     * through the drain, it lands stamped with that id, or waits in the queue
-     * under it, so boot's exactly-once holds for it: a crash before the
-     * original's ack replays one entry, never the original and a separate
-     * notice. An entry marked as one whose earlier write may have landed
-     * (`landing`) keeps the mark, so before it's written it's looked up by its
-     * id in the primary's window, where it would land now
-     * (writeDrainedInOrder). A release has looked in the speaker's own window
-     * first (releaseWindow). null when no one is told (logged where it's
-     * decided).
-     */
-    private queuedNoticeForPrimary;
     /**
      * The primary's by-name notice in place of one `speaker` never read, and
      * what it's about, as a log line says it: a failed reply's
@@ -5634,111 +6636,84 @@ export declare class AgentFramework {
     private labelledChannel;
     /**
      * A module's write through its context (ModuleContext.addMessage):
-     * addMessage's, except that a write the framework holds is answered by its
-     * handle (heldHandle) rather than '', so the module can find, read, edit
-     * and remove what it wrote before the write lands, through getMessage,
-     * editMessage and removeMessage, which read the delivery agent's window: a
-     * handle for a write held for a fork or a sub-agent isn't found there. The
-     * framework's own callers keep the '' they've always had, which their
-     * traces and checks take as a write not stored yet.
+     * addMessage's. The write is stored at once whatever its agent's turn
+     * (#291), and its stored id returned; it enters the agent's window at the
+     * agent's next presentation point, or at once while no turn of it is
+     * alive. Only while the write is kept in memory is the id '': a
+     * surgery's hold keeps it until its release stores it, and an agent whose
+     * context manager refuses its work after a failed re-initialization has
+     * it kept until a move re-initializes the agent and its release stores
+     * it (heldForRecovery). A write whose store throws where context-manager
+     * can't tell what of it landed throws its WriteOutcomeUnknownError, the
+     * rows it names presented (addMessage): the write may be stored, and isn't
+     * answered as stored.
      *
      * With `forAgent`, the write is for the named agent's window, which must
      * be registered when the write is made: a name that isn't, or the empty
      * one, which addMessage would read as none (deliveryAgent), throws, naming
      * the registered ones, as queryMessages does. The framework's own writes
-     * log and drop instead, as a held write does whose agent is gone by its
-     * flush. A write for an ephemeral run or a conversation fork, whose
-     * window nothing reads after its release, is marked (PRIMARY_IF_UNREAD_KEY),
-     * so the release passes it to the primary if its target never read it,
-     * as it passes a notice (passOnFromReleasedWindow).
+     * log and drop instead. A write for an ephemeral run or a conversation
+     * fork, whose window nothing reads after its release, is marked
+     * (PRIMARY_IF_UNREAD_KEY), so the release passes it to the primary if its
+     * target never read it, as it passes a notice (releaseWindow). A write
+     * that names no agent is stamped for the agents that take untargeted
+     * inbound in the slot it lands in (untargetedAudience, #291); one with
+     * `forAgent` for that agent.
      */
     private addModuleMessage;
-    /**
-     * The writes the framework holds for the store `reader` reads, in queue
-     * order: those addressed to it and, when it's an ordinary resident, those
-     * addressed to any ordinary resident, since residents share one message
-     * slot (`readsSharedSlot` in the registry). A write whose target is gone isn't among them:
-     * no module reads that agent's store, and the write waits for its window's
-     * release (drainDeferredFor) or, at its flush, is dropped (addMessage), a
-     * failed reply, or a channel notice its reader could act on, passing to the
-     * primary as its notice, and a module's write for a run as written
-     * (passesToPrimary, queuedNoticeForPrimary).
-     */
-    private heldWritesFor;
-    /**
-     * The writes held for `reader`'s store (heldWritesFor) as the rows a
-     * module's context reads: each under its handle, marked `held`, and
-     * `heldFromResidents` too when its metadata carries a tune-out's stamp
-     * (asModuleRow), with the participant, content and metadata it was
-     * written with, the time it was first held as its timestamp, and a
-     * sequence after every row the store holds, in queue order. The sequence
-     * and timestamp are provisional: the stored row has the store's own.
-     */
-    private heldRows;
-    /** The row a held write landed as, found by the id it's stored with
-     *  (`metadata.deferredWriteId`): the first, for a body stored in shards,
-     *  as addMessage answers a stored write. Null when it hasn't landed, or is
-     *  no longer in the store. */
+    /** The row a write an earlier release held landed as, found by the id
+     *  it's stored with (`metadata.deferredWriteId`): the first, for a body
+     *  stored in shards, as addMessage answers a stored write. Null when it
+     *  hasn't landed, or is no longer in the store. A module that kept the
+     *  `held:` handle such a release gave it reaches the row through it, for
+     *  one release (heldWriteId). */
     private landedRow;
     /**
-     * Settle held writes whose landing is unknown (DeferredWrite.landing),
-     * among those `which` picks, before a path reads or changes held writes:
-     * each is looked up by its id in its target's store (landedCopiesById).
-     * Found, the write landed (settleFound), where its copy sits, a known
-     * limit (writeDrainedInOrder). Not found, the mark goes, and it's an
-     * ordinary held write, which is persisted as an edit is. Where the store
-     * can't be searched, it stays marked, a doubt each path reads by its own
-     * rule.
-     */
-    private settleUnknownLandings;
-    /**
-     * A marked held write found to have landed, as `stored`: it leaves the
-     * pending queue for the un-acked set, as a drained write does, so it stays
-     * in the durable queue until the next ack has synced the store that holds
-     * it, and it's a stored write from then on, so the paths for a landed
-     * write apply to it. It takes the notes a store takes (noteStored), which
-     * its first write missed when it threw, as a flush that finds such a write
-     * takes them (readdDrained), and is logged by its id. It isn't carried
-     * into a turn, as a flush that finds it carries it: the agent reads it at
-     * its next compile, where the store holds it.
-     */
-    private settleFound;
-    /**
-     * A stored row a module names by its id: where it carries the
-     * deferredWriteId of a marked held write the reader's store holds, it's
-     * that write's copy, so the write landed, and it's settled as found
-     * (settleFound) before the row is read or changed. A lookup by the id
-     * can't be needed then, so this holds where the store can't be searched
-     * too. One row of a sharded body says it's a shard, without a count,
-     * since one row doesn't tell how many landed.
-     */
-    private settleByCopy;
-    /** A held write whose landing stays unknown after settling, its store
-     *  unsearchable, can't be edited or removed: it may already be stored, and
-     *  changing only the queued entry could leave its stored copy as it was.
-     *  Throws with nothing changed. */
-    private refuseUnsettled;
-    /** Whether a wake for a deferred write has nothing left for the agent to
-     *  do, on evidence only. The write's row is at or below the newest
+     * Whether a wake for a row it reads (InferenceRequest.readsRow) has
+     * nothing left for the agent to do, on evidence only. The row is done once
+     * it is gone from the agent's store on its current branch
+     * (removed, or left on a branch the agent has switched from, where a turn
+     * now would find nothing of it), or once an answered request's consumed
+     * watermark covers it and the agent has spoken where the wake asks
+     * (answeredCovers). A row stored and not yet presented to the agent isn't
+     * covered, so its wake stays: its turn presents the row. Any doubt keeps
+     * the wake, such as a store that can't be read.
+     */
+    private rowDone;
+    /** Whether a request the agent had answered carried `row`: the newest
      *  consumed watermark of an answered request (Agent.getAnsweredWatermark)
-     *  on the agent's current branch, and for a wake that carries a channel
-     *  and wasn't marked ambient (`to`, that channel on the wake's server), the
-     *  agent has since published there having read the row
-     *  (Agent.publishedAfterReading): hearing a message isn't answering it,
-     *  and the wake's turn is the agent's chance to answer there. Or the
-     *  write is in neither the queue (drained entries not yet stored
-     *  included) nor the store's current branch: removed, or left on a
-     *  branch the agent has switched from, where a turn now would find
-     *  nothing of it (switching back brings it back unread, with no wake, as
-     *  main's wake spent on this branch leaves it). Any doubt keeps the
-     *  wake, such as a watermark that a branch switch or an undo left on
-     *  another branch, or a store that can't be read: a turn that finds
-     *  nothing new costs less than a write no wake brings the agent to read
-     *  or answer. */
-    private deferredWriteDone;
-    private storedMessageDone;
-    private writeAnswered;
-    private readsWriteFor;
+     *  covers it, read in the agent's context (covers), and, for a wake that
+     *  carries a channel and wasn't marked ambient (`to`, that channel on the
+     *  wake's server), the agent has since published there having read the
+     *  row (Agent.publishedAfterReading): hearing a message isn't answering
+     *  it, and the wake's turn is the agent's chance to answer there. A mark
+     *  that can't say (none, or one a branch switch or an undo left on another
+     *  branch) says no. */
+    private answeredCovers;
+    /**
+     * The mark a wake for `agentName` takes for the row it was queued with
+     * (`placement`, addMessage's out-param), so the scheduler can drop the
+     * wake once the row needs nothing more of the agent (rowDone): the row's
+     * stored id, for every row stored for that agent, whether it was
+     * presented to the agent at its write or not (`presented: false`, set
+     * where the agent's turn was alive). #291 first marked only a row kept
+     * out of a live turn's window; #814 marks a message stored as it arrived
+     * too, and this carries that. The wider mark drops no wake wrongly:
+     * rowDone drops one only once an answered request's mark covers the row,
+     * by its place in the agent's window (covers), so a request that never
+     * carried the row keeps its wake. A resumed turn (a context-budget
+     * restart, or a tool-result guard's retry a provider held) presents
+     * nothing that arrived meanwhile (the presentation's afterStore counts
+     * its turn alive), so its request doesn't carry such a row, and the row's
+     * wake still starts a turn after it. Another agent's wake stays plain, and
+     * so does one for a write kept in memory (a surgery's hold, or
+     * heldForRecovery), which has no id yet.
+     */
+    private readsRowFor;
+    /** A module's id as the store knows it: a stored id as it is, and an
+     *  earlier release's `held:` handle as the row its write landed as, or
+     *  the handle itself, which the store doesn't hold, when it never landed. */
+    private storedIdOf;
     private editMessage;
     private removeMessage;
     private getMessage;
@@ -5749,10 +6724,38 @@ export declare class AgentFramework {
      *  so. */
     private unknownAgentError;
     /** A module's query (ModuleContext.queryMessages): the delivery agent's
-     *  window (the primary's, or the first agent's when none is primary), or
+     *  store (the primary's, or the first agent's when none is primary), or
      *  the named agent's, which must be registered: an unknown name, or the
-     *  empty one, throws, naming the registered ones, as a write's does. */
+     *  empty one, throws, naming the registered ones, as a write's does. The
+     *  rows come in store order, each marked `held` where it isn't in that
+     *  agent's window (#291: stored and not yet presented to it, or taken out
+     *  of it as an undone turn's), and the count is the store's. */
     private queryMessages;
+    /** A module's window lookup (ModuleContext.windowStatusOf, #291): where
+     *  a row stands with the delivery agent's window, or the named agent's,
+     *  which must be registered, as for a query: an unknown name, or the
+     *  empty one, throws, naming the registered ones. */
+    private windowStatusFor;
+    /** Whether `observer` reads `observed`'s own rows through an observe edge
+     *  (ModuleContext.observes, #291), as the presentation index reads its
+     *  edges (observesOwnRows). */
+    private observesOwnRowsOf;
+    /**
+     * A module's view lookup (ModuleContext.viewKeeps, #291): whether the
+     * delivery agent's view, or the named agent's, which must be registered,
+     * as for windowStatusFor, keeps a row, so its requests carry it, as its
+     * strategy renders it (a row it has folded, as that summary), while its
+     * window holds it. The view is the one its context was opened with, as
+     * recorded for it (agentSees, main's #853: liveViewFilterOf's choice,
+     * through the agent a shared derivation's view came from): a resident's
+     * leaves out held traffic, the other agents' stored context injections
+     * and what a suppress rule hid, the subconscious's those injections and
+     * suppressed rows, and an agent opened with no view keeps every row. An agent the registry has no
+     * record of is read through a resident's view, the one that keeps least.
+     */
+    private viewKeepsFor;
+    /** The live agent whose context a context manager is (ModuleContext.agentNameOf, #291), or undefined. */
+    private agentNameOfContext;
     private createFrameworkState;
     private emitTrace;
     /**
@@ -5828,6 +6831,17 @@ export declare class AgentFramework {
      * `roundContent` to vouch for ends noting instead, as a round's does.
      */
     private noteStreamEnd;
+    /**
+     * A row an agent's window holds, by its id, from whichever slot its
+     * manager merges: getMessage reads the manager's own slot alone, and the
+     * subconscious hears the residents' rows at its tool boundary from the slot
+     * it watches (#291). Null in legacy mode, where nothing is heard from
+     * another slot, and for a row the window doesn't hold; null too where the
+     * window can't be read, which is logged naming `agentName` and the row,
+     * so a note that then records the row as not stored can be told from one
+     * whose row is absent.
+     */
+    private windowRowOf;
     /**
      * Every row so far, judged as of now (roundRows), noted. A note the context manager writes nothing for (false)
      * ends the stream's notes, with a line saying so: where the stream's compile no longer wrote the branch's record, or
@@ -6475,10 +7489,7 @@ export declare class AgentFramework {
      * every other wake.
      */
     private wireModernEvents;
-    /** An MCP tool call's trace: a result the server marked an error (or one
-     *  the reading takes as one, such as malformed content) is tool:failed, as
-     *  on the other tool paths; anything else is tool:completed. */
-    private traceMcpToolOutcome;
+    private traceToolOutcome;
     /**
      * Discover tools from all connected MCPL servers and cache them.
      * Tools are namespaced as `{toolPrefix}--{toolName}` per server config.
@@ -6565,6 +7576,35 @@ export declare class AgentFramework {
      * and what's nested in them at any depth (shownToScriptFromServer).
      */
     private mcpToolResult;
+    /** Whether any tune-out is on record: a channel's, or the all-except scope. */
+    private tuneOutOnRecord;
+    /** The tune-out coordinator over this framework's channels, with the hooks it acts through. */
+    private makeTuneOutCoordinator;
+    /**
+     * Whether a tune-out's release would be kept in memory now, not stored:
+     * a release made while a surgery's hold keeps writes in memory, or while
+     * the primary's or the subconscious's manager refuses its work, would be
+     * kept there too, and lost to a crash before it is stored, while the
+     * epoch's end is on disk at once. The coordinator's cancel waits for them
+     * then (its writesHeld; releaseSurgeryHeldWrites runs it), and so does a
+     * release of the holds on record with no reader
+     * (releaseTuneOutsWithoutReader). With `forAgent` (a loss notice's
+     * author), 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 hold
+     * their own agent's writes alone.
+     */
+    private tuneOutWritesHeld;
+    /**
+     * No reader is configured, so nothing can watch or end a hold: each hold
+     * on record (one 0.32's `tuneOut.enabled` left, or one whose reader the
+     * recipe no longer has) ends now, and its backlog goes to the resident,
+     * the per-channel holds and the all-except scope alike, through a
+     * coordinator made for that alone: at a start, or, where no MCPL server
+     * was configured, when the first one connects. One whose release fails
+     * stays on record for the next start.
+     */
+    private releaseTuneOutsWithoutReader;
     /**
      * A tune-out on record where this host has no tune-out coordinator: a
      * start with no subconscious makes none, and neither does a channel
@@ -6576,8 +7616,10 @@ export declare class AgentFramework {
      * open again as a cancel leaves it, under the tune-out's own source, so an
      * agent's tune-out keeps the agent's provenance (the housekeeping guard
      * reads it). A log line names the channel and says how many of the
-     * messages it diverted are held here, stored or still queued to be
-     * written, which nothing will now deliver as its backlog.
+     * messages it diverted are stored here, which nothing will now deliver as
+     * its backlog. Where no reader is configured, releaseTuneOutsWithoutReader
+     * ends them instead, backlog delivered; this is only the late-connect path
+     * of a host that has a reader.
      */
     private endTuneOutsWithoutCoordinator;
     /**
@@ -6587,6 +7629,15 @@ export declare class AgentFramework {
      * Dispatch a synthesized channel tool call.
      */
     private dispatchChannelToolCall;
+    /**
+     * `wake_accept_suggestions` / `wake_decline`: the agent's answer to a wake
+     * onboarding offer. Accepting writes the chosen suggestions as
+     * `suggested:<server>:<n>` rules (replacing any it accepted before) ahead of
+     * the first catch-all; declining removes them. Either way the decision is
+     * recorded against the server's declared ontology, so it isn't asked again
+     * until that changes. Throws only what the gate throws on a write.
+     */
+    private answerWakeOnboarding;
     /**
      * Handle the synthesized `wake_add_rule` / `wake_remove_rule` tools: mutate
      * the hot-reloaded gate.json at runtime. Validation lives in the EventGate
@@ -6635,7 +7686,102 @@ export declare class AgentFramework {
      * framework's policy inputs (recipients, the hold in force, the wake
      * gate), traced. Callers apply it; nothing downstream re-asks.
      */
+    /**
+     * The suppressed rows stored in an agent's message slot (the primary's when
+     * none is named), oldest first, whole: what dump_suppressed writes and the
+     * suppression review reads, for a host to read too. Within `sinceMs` (at or
+     * after) and `untilMs` (before), and of `rule`, when given. The slot is read
+     * on the branch it's on; a write a surgery's hold, or the wait for its
+     * agent's recovery, keeps in memory isn't in it until it is stored.
+     */
+    suppressedEvents(agentName?: string, opts?: {
+        rule?: string;
+        sinceMs?: number;
+        untilMs?: number;
+    }): SuppressedEventRecord[];
+    /** Run the suppression review now, as its timer would: null when none is wired or one isn't run now (SuppressionReview.runOnce). */
+    reviewSuppression(): Promise<SuppressionReviewSummary | null>;
+    /** The suppress rules in force, as the suppression review knows them. */
+    private suppressRulesInForce;
+    /**
+     * Tell the agent what the suppression review found: a notice of the
+     * framework's own (never suppressed, as it's no event), and a wake when the
+     * review flagged something. Throws when the notice can't be written, so the
+     * review covers its period again next time.
+     */
+    private deliverSuppressionReview;
+    /**
+     * Whether `agent`'s view leaves suppressed rows out, asked of the view
+     * itself (storeSees): every resident's, the subconscious's and a view
+     * derived from one does; an isolated agent's own store has no view filter,
+     * so a row stamped there would render.
+     */
+    private viewHidesSuppressed;
+    /**
+     * The suppress rule that takes an event a lane is about to write with
+     * addMessage, or null (EventGate.decideSuppression: asked once per event,
+     * since a windowed rule opens its window for an event it lets by). Null
+     * with no gate, and where the write would land in a view that doesn't hide
+     * suppressed rows (viewHidesSuppressed), since the stamp would hide
+     * nothing there.
+     */
+    private suppressionFor;
+    /**
+     * Count a write a suppress rule took, once addMessage has taken it (stored,
+     * or kept in memory by a surgery's hold) (EventGate.noteSuppressed), and tell the review
+     * the rule's description as it stands now, so the rows are judged against
+     * it even when the rule is gone by the next review.
+     */
+    private noteSuppressedWrite;
     private admitInbound;
+    /**
+     * Wake onboarding, after an inbound event is stored: if the gate let it go
+     * by without anyone having decided about its server (gate/wake-onboarding.ts
+     * isUndecided), and the agent hasn't been offered or answered for this
+     * server's declared ontology, offer the server's suggestions once — a notice
+     * after the event, and a wake when the event is addressed to the agent or
+     * waiting on it (ATTENTION_TAGS); otherwise the notice waits for the next
+     * turn. Never throws: onboarding is advice, and an event's delivery must not
+     * depend on it.
+     *
+     * The notice is for the agents the event was delivered to (#291's audience
+     * stamp): the event's recipients, as its row's stamp names them
+     * (inboundAudience), so it reads as following "the one above" only where
+     * that one is, and a co-resident the event wasn't for is neither shown it
+     * nor woken by it. It is stored where a write that names no agent is for
+     * those of them that read that slot (readersNamed), stamped for them; a
+     * recipient that doesn't read it (a conversation fork, on its own slot)
+     * gets its own copy where it reads (`forAgent`), stamped for it, so a
+     * recipient is woken to a notice it is shown and no one else is shown it
+     * but an agent observing that slot (the persistent subconscious).
+     * Mixed recipients get it in both places, once each. An event with no
+     * recipients is for the residents that take untargeted messages, as
+     * before. It goes through addMessage, which stores it at once and
+     * presents it to each of them at rest or at their next point, as it does
+     * the event. The wake of the agent its write's placement names reads the
+     * row (readsRowFor): the delivery agent, or, where the stamp doesn't name
+     * it, a recipient whose own slot that is (placementReaders); and so does
+     * a fork's for its own copy. A co-resident's wake beside the delivery
+     * agent stays plain, as the event's own does.
+     */
+    private considerWakeOnboarding;
+    /** The last offer built per server, kept while its enabled declarations are the same objects. */
+    private wakeOfferCache;
+    /**
+     * A server's offer from the feature sets this host enabled for it (events
+     * of the others never arrive, and their ontology isn't the question).
+     */
+    private wakeOffer;
+    /** The onboarding notice: what happened, what the server suggests, how to answer. Server-written text is quoted. */
+    private wakeOnboardingText;
+    private describeOfferedRule;
+    /**
+     * Make delivered messages durable now, and answer whether they are: a
+     * tune-out's cancel stores its release and syncs it before it records the
+     * epoch's end (#232 gap 6), and a sync that fails answers false, so the
+     * cancel leaves the tune-out in force for its next try. A dump a surgery's
+     * hold keeps is in memory until the hold's release.
+     */
     private commitDeliveries;
     /** The history-reading tool the primary resident actually has, if any (#232 gap 11). */
     private residentHistoryTool;
@@ -6688,11 +7834,23 @@ export declare class AgentFramework {
     private buildEventTagsResult;
     private dispatchEventTagsToolCall;
     private dispatchGateToolCall;
+    /**
+     * suppression_stats: what the suppress rules have hidden, counted over the
+     * rows stored in the caller's message slot (the residents' shared one, for
+     * a resident), on the branch it's on. Every suppress rule in force is
+     * listed, with what it suppressed since start (the gate's matchCount).
+     */
+    private dispatchSuppressionStatsToolCall;
+    /**
+     * dump_suppressed: the suppressed rows in the caller's message slot
+     * (suppressedEvents), whole, written to a workspace file as the caller's own
+     * write.
+     */
+    private dispatchDumpSuppressedToolCall;
     /** The channel context one server is told for an agent's inference
      *  (context/beforeInference, §14.4): only that server's own channels
      *  (ChannelRegistry.buildChannelContext). */
     private channelsForServer;
     private buildBeforeInferenceParams;
 }
-export {};
 //# sourceMappingURL=framework.d.ts.map