@cello-protocol/daemon 0.0.196 → 0.0.197

package/dist/session-node-manager.d.ts

@@ -21,27 +21,29 @@ import { type CapacityReason } from "./refusal-reasons.js";
 import { type SaltAgreementFrame } from "./session-salt-agreement.js";
 import { type DaemonDatabase } from "./sqlcipher-db.js";
 import { type RefusalKind } from "./refusal-reasons.js";
-import type { Stream } from "@libp2p/interface";
-import type { Logger, SessionRecord, SealReadinessView } from "./types.js";
+import type { Logger, SessionRecord } from "./types.js";
 import { SessionTree, type WritableSessionTreeLeafKind } from "./session-tree.js";
 import { type CelloNode, type IAutoNatService } from "@cello-protocol/transport";
 import type { KeyProvider } from "@cello-protocol/crypto";
 import { type SessionEphemeral } from "@cello-protocol/crypto";
 import { type ParkEnvelope } from "./park-envelope.js";
 import { AgentRelayClient, type RelayAuthRefusal, type RelayWitnessAlert } from "./session-relay-client.js";
-import { RelayReceiptStore, type RelayReceipt } from "./relay-receipt-store.js";
-import { SessionSealLeafStore, type SealCarryLeaf } from "./session-seal-leaf-store.js";
+import { SessionContentSender } from "./session-content-send.js";
+import { SessionContentIngest } from "./session-content-ingest.js";
+import { SessionSeal } from "./session-seal.js";
+import { SessionRelay } from "./session-relay.js";
+import { SessionLifecycle } from "./session-lifecycle.js";
+import { RelayReceiptStore } from "./relay-receipt-store.js";
+import { SessionSealLeafStore } from "./session-seal-leaf-store.js";
 import { SessionOwnChainStore } from "./session-own-chain-store.js";
-import type { SealUpgradeReadiness } from "./seal-upgrade.js";
 import type { SealFrontierLeaf } from "./seal-frontier-verify.js";
-import { type QuarantineFrameMeta } from "./quarantine-framing.js";
 import { type SecurityGatewayClient } from "@cello-protocol/gateway";
 /**
  * One row in an agent's witness-alert list — DOD-M15-CORROBORATE-1 review F1. Deduped on
  * `(witness relay, session)`, so a repeated observation raises `occurrences` rather than taking
  * another slot in a bounded list.
  */
-import { type AbandonNoticeResult, type CreateSessionResult, type ISessionNodeFactory, type ParkedDrainReason, type QuarantinedRecord, type ReceivedContentEntry, type RefusalNotice, type RelayConnectParams, type SentAuthorship, type SessionImpairment, type TranscriptEntry, type WitnessAlertNotice } from "./session-node-types.js";
+import { type ISessionNodeFactory, type ParkedDrainReason, type QuarantinedRecord, type RefusalNotice, type SessionImpairment, type TranscriptEntry, type WitnessAlertNotice } from "./session-node-types.js";
 export { ABUSE_MAX_SESSIONS_PER_UNKNOWN_SENDER, ABUSE_MAX_SESSION_RECEIVED_BYTES, ABUSE_MAX_UNKNOWN_SESSIONS_GLOBAL, type AbandonNoticeResult, type AckHashReason, CAP_INTERRUPTED_TTL_MS, type ISessionNodeFactory, LEAF_FETCH_GRACE_MS, MAX_TERMINAL_REFUSALS_PER_SESSION, type ParkedDrainReason, type QuarantinedRecord, RELAY_QUARANTINE_MS, REVIVAL_BOUND_SWEEP_MS, REVIVAL_WINDOW_MS, REVIVE_RESERVATION_CANDIDATES, REVIVE_RESERVATION_TIMEOUT_MS, type RefusalNotice, type RelayConnectParams, SR_RESERVATION_MAX_RETRIES, type SentAuthorship, type SessionImpairment, type SessionNodeConfig, TERMINAL_REFUSAL_READ_RETRY_MS, TERMINAL_REFUSAL_REASONS, type TranscriptEntry, type WitnessAlertNotice, } from "./session-node-types.js";
 export declare class SessionNodeManager {
     #private;
@@ -199,6 +201,21 @@ export declare class SessionNodeManager {
     wasSessionRefused(agentName: string, sessionId: string): boolean;
     countReceivedMessages(agentName: string, sessionId: string): number;
     markInterruptedByCounterpartyForTest(agentName: string, sessionId: string): void;
+    /**
+     * M7-SESSION-004 (AC-005): persist the seal certificate's legibility object with the
+     * sealed record. Stored as a JSON string (hex-encoded pubkeys) so it round-trips a
+     * daemon restart and is returned intact on the cert-read surface. The caller normalises
+     * the raw wire legibility (Uint8Array pubkeys) into a JSON-safe shape before storing.
+     * Best-effort: a session row may not yet exist (the seal arrived before the row was
+     * persisted); in that case we no-op rather than throw — the cert still flows through the
+     * live return path. The legibility content is identical regardless of delivery timing.
+     *
+     * ⚠️ THIS BLOCK WAS STRANDED WHEN THE METHOD BECAME A DELEGATOR. It stayed behind and ended up
+     * stacked on top of `markSealed`'s own doc block, so that method showed two descriptions and the
+     * first one described a different method entirely — and the seal split then carried it into
+     * `session-seal.ts`, where `recordSealCertificate` does not appear at all. Returned to the call
+     * it describes. The row-writing itself lives in `session-queries.ts`.
+     */
     recordSealCertificate(agentName: string, sessionId: string, sealedRootHex: string, legibilityJson: string): void;
     recordCounterpartyPrimary(agentName: string, sessionId: string, primaryPubkeyHex: string): void;
     /**
@@ -435,76 +452,6 @@ export declare class SessionNodeManager {
      * encrypted DB file.
      */
     getDb(): DaemonDatabase;
-    /**
-     * RELAYSIG-1: the durably-stored, signature-verified relay ordering-record receipts for an agent
-     * (optionally a single session). Empty when no receipts have been recorded yet. Read-only.
-     */
-    getRelayReceipts(agentPubkeyHex: string, sessionIdHex?: string): RelayReceipt[];
-    /**
-     * FED-OPTIONB-SEAL-001: the complete ordered leaf chain (both parties) a UNILATERAL seal carries to the
-     * directory for the OFFLINE tree rebuild. Empty when no leaves were logged (e.g. a direct-only session
-     * with no relay witness) — the caller then has nothing to carry and the seal stays bilateral/pending.
-     */
-    /**
-     * REBUILD THE CERTIFIED ROOT FROM THIS DAEMON'S OWN LEAVES — `DOD-M15-SEALWIRE-1` bullet 2.
-     *
-     * The receipt used to prove only that the directory signed SOMETHING: the client took the sealed
-     * root off the wire, confirmed the directory's signature over those bytes, stored it, and threw
-     * away the root it had computed a step earlier. At co-signing time that means **your key signs a
-     * root you never checked.**
-     *
-     * Bullet 1 moved the certified root into the content-hash domain, which is the domain this daemon
-     * can actually rebuild — each carry leaf's `content_hash` is the leaf hash (RFC 6962 §2.1 "hash"
-     * leaves are used as-is), and the carry is ordered by the relay's canonical `sequence_number`,
-     * which is the order the directory rebuilds in.
-     *
-     * ─── Why this returns "cannot judge" instead of always answering ───────────────────────────
-     *
-     * A root comparison that is WRONG makes every session unsealable, and force-abandon — no receipt —
-     * becomes the only exit. That failure is worse than the one being guarded, and this file already
-     * carries two comments saying so about other gates.
-     *
-     * The carry is this daemon's view, and it is not guaranteed complete at the instant a certificate
-     * arrives: the counterparty's SEAL ctrl leaf is what TRIGGERS the seal, so it may not have been
-     * witnessed here yet. So completeness is checked FIRST, against the certificate's own leaf count.
-     * A short carry means this daemon cannot judge — which is a different answer from "the roots
-     * disagree", and conflating them would turn a local timing gap into an accusation.
-     */
-    verifyCertifiedRoot(agentPubkeyHex: string, sessionIdHex: string, certifiedRoot: Uint8Array, certifiedLeafCount: number): {
-        verdict: "match";
-    } | {
-        verdict: "mismatch";
-        ownRootHex: string | null;
-        detail: string;
-    } | {
-        verdict: "cannot_judge";
-        reason: string;
-    };
-    /**
-     * WHERE THE MUTUALLY-SIGNED PREFIX ENDS, DERIVED FROM THIS DAEMON'S OWN LEAVES —
-     * `DOD-M15-UNILATERAL-1`, review F2.
-     *
-     * ⚠️ **THE FIRST VERSION COMPUTED THIS FROM THE CERTIFICATE'S OWN PARTICIPANT LIST, AND CALLED
-     * THAT "recomputed, cannot be steered".** It could be steered. On the SOLO path the certificate's
-     * TBS binds no legibility at all, and the client verifies only the *live* party's frontier — so
-     * the absent party's `content_frontier_seq` and every `last_authored_seq` arrived unchecked. One
-     * directory node could publish the absent party's frontier as 3 and the receipt would say
-     * "mutually signed through 3" over a transcript that party never signed for. That is the precise
-     * conflation this field exists to prevent, reintroduced by the field itself.
-     *
-     * The carry answers it without trusting anybody. This daemon holds the counterparty's own leaves,
-     * each carrying, inside the bytes THEY signed, both the sequence they authored and the
-     * `last_seen_seq` they acknowledged. So a party's commitment reaches
-     * `max(highest sequence they authored, highest sequence they acknowledged)`, and the transcript is
-     * mutually signed only as far as the LEAST-committed party reaches.
-     *
-     * Fewer than two distinct authors ⇒ `0`: nobody countersigned anything, which is the honest floor
-     * for a conversation where the other side only ever received. `null` when the carry is empty or
-     * unreadable — the caller must then publish NO boundary rather than fall back to a number
-     * somebody else supplied.
-     */
-    countersignedThroughSeqFromCarry(agentPubkeyHex: string, sessionIdHex: string): number | null;
-    getSealCarry(agentPubkeyHex: string, sessionIdHex: string): SealCarryLeaf[];
     /** DOD-TIER-4: the DISPLAY/relationship check — is this counterparty a genuine contact (KNOWN or
      *  above)? Replaces the old binary `isContact` for behaviour that keyed on "we have a relationship"
      *  (e.g. the away-response wording). An UNKNOWN-tier contact (a mere row) is NOT known. */
@@ -520,22 +467,6 @@ export declare class SessionNodeManager {
      *  four-level resolution TOTAL. A pure read; the resolved text is screened on the outbound path by
      *  the caller like any content (SI — it does not bypass the gateway). */
     resolveAwayMessage(agentName: string, pubkey: string): string | null;
-    /**
-     * DOD-M15-REFUSEDEVIDENCE-1 — retain a message refused OUTSIDE `ingestReceivedContent`.
-     *
-     * Review F6. The park drain terminally-blocks a message that arrived for an already-committed
-     * session, then confirm-deletes the relay copy — the one other route in the tree that discarded
-     * refused content, and the highest-suspicion combination in the product: hostile bytes aimed at a
-     * conversation somebody has already sealed. Shipped guidance now tells every operator that
-     * refused messages are kept, so this is made true rather than the promise narrowed.
-     *
-     * A thin delegate, not a second implementation: the bound, the dedup, the sequence allocation and
-     * the logging are the ones every other refusal uses.
-     */
-    quarantineRefusedInbound(agentName: string, sessionId: string, reason: string, content: Uint8Array, contentHashHex: string, senderPubkeyHex: string | null, correlationId?: string): number | null;
-    /** The metadata half of a framed quarantine read — everything known ABOUT the message, none of it
-     *  taken from the message. Split out so the framing module never touches the database. */
-    quarantineFrameMeta(agentName: string, sessionId: string, rec: QuarantinedRecord): QuarantineFrameMeta;
     /** M8C-ABUSE-1 + DOD-TIER-2/3: is a NEW inbound session from this counterparty within the
      *  acceptance bounds? The per-sender cap is now the sender's TIER cap (DEFAULT_TIER_BOUNDS), not a
      *  flat "3 for strangers, unbounded for contacts". This is where DOD-TIER-3 falls out for free: a
@@ -550,43 +481,11 @@ export declare class SessionNodeManager {
         ok: false;
         reason: CapacityReason;
     };
-    /**
-     * The current standing receiver node's session-transport coordinates (peer id +
-     * listen multiaddrs), or null if it is not ready. These are the addresses a local
-     * SessionNegotiator advertises as this node's counterparty endpoint so the initiator
-     * can dial it, and the value an inbound session_assignment carries in its
-     * counterparty_session_* fields. Read-only — does NOT consume the standing receiver
-     * (unlike acceptSession, which hands it off).
-     */
-    /**
-     * 032-RELAYSPREAD — would this receiver ADMIT an inbound dial from this relay?
-     *
-     * The gater's inbound carve-out is the security-sensitive half of the spread: only relays whose
-     * own reservation is confirmed held earn it, so a directory that merely NAMES a relay cannot dial
-     * in behind the gate. Nothing could observe that from outside the manager, and the review found
-     * the consequence: substituting the CANDIDATE list for the held list at the `setReservedRelayPeers`
-     * call kept every test in the unit green while shipping exactly that hole. A guard whose wiring
-     * cannot be observed is a guard nothing can test.
-     *
-     * Reads the live gater rather than a copy, so it cannot drift from what the gate actually does.
-     */
-    isRelayCarvedOutInbound(agentName: string, relayPeerId: string): boolean;
-    /**
-     * The libp2p Peer ID of an active session's node (N_A for an initiated session), or
-     * null if no active node exists for it. This is the initiator's session peer id that an
-     * inbound session_assignment must carry to the counterparty (so the counterparty gates
-     * its handed-off receiver to it). Read-only.
-     */
-    getSessionNodePeerId(agentName: string, sessionId: string): string | null;
     /**
      * M7-SESSION-001 (M-1 PUSH): register the session-state-change callback.
      * Called by the composition root (daemon.ts) after the NotificationDispatcher
      * exists. Setter injection avoids a construction-order/circular dependency.
      */
-    /** Fix #1 EXTENSION: inject the broker-connection opener. Setter injection, same construction-order reason. */
-    setEnsureSealBroker(cb: (agentName: string, sessionId: string) => Promise<{
-        stop: (reason: string) => Promise<void>;
-    } | null>): void;
     setOnSessionStateChanged(cb: (agentName: string, sessionId: string, state: string, counterpartyPubkey: string | null) => void): void;
     /**
      * M8C-MSGWAKE-1: inject the content-arrival callback (daemon.ts → NotificationDispatcher.
@@ -607,17 +506,6 @@ export declare class SessionNodeManager {
      * an unresolvable name — see #requireAgentId for why null is not an option.
      */
     resolveAgentId(agentName: string): string;
-    /**
-     * Create a new outbound session node.
-     * Called during cello_initiate_session.
-     *
-     * @param sessionId      Unique session ID (hex string)
-     * @param agentName      Name of the initiating agent
-     * @param counterpartyPubkey  Counterparty's K_local public key (hex)
-     * @param counterpartyPeerId  Counterparty's session-layer Peer ID (for gater)
-     * @param correlationId  Correlation ID minted at session initiation
-     */
-    createSessionNode(sessionId: string, agentName: string, counterpartyPubkey: string, counterpartyPeerId: string, correlationId: string, reuseStandingReceiver?: boolean, relay?: RelayConnectParams): Promise<CreateSessionResult>;
     /**
      * DOD-M12B-ACK-1 — live `/cello/content/1.0.0` stream counts on a session's direct path, or null
      * when the session has no active node.
@@ -631,40 +519,6 @@ export declare class SessionNodeManager {
         inbound: number;
         outbound: number;
     } | null;
-    /**
-     * DOD-M12B-ABANDON-NOTIFY-1 — drive the REAL inbound content handler with one framed message and
-     * a claimed peer identity.
-     *
-     * The handler is registered on a live libp2p node, so without this the only way to reach its
-     * branches is a full two-node transport fixture — which is why the session-abandoned branch and
-     * its peer pinning had no coverage at all. This feeds the same function the protocol handler
-     * calls, including the authentication check, rather than a copy of its logic.
-     */
-    handleContentFrameForTest(agentName: string, sessionId: string, framedBytes: Uint8Array, remotePeerId?: string): Promise<void>;
-    /**
-     * Hand the standing receiver to an inbound session.
-     * Called during cello_await_session.
-     *
-     * CRITICAL (AC-015): gater.setAllowedPeer() is called BEFORE returning
-     * the node's multiaddr to the caller. This closes the window where an
-     * unexpected peer could connect during the hand-off.
-     */
-    acceptSession(sessionId: string, agentName: string, counterpartyPubkey: string, initiatorPeerId: string, correlationId: string, relay?: RelayConnectParams): Promise<CreateSessionResult>;
-    /**
-     * Destroy a session node after seal or on error teardown.
-     * Status written to SQLite.
-     */
-    destroySessionNode(agentName: string, sessionId: string, reason: "sealed" | "interrupted" | "error"): Promise<void>;
-    /**
-     * round-2 finding #5: retire a session's live libp2p node WITHOUT changing its
-     * DB status. Used after the active-session bilateral seal commitment has already
-     * advanced the row to 'seal_interrupted_pending': the session is frozen, so we
-     * stop the node and unregister its /cello/content handler (no more inbound leaves,
-     * no leaked node per active close) but must NOT overwrite the pending/sealed status
-     * the way destroySessionNode would. The durable tree stays in SQLite (getSessionTree
-     * reloads it); the in-memory plaintext buffer is evicted.
-     */
-    retireSessionNode(agentName: string, sessionId: string): Promise<void>;
     gracefulShutdown(): Promise<void>;
     /**
      * DOD-M12B-REVIVAL-BOUND-1 — close every session the revival window has expired.
@@ -687,88 +541,46 @@ export declare class SessionNodeManager {
      * cello_list_sessions). Classification + filtering + the count limit are applied by the caller.
      */
     getAllSessions(): SessionRecord[];
-    /**
-     * M7-SESSION-004 (AC-005): persist the seal certificate's legibility object with the
-     * sealed record. Stored as a JSON string (hex-encoded pubkeys) so it round-trips a
-     * daemon restart and is returned intact on the cert-read surface. The caller normalises
-     * the raw wire legibility (Uint8Array pubkeys) into a JSON-safe shape before storing.
-     * Best-effort: a session row may not yet exist (the seal arrived before the row was
-     * persisted); in that case we no-op rather than throw — the cert still flows through the
-     * live return path. The legibility content is identical regardless of delivery timing.
-     */
-    /**
-     * DOD-M12B-INTERRUPTED-ESCALATE-1 — flip a session to `sealed`, synchronously, without needing a
-     * live node.
-     *
-     * **`destroySessionNode(…, "sealed")` cannot be relied on to do this.** It returns early at
-     * `if (!entry) return`, and the status write lives 26 lines BELOW that guard — so it flips the
-     * status only for a session that still has an `#activeNodes` entry. An interrupted session has
-     * none by construction: every producer of that status deletes the entry. Before this method, a
-     * unilateral seal on an interrupted session stored the notarized root and the certificate and
-     * left the row saying `interrupted` — the receipt landed and nothing that represents it moved.
-     * `cello_sessions` still showed it stuck, `cello_close_session` still refused it by name, and the
-     * restart-seal resolver re-selected it on the next boot to run the whole ceremony again against a
-     * session that already held a receipt.
-     *
-     * STATUS FIRST AND SYNCHRONOUS, teardown second — the order `abandonSession` uses and the one
-     * `retireSession` documents. The flip is the load-bearing half; the teardown makes memory agree
-     * with it. `#updateSessionStatus` also runs the terminal disposition hooks (held content is
-     * annexed, not stranded), which the early return skipped entirely.
-     */
-    markSealed(agentName: string, sessionId: string): boolean;
-    /**
-     * M8B FINDING-6 (cascade-2): persist a seal certificate for a session that may have NO local
-     * `sessions` row. recordSealCertificate above is an `UPDATE ... WHERE` — a SILENT no-op when the
-     * row is absent (the exact trap the cascade-2 reviewer flagged). The ABSENT party (B), learning of
-     * a seal on reconnect via seal_unilateral_notification, may never have persisted a row for this
-     * session. This ensures a minimal stub row first (INSERT OR IGNORE — a no-op if a row already
-     * exists, e.g. an 'interrupted' row after a restart) so B's receipt is actually durable + retrievable
-     * via cello_get_sealed_receipt. The counterparty pubkey is required by the schema (NOT NULL); B
-     * derives it from the notification's present_pubkey.
-     */
-    recordSealCertificateEnsuringRow(agentName: string, sessionId: string, counterpartyPubkeyHex: string, sealedRootHex: string, legibilityJson: string): void;
-    /**
-     * M7-SESSION-001: Mark a session as interrupted with message count and timestamp.
-     * Called when a relay session_interrupted frame arrives or a relay stream closes.
-     * Also tears down the in-memory session node if one exists for this sessionId.
-     *
-     * @param sessionId The hex session ID from the relay frame
-     * @param messageCount Number of message leaves at interruption
-     * @param source 'relay_frame' | 'stream_close'
-     */
-    markInterruptedWithDetails(agentName: string, sessionId: string, messageCount: number, 
-    /**
-     * WHAT ACTUALLY HAPPENED, and it is written to the row — review F3.
-     *
-     * `key_refused` is its own source rather than a borrowed `stream_close`, because the row's
-     * `interrupted_by` is what an operator reads days later: labelling a key-authentication refusal
-     * `relay_stream_close` sends them to the relay fleet for a fault in the payload.
-     */
-    source: "relay_frame" | "stream_close" | "key_refused"): Promise<boolean>;
-    /**
-     * M7-SESSION-001 (H-1): persist a verified bilateral SEAL-INTERRUPTED
-     * commitment and transition the session to 'seal_interrupted_pending'.
-     *
-     * This is NOT a seal. It records that both parties produced and exchanged
-     * K_local-signed SEAL-INTERRUPTED leaves over the same {leafCount, merkleRoot}.
-     * The FROST threshold notarization is a separate, currently-unwired step (see
-     * daemon.ts handleSealInterruptedFlow H-1 note), which is precisely why the
-     * status is 'seal_interrupted_pending' and never 'sealed'.
-     *
-     * The status update is guarded so it only advances a session out of the
-     * 'interrupted' state — it will not overwrite a 'sealed' row.
-     *
-     * @returns true if the session row was advanced to seal_interrupted_pending.
-     */
-    persistSealInterruptedCommitment(opts: {
-        agentName: string;
-        sessionId: string;
-        role: "initiator" | "responder";
-        ownLeaf: unknown;
-        counterpartyLeaf: unknown;
-        merkleRoot: string;
-        nonce: string;
-    }): boolean;
+    createSessionNode(...args: Parameters<SessionLifecycle["createSessionNode"]>): ReturnType<SessionLifecycle["createSessionNode"]>;
+    acceptSession(...args: Parameters<SessionLifecycle["acceptSession"]>): ReturnType<SessionLifecycle["acceptSession"]>;
+    destroySessionNode(...args: Parameters<SessionLifecycle["destroySessionNode"]>): ReturnType<SessionLifecycle["destroySessionNode"]>;
+    retireSessionNode(...args: Parameters<SessionLifecycle["retireSessionNode"]>): ReturnType<SessionLifecycle["retireSessionNode"]>;
+    markInterruptedWithDetails(...args: Parameters<SessionLifecycle["markInterruptedWithDetails"]>): ReturnType<SessionLifecycle["markInterruptedWithDetails"]>;
+    connectToCounterparty(...args: Parameters<SessionLifecycle["connectToCounterparty"]>): ReturnType<SessionLifecycle["connectToCounterparty"]>;
+    notifyCounterpartyAbandon(...args: Parameters<SessionLifecycle["notifyCounterpartyAbandon"]>): ReturnType<SessionLifecycle["notifyCounterpartyAbandon"]>;
+    retireOnCounterpartyAbandon(...args: Parameters<SessionLifecycle["retireOnCounterpartyAbandon"]>): ReturnType<SessionLifecycle["retireOnCounterpartyAbandon"]>;
+    reviveSessionNode(...args: Parameters<SessionLifecycle["reviveSessionNode"]>): ReturnType<SessionLifecycle["reviveSessionNode"]>;
+    reviveIfNeededForSend(...args: Parameters<SessionLifecycle["reviveIfNeededForSend"]>): ReturnType<SessionLifecycle["reviveIfNeededForSend"]>;
+    reviveIfNeededForRead(...args: Parameters<SessionLifecycle["reviveIfNeededForRead"]>): ReturnType<SessionLifecycle["reviveIfNeededForRead"]>;
+    abandonSession(...args: Parameters<SessionLifecycle["abandonSession"]>): ReturnType<SessionLifecycle["abandonSession"]>;
+    getSessionNodePeerId(...args: Parameters<SessionLifecycle["getSessionNodePeerId"]>): ReturnType<SessionLifecycle["getSessionNodePeerId"]>;
+    setDirectoryRelayEndpoints(...args: Parameters<SessionRelay["setDirectoryRelayEndpoints"]>): ReturnType<SessionRelay["setDirectoryRelayEndpoints"]>;
+    registerRelayStream(...args: Parameters<SessionRelay["registerRelayStream"]>): ReturnType<SessionRelay["registerRelayStream"]>;
+    isRelayCarvedOutInbound(...args: Parameters<SessionRelay["isRelayCarvedOutInbound"]>): ReturnType<SessionRelay["isRelayCarvedOutInbound"]>;
+    isRelayQuarantined(...args: Parameters<SessionRelay["isRelayQuarantined"]>): ReturnType<SessionRelay["isRelayQuarantined"]>;
+    quarantineRefusedInbound(...args: Parameters<SessionRelay["quarantineRefusedInbound"]>): ReturnType<SessionRelay["quarantineRefusedInbound"]>;
+    quarantineFrameMeta(...args: Parameters<SessionRelay["quarantineFrameMeta"]>): ReturnType<SessionRelay["quarantineFrameMeta"]>;
+    getRelayReceipts(...args: Parameters<SessionRelay["getRelayReceipts"]>): ReturnType<SessionRelay["getRelayReceipts"]>;
+    patchRelayClientForTest(...args: Parameters<SessionRelay["patchRelayClientForTest"]>): ReturnType<SessionRelay["patchRelayClientForTest"]>;
+    getSessionRelayForTest(...args: Parameters<SessionRelay["getSessionRelayForTest"]>): ReturnType<SessionRelay["getSessionRelayForTest"]>;
+    submitSealLeaf(...args: Parameters<SessionSeal["submitSealLeaf"]>): ReturnType<SessionSeal["submitSealLeaf"]>;
+    sealReadiness(...args: Parameters<SessionSeal["sealReadiness"]>): ReturnType<SessionSeal["sealReadiness"]>;
+    sealReadinessView(...args: Parameters<SessionSeal["sealReadinessView"]>): ReturnType<SessionSeal["sealReadinessView"]>;
+    verifyCertifiedRoot(...args: Parameters<SessionSeal["verifyCertifiedRoot"]>): ReturnType<SessionSeal["verifyCertifiedRoot"]>;
+    getSealCarry(...args: Parameters<SessionSeal["getSealCarry"]>): ReturnType<SessionSeal["getSealCarry"]>;
+    markSealed(...args: Parameters<SessionSeal["markSealed"]>): ReturnType<SessionSeal["markSealed"]>;
+    recordSealCertificateEnsuringRow(...args: Parameters<SessionSeal["recordSealCertificateEnsuringRow"]>): ReturnType<SessionSeal["recordSealCertificateEnsuringRow"]>;
+    persistSealInterruptedCommitment(...args: Parameters<SessionSeal["persistSealInterruptedCommitment"]>): ReturnType<SessionSeal["persistSealInterruptedCommitment"]>;
+    getSealUpgradeReadiness(...args: Parameters<SessionSeal["getSealUpgradeReadiness"]>): ReturnType<SessionSeal["getSealUpgradeReadiness"]>;
+    countersignedThroughSeqFromCarry(...args: Parameters<SessionSeal["countersignedThroughSeqFromCarry"]>): ReturnType<SessionSeal["countersignedThroughSeqFromCarry"]>;
+    setEnsureSealBroker(...args: Parameters<SessionSeal["setEnsureSealBroker"]>): ReturnType<SessionSeal["setEnsureSealBroker"]>;
+    ingestReceivedContent(...args: Parameters<SessionContentIngest["ingestReceivedContent"]>): ReturnType<SessionContentIngest["ingestReceivedContent"]>;
+    sendContent(...args: Parameters<SessionContentSender["sendContent"]>): ReturnType<SessionContentSender["sendContent"]>;
+    placeOwnLeaf(...args: Parameters<SessionContentSender["placeOwnLeaf"]>): ReturnType<SessionContentSender["placeOwnLeaf"]>;
+    takeReceivedContent(...args: Parameters<SessionContentIngest["takeReceivedContent"]>): ReturnType<SessionContentIngest["takeReceivedContent"]>;
+    recordWitnessedSequence(...args: Parameters<SessionContentIngest["recordWitnessedSequence"]>): ReturnType<SessionContentIngest["recordWitnessedSequence"]>;
+    getUndeliverableSeqs(...args: Parameters<SessionContentIngest["getUndeliverableSeqs"]>): ReturnType<SessionContentIngest["getUndeliverableSeqs"]>;
+    handleContentFrameForTest(...args: Parameters<SessionContentIngest["handleContentFrameForTest"]>): ReturnType<SessionContentIngest["handleContentFrameForTest"]>;
     /** Loaded from SQLite on first access so it survives a restart (AC-007). NEVER null: an unknown session yields an EMPTY tree. */
     getSessionTree(agentName: string, sessionId: string): SessionTree;
     /** Current daemon-owned tree root for a session, as hex. */
@@ -783,319 +595,9 @@ export declare class SessionNodeManager {
         leafIndex: number;
         newRootHex: string;
     };
-    /**
-     * SEAM 1b (dialer ⇄ session-node reconciliation): dial the counterparty THROUGH
-     * this session's OWN node, so the session node N_A holds the connection its content
-     * newStream actually rides. TRANSPORT-001's transport selector dialed on a separate
-     * (composition-root) node whose connection N_A could not use — the per-session node
-     * must be the dialer. Direct mode only here (the default content path, Part 4 D-a);
-     * relay-circuit + dcutr strategy via N_A is a later seam. Tries each addr in turn;
-     * succeeds on the first connection, returns a named failure if none connect.
-     */
-    connectToCounterparty(agentName: string, sessionId: string, addrs: string[]): Promise<{
-        ok: true;
-    } | {
-        ok: false;
-        reason: string;
-        error: string;
-    }>;
-    /**
-     * Send content over the session node's direct P2P content stream.
-     * On a dead/missing stream this returns a NAMED, diagnosable failure — never a silent success
-     * (which desyncs the two sides). Do not swallow a send error here.
-     *
-     * SCOPE / findings #3 + #4 — what this send path does and does NOT do today:
-     *   - #4: it delivers the content over the direct /cello/content/1.0.0 P2P
-     *     stream only. It does NOT also submit a K_local-SIGNED content_hash leaf to
-     *     the RELAY on /cello/relay/1.0.0 (EARS behavior #1). That relay hash-submit
-     *     is MSG-001's scope; AC-001's "relay log shows a hash_submit" evidence is
-     *     produced once MSG-001 lands.
-     *   - #3: because there is no relay yet, the sequence number cello_send returns
-     *     is the LOCAL leaf index, not a relay-assigned canonical global sequence.
-     *     Each daemon appends leaves in its own LOCAL observation order, so two
-     *     daemons' roots agree only under perfectly ping-ponged traffic. Canonical
-     *     cross-process ordering (and thus AC-002 root agreement under concurrent
-     *     bidirectional traffic) requires the relay-assigned sequence from MSG-001.
-     */
-    sendContent(agentName: string, sessionId: string, content: Uint8Array, contentHash: Uint8Array, 
-    /**
-     * Required alongside the two below — every production caller already passes one, and an optional
-     * parameter in front of a required one is what TypeScript refuses. Making it explicit costs
-     * nothing and removes the last place a positional argument can silently shift.
-     */
-    correlationId: string | undefined, 
-    /**
-     * The DOMAIN this content belongs to, as the relay and the directory will see it. Defaults to
-     * MESSAGE so `cello_send` is unchanged; the document path passes 0x04/0x05. Not cosmetic — the
-     * directory computes `final_message` and `answered` from the witnessed kind, and both of its
-     * document exclusions were dead while every document leaf arrived here as a message.
-     *
-     * ⚠️ ALSO REQUIRED NOW, and for the same reason as `contentHashAlg` below — this parameter is the
-     * precedent, not a bystander. It defaulted to MESSAGE, the document adapter in `daemon.ts`
-     * silently dropped it, and the wire was wrong for a whole release: *"0.0.145 shipped the fix
-     * everywhere except here."* A default that matches the common case makes the omission invisible
-     * at every call site and at typecheck. Every caller states its kind now.
-     */
-    leafKind: number, 
-    /**
-     * `DOD-M15-SEALWIRE-1` part B2b — the algorithm `contentHash` was produced under, taken from
-     * `contentHashForSession` by the caller that computed the hash.
-     *
-     * Passed rather than re-derived HERE, deliberately: re-deriving would ask "how would this
-     * session hash something now?", and the answer can differ from how THIS message was actually
-     * hashed. A hash and its label must travel together or the peer refuses a message nobody touched.
-     *
-     * ⚠️ REQUIRED, NOT DEFAULTED — review B2b-1 F4, and the default is what made four mutants
-     * unfalsifiable. It was `= CONTENT_HASH_ALGS.SHA256`, which equals the only value in play today,
-     * so DROPPING THE ARGUMENT AT ANY OF THE FIVE HOPS produced byte-identical output and the whole
-     * 2,800-test daemon suite stayed green. Measured at all four send sites individually.
-     *
-     * A default that equals the current value makes every threading edit invisible until the value
-     * changes — and the day it changes, the dropped argument mislabels the message and every peer
-     * refuses it as a tamper. Required makes a dropped argument a TYPECHECK failure instead of a
-     * test question nobody can answer.
-     */
-    contentHashAlg: string): Promise<{
-        ok: true;
-        delivered: true;
-        sequenceNumber?: number;
-        authorship?: SentAuthorship;
-    } | {
-        ok: true;
-        delivered: false;
-        parked: true;
-        sequenceNumber?: number;
-        authorship?: SentAuthorship;
-    }
-    /**
-     * ⚠️ `authorship` RIDES THE FAILURE PATH TOO — review pass 2, and it is the same reasoning that
-     * already put `sequenceNumber` here.
-     *
-     * A DURABLY QUEUED message was witnessed and SIGNED before delivery was attempted; only the
-     * direct hand-off failed. Omitting the proof here meant every relay-degraded-but-alive send —
-     * the common case — wrote a transcript row indistinguishable from one the relay never saw, while
-     * the signature for it sat in scope and was discarded. The position survives a failed delivery
-     * for exactly this reason; so does the proof.
-     */
-     | {
-        ok: false;
-        reason: string;
-        error: string;
-        durable: boolean;
-        cause?: string;
-        guidance?: string;
-        sequenceNumber?: number;
-        authorship?: SentAuthorship;
-    }>;
-    /**
-     * M7 DOD-SPINE-7: submit THIS party's SEAL ctrl leaf (0x02) to the relay witness.
-     * Structure: content_hash = SHA-256(0x02 || encodeSealPayload({session_id, final_root,
-     * close_timestamp, "PENDING"})), where final_root is the daemon's OWN tree root. Two
-     * distinct-sender SEAL leaves in the relay's log trigger the relay's #maybeProcessSeal
-     * → directory processSeal (rebuild + verify the signed chain) → FROST notarization →
-     * session_sealed. Requires an active relay client; the caller falls back to the
-     * directory-mediated path when this returns relay_unavailable.
-     */
-    submitSealLeaf(agentName: string, sessionId: string, correlationId?: string): Promise<{
-        ok: true;
-        sequenceNumber: number;
-        reportedRootHex: string;
-    } | {
-        ok: false;
-        reason: string;
-        reportedRootHex?: string;
-        sequenceNumber?: number;
-    }>;
-    /**
-     * CELLO-M7-UPGRADE-001 (DOD-UP-1): readiness of a session for B to RATIFY a unilateral seal
-     * (the returning absent party). This is the SAME verifiability bar as the UP-2 auto-ack gate:
-     *
-     *  - `known`: the session exists locally with its content (B has a transcript to ratify). After a
-     *    restart B reloads it from SQLite, and autoRecoverForAgent re-pulls any parked content first.
-     *  - `tampered`: the content cross-check flagged a content_hash mismatch (#contentDesynced) — B
-     *    must NEVER ratify content it could not integrity-verify (the KERNEL refusal, AC-003).
-     *
-     * The directory separately verifies B's ack signature is genuine; B separately verifies the
-     * unilateral cert signature (R1 is authentic). NOTE: a full "B's frontier covers R1's tail"
-     * completeness check (the `desynced` reason) requires the deferred MSG-001-3b canonical-sequence
-     * reconciliation — same documented limitation as the UP-2 gate above.
-     */
-    getSealUpgradeReadiness(agentName: string, sessionId: string): SealUpgradeReadiness;
-    ingestReceivedContent(agentName: string, sessionId: string, content: Uint8Array, contentHash: Uint8Array, correlationId?: string, 
-    /**
-     * DOD-FRONTIER-STRAND-1 AC1: the relay-assigned canonical position for THIS message, taken from
-     * the verified ordering record by the caller. Passed EXPLICITLY rather than recovered from
-     * `#witnessedSeq`, because that map is keyed by content hash — so two byte-identical messages
-     * collapse in it before dedup is ever consulted, which is the whole defect. Absent when the
-     * session has no relay witness (relay-degraded): see the announced fallback below.
-     */
-    canonicalSeqIn?: number, 
-    /**
-     * DOD-M15-SEALWIRE-1 part B1 — the algorithm the SENDER named on the frame, verbatim.
-     *
-     * `undefined` means the frame carried no name, which is a peer that predates the field and is
-     * the one case we may safely assume `sha256` for. It is threaded through rather than read off
-     * the session, because whether a hash is salted is a fact about the FRAME and its sender, never
-     * about what this side happens to hold.
-     */
-    contentHashAlgIn?: string | null, 
-    /**
-     * DOD-M15-SEALWIRE-1 bullet 5: the VERIFIED authorship proof for this message, when the caller
-     * has one. The caller is the only place that has it — `#verifyAuthorshipClaim` verifies the
-     * signature the frame carries beside the sender's own signed bytes, against the key inside those
-     * bytes, and matches the signer to this session's counterparty. That result reaches here or
-     * nowhere.
-     *
-     * ⚠️ IT USED TO NAME `#recordFrameOrdering`, and that was accurate until
-     * `DOD-M15-AUTHORSHIP-ABSENT-1`: the signature arrived only inside the RELAY's Structure 2, so
-     * checking authorship needed a relay record. It does not now, and the old name sends a reader to
-     * a method that answers a different question. Rewritten, not deleted — that dependence is the
-     * defect the unit removed.
-     *
-     * Optional, because the PARK route ingests without it: recovered mail proves its sender by the
-     * mailbox envelope instead. The row records which it was, so absence is never silent.
-     */
-    verifiedAuthorship?: {
-        senderPubkey: Uint8Array;
-        senderSig: Uint8Array;
-    }, 
-    /**
-     * 024-ORPHANTRIAGE — the key whose signature VERIFIED on a frame we could not tie to a session.
-     *
-     * Read by the orphan branch below and NOWHERE ELSE. It exists because the daemon establishes,
-     * cryptographically, that the sender holds a private key — and then discarded that the instant
-     * the session lookup came back empty, leaving the operator advised to go and make contact with
-     * whoever sent a message for a conversation that does not exist.
-     *
-     * Absent on the park-recovery caller, which cannot reach the orphan branch at all:
-     * `authenticateParkedEntry` refuses `counterparty_unknown` from the same missing record first.
-     */
-    verifiedSignerUnmatched?: Uint8Array): Promise<{
-        ok: true;
-        leafIndex: number;
-        sequenceNumber: number;
-        held?: boolean;
-        appendedCount?: number;
-        screenedOut?: boolean;
-    } | {
-        ok: false;
-        reason: string;
-    }>;
-    /**
-     * DOD-MSG-4: record the relay-witnessed canonical sequence for a content hash. The relay is the
-     * ordering authority (Structure 2): it assigns each message a sequence from its hash and delivers
-     * B the (content_hash -> sequence) binding via leaf_deliver. The strict-in-order gate orders the
-     * transcript by THIS — never a sender-stamped field. Also advances the per-session high-water mark
-     * (the largest witnessed sequence) reserved for the future catch-up-before-live increment. Idempotent.
-     */
-    recordWitnessedSequence(agentName: string, sessionId: string, contentHashHex: string, sequenceNumber: number): void;
     /** DOD-M12B-LEAF-TRIGGERS-FETCH-1 test seams. */
     setLeafFetchGraceMsForTest(ms: number): void;
     markContentPresentForTest(agentName: string, sessionId: string, contentHashHex: string): void;
-    /**
-     * DOD-MSG-4: the relay's high-water canonical sequence for this session (largest witnessed leaf),
-     * or -1 if none. The relay is the ordering authority, so this is the outside view of how far the
-     * session has actually progressed — which is why it is the right input to a catch-up-before-live
-     * gate. Consumed by `sealReadiness` (M12-P14) for REPORTING only: the missing-leaf decision is made
-     * from `#witnessedSeq`, because this counts the relay's sequence space (which includes ctrl leaves)
-     * and the tree does not. Maintained by `recordWitnessedSequence`.
-     */
-    /**
-     * DOD-COATTEND-1 (review F2): leaf sequences whose plaintext failed to reach the transcript and
-     * are therefore undeliverable. Empty is the overwhelmingly normal case.
-     */
-    getUndeliverableSeqs(agentName: string, sessionId: string): readonly number[];
-    /**
-     * M12-P14: is this side's chain COMPLETE enough to be sealed?
-     *
-     * A seal is a bilateral signature over the same conversation, so a side that is missing a leaf
-     * cannot produce a signable one — the counterparty compares frontiers and refuses with
-     * `leaf_count_mismatch`. That refusal is correct and it is also terminal: there is no backfill
-     * request in the protocol, so the only exit is a force-abandon, which yields NO notarized receipt.
-     * Measured 2026-08-05 on two sessions that died exactly this way (initiator 2 leaves, responder 3).
-     *
-     * The cheap prevention is to notice BEFORE asking. Two local signals already exist and, until now,
-     * nothing read either of them at close time:
-     *  - `#highWaterSeq` — the largest canonical sequence the RELAY has witnessed for this session.
-     *    The relay is the ordering authority, so a high-water above our own frontier is proof that a
-     *    leaf exists which we have not appended. (Its own doc comment called it "reserved … NOT yet
-     *    consumed by the gate" — this is that consumer.)
-     *  - `#heldContent` — content we HAVE received and verified but cannot append because it sits
-     *    behind a gap. Holding content and sealing anyway would seal a chain we know is short.
-     *
-     * Deliberately NOT a network call: it must work when the counterparty is unreachable, which is
-     * the whole situation a seal-interrupted exists for.
-     *
-     * KNOWN LIMIT, stated rather than hidden: both maps are in-memory and cleared on teardown, so
-     * after a daemon restart this returns ready for a session whose gap predates the restart — which
-     * is the shape of the 2026-08-05 incident itself. Closing that needs the mailbox drained (or the
-     * high-water persisted) before the check; tracked with M12-P14, not claimed here.
-     */
-    sealReadiness(agentName: string, sessionId: string): {
-        ready: boolean;
-        treeSize: number;
-        highWaterSeq: number;
-        heldCount: number;
-        missingLeaves: number;
-        /** DOD-M12B-INDEX-1: of `heldCount`, how many are THIS side's own sends versus the
-         *  counterparty's. They block a seal identically and mean completely different things. */
-        heldOwn: number;
-        heldReceived: number;
-        /**
-         * DOD-M15-DIVERGE-1 — this tree and the relay's counter have PROVABLY parted.
-         *
-         * The other two counters both measure the same direction: positions the relay committed that
-         * this tree has not appended. This is the OPPOSITE direction — this tree holds a leaf at a
-         * position the relay assigned to something else — and it is the direction an injected or forged
-         * leaf appears in. Without it `ready` was asymmetric, and a diverged session read as perfectly
-         * sealable right up until the counterparty answered `leaf_count_mismatch`, which is terminal.
-         */
-        diverged: boolean;
-    };
-    /**
-     * DOD-M12B-SEAL-STUCK-1 — the operator-facing answer to "can this session be closed?".
-     *
-     * THREE STATES, because there are three answers. `sealReadiness` above returns a boolean plus raw
-     * counters, and both of its counters are easy to misread on a surface:
-     *
-     *  - `missingLeaves` is `#witnessedSeq.size`, which is every position the relay witnessed that
-     *    this tree has not appended — and a HELD frame keeps its witness entry. So it INCLUDES the
-     *    held ones. Reporting it beside `heldCount` counts the same message twice and labels one copy
-     *    "never received" when it is sitting on our own disk. Split here into what each actually is.
-     *  - Neither counter survives a restart on its own: `#witnessedSeq` is memory-only. Held content
-     *    is durable since DOD-M12B-STRAND-1, but a position the relay witnessed for content that
-     *    never arrived leaves no trace. So for a session carrying leaves this process did not watch
-     *    arrive, "clean" is unknowable — and saying `ready` there invites a close that gets
-     *    `leaf_count_mismatch` back, which is terminal and costs the receipt for good.
-     */
-    sealReadinessView(agentName: string, sessionId: string): SealReadinessView;
-    /**
-     * DOD-M12B-ABANDON-NOTIFY-1 — tell the counterparty we have hung up. Best effort, never blocking.
-     *
-     * A force-abandon marks the session terminal HERE and did nothing else, so the other side kept
-     * its half live, kept retrying delivery into it, and kept trying to re-establish — forever,
-     * because nothing would ever answer. That is what produced the 2026-08-17 notification storm:
-     * surviving halves calling continuously while the operator saw connection requests from agents
-     * nobody was driving.
-     *
-     * BEST EFFORT, and every caller must treat it that way. A peer that is offline cannot be told, so
-     * this is an improvement on silence rather than a guarantee — and it must never delay or fail the
-     * abandon, which is the operator's escape hatch out of a session that can never seal.
-     */
-    notifyCounterpartyAbandon(agentName: string, sessionId: string, correlationId?: string): Promise<AbandonNoticeResult>;
-    /**
-     * DOD-M12B-ABANDON-NOTIFY-1 — the receiving half: our counterparty has abandoned, so retire.
-     *
-     * RETIRING IS NOT DELETING. The counterparty walking away forfeits the notarized receipt; it must
-     * not also cost the operator the record of what was actually said. The transcript and the tree
-     * stay exactly as they are.
-     *
-     * Only an `active` or `interrupted` session moves. A SEALED session has a notarized receipt and
-     * must never be turned into an abandoned one by a late or duplicated notice — that would destroy
-     * the artifact this protocol exists to produce. An unknown session is refused rather than
-     * created: an authenticated stream proves who is speaking, not that a session exists.
-     */
-    retireOnCounterpartyAbandon(agentName: string, sessionId: string, correlationId?: string): Promise<boolean>;
     /**
      * DOD-CAP-SELF-HEAL-1 — the numbers behind a cap refusal, for the OPERATOR'S alarm only.
      *
@@ -1111,79 +613,12 @@ export declare class SessionNodeManager {
         mustClear: number;
         blocked: boolean;
     };
-    /**
-     * DOD-M12B-INDEX-1 — commit THIS agent's own leaf at the position the relay assigned it.
-     *
-     * The receiver has always enforced "leaf index === canonical position": content witnessed ahead
-     * of the next expected leaf is held, not appended out of order. The sender never did. It had the
-     * position in hand — the relay answers about 4 ms before the append — and called a push-only
-     * append that puts the leaf at the tail whatever the tail happens to be. While its own tree has
-     * no gap the two agree and nothing shows; the first gap puts its leaf at someone else's index,
-     * parts its root from the counterparty's, and the next seal gets `leaf_count_mismatch`, which is
-     * terminal.
-     *
-     * DELIVERY IS NOT DEFERRED BY THIS. The caller has already put the bytes on the wire; only the
-     * leaf waits for its slot, exactly as a received message does. Holding our own send is only
-     * affordable because holds are durable (DOD-M12B-STRAND-1) — before that it would have risked
-     * losing the message outright.
-     *
-     * `assignedSeq` absent means no ordering authority answered. That is the documented degradation
-     * and it appends in arrival order as before: with no position there is no discipline to enforce,
-     * and refusing would take messaging down whenever the relay is unreachable.
-     */
-    placeOwnLeaf(agentName: string, sessionId: string, contentHashHex: string, sentBytes: Uint8Array, assignedSeq: number | undefined, correlationId: string | undefined, 
-    /**
-     * ⚠️ NO DEFAULT, for the same reason `authorship` has none.
-     *
-     * `kind = "msg"` meant a caller writing a `doc` or a `ctrl` leaf got a `msg` leaf by saying
-     * nothing, and the tree recorded a leaf kind the author never chose. TypeScript also forbids a
-     * required parameter after a defaulted one, so leaving the default here would have forced
-     * `authorship` back to optional — which is the defect above. Every one of the seven call sites
-     * already passed a kind or wanted "msg"; making it explicit cost nothing and removes a second
-     * silent answer from the same signature.
-     */
-    kind: WritableSessionTreeLeafKind, 
-    /**
-     * DOD-M15-SEALWIRE-1 bullet 5 — the proof for THIS send, so a held row keeps it.
-     *
-     * ⚠️ REQUIRED, AND `undefined` IS A VALID ANSWER — the two are not the same thing.
-     *
-     * This was `authorship?:` for exactly one review cycle, and in that cycle THREE of the seven
-     * call sites omitted it: `daemon.ts` 1440, 1671, 1685 — the away-reply path, which is the
-     * highest-traffic sent-writer in the daemon and the one with no human watching it. All three
-     * had the proof **already in a local variable one line below**, handed to
-     * `recordTranscriptMessage` and not to this method. Nothing went red, because an optional
-     * parameter's whole behaviour on omission is to look deliberate.
-     *
-     * An unwitnessed send genuinely has no proof, so absence must stay expressible. Requiring the
-     * parameter keeps that while making the caller SAY it: omission is now a type error, and
-     * `undefined` is a claim the author made rather than one the signature made for them.
-     */
-    authorship: SentAuthorship | undefined): {
-        placed: true;
-        leafIndex: number;
-        diverged?: true;
-        unwitnessed?: true;
-    } | {
-        placed: false;
-        heldAt: number;
-    };
-    /** DAEMON-004: pop the oldest verified received content for cello_receive. */
-    takeReceivedContent(agentName: string, sessionId: string): ReceivedContentEntry | null;
     /** DOD-AWAY-WRAP-1: peek at the hex of the most-recently buffered (last) received message without
      *  consuming it. Used by sendAwayResponse to detect [[WRAP]]-signalled messages and skip the away
-     *  reply. Returning the last entry (not the first) is intentional — #appendVerifiedContent always
+     *  reply. Returning the last entry (not the first) is intentional — the ingest file's
+     *  appendVerifiedContent always
      *  pushes to the tail, so the tail is the message that just triggered onContentArrived. */
     peekLatestReceivedContentHex(agentName: string, sessionId: string): string | null;
-    /**
-     * TEST-ONLY (M8C-INBOX-1 reviewer F1): buffer a received message + persist its transcript row,
-     * exactly as the real inbound path (#appendVerifiedContent) does, WITHOUT standing up a session
-     * tree — so a test can drive a live cello_receive that advances the read watermark (the N3
-     * "delivery marks read" coupling). Only reachable via the CELLO_ENV=test IPC hook.
-     */
-    /** CELLO_ENV=test only: patch a relay client and session-id bytes onto an existing active node entry
-     *  so submitSealLeaf succeeds without a real relay handshake (used by the oneshot relay-path test). */
-    patchRelayClientForTest(agentName: string, sessionId: string, relayClient: AgentRelayClient, relaySessionIdBytes: Uint8Array): void;
     pushReceivedContentForTest(agentName: string, sessionId: string, seq: number, content: string, senderPubkey: string): void;
     /**
      * F1-b: the terminal answer for a session that sealed while a blocking receive was (or could be)
@@ -1235,15 +670,6 @@ export declare class SessionNodeManager {
     observeInboundContentFramesForTest(cb: (frame: Record<string, unknown>) => void): void;
     /** Injected by the daemon once its per-agent key providers exist. See `#keyProviderResolver`. */
     setKeyProviderResolver(resolver: (agentName: string) => KeyProvider | undefined): void;
-    /**
-     * Test seam: force this session's own salt half, so the LOCAL-defect path is reachable.
-     *
-     * `generateSaltContribution` cannot produce a degenerate half, which is the point of it — so the
-     * only way to exercise "our own random source is broken" end-to-end is to stand in for the broken
-     * source. Named `…ForTest` like every other seam in this file, and it writes the same map
-     * production writes rather than a parallel one, so a test cannot pass against state the daemon
-     * never reads.
-     */
     /**
      * Test seam: run the auto-acknowledge gate, exactly as the counterparty's SEAL ctrl leaf does.
      *
@@ -1255,7 +681,7 @@ export declare class SessionNodeManager {
      * `content_verification_unavailable` branch had no coverage anywhere in the repo and two mutants
      * on it survived the full gate.
      *
-     * It calls the REAL private method rather than reproducing its logic, so a test cannot pass
+     * It calls the REAL method (public on `SessionSeal` since the split, private before it) rather than reproducing its logic, so a test cannot pass
      * against a decision production does not make.
      */
     runAutoAcknowledgeGateForTest(agentName: string, sessionId: string, correlationId?: string): void;
@@ -1314,22 +740,6 @@ export declare class SessionNodeManager {
         salt: null;
         reason: "none" | "unreadable";
     };
-    /**
-     * M7-SESSION-001 AC-004/AC-005: Register a relay stream for an active session.
-     * Starts a background reader that watches for session_interrupted frames and
-     * stream close events. Both detection paths call markInterruptedWithDetails().
-     *
-     * The reader runs for the lifetime of the relay stream. If the stream closes
-     * without delivering a session_interrupted frame (AC-005 / 'stream_close' path),
-     * the session is still marked interrupted.
-     *
-     * @param sessionId The hex session ID
-     * @param stream The relay stream to monitor
-     * @param messageCount Number of message leaves at the time of registration
-     *   (used as the count at interruption — best effort since exact count at frame
-     *   receipt may differ, but this is the value available at stream setup time)
-     */
-    registerRelayStream(agentName: string, sessionId: string, stream: Stream, messageCount?: number): void;
     /**
      * DOD-M15-RELAYSLOTS-1: accept the directory's online token for an agent. Called on every
      * signaling connect and reconnect, which is what keeps it fresh.
@@ -1343,109 +753,6 @@ export declare class SessionNodeManager {
      * directory does not recognise.
      */
     getDirectoryOnlineToken(agentName: string): Uint8Array | undefined;
-    /**
-     * DOD-NAT-REACHABILITY-1 (Phase 2): accept the directory's relay-pool endpoints
-     * for an agent (arrives with signaling_auth_ok, i.e. on every connect AND every
-     * reconnect). If the agent's standing receiver is up but holds NO reservation —
-     * the agent-online ensure raced ahead of auth_ok, or every relay was down at
-     * create time — rebuild it now so the agent becomes dialable without waiting
-     * for a session handoff that (being unreachable) would never come.
-     */
-    setDirectoryRelayEndpoints(agentName: string, endpoints: Array<{
-        relayPeerId: string;
-        relayAddrs: string[];
-    }>): void;
-    /**
-     * Is this agent currently skipping this relay? The observable half of the failover decision — a
-     * test that asserts only on the classifier's boolean proves nothing about what the daemon does.
-     */
-    isRelayQuarantined(agentName: string, relayPeerId: string): boolean;
-    /**
-     * DOD-M12B-SESSION-SEED-1 — bring an interrupted session back on the peer id it already has.
-     *
-     * THE DEFECT THIS CLOSES. `markInterruptedWithDetails` and `destroySessionNode` stop the node and
-     * delete it from `#activeNodes`, and until now **nothing anywhere recreated one**. A laptop-close
-     * session stayed stuck even though both processes were alive and both keypairs were still in
-     * memory — the trace on 2026-08-17 found no missing transport capability, just a missing edge.
-     *
-     * TWO THINGS HAVE TO HAPPEN, and doing only one leaves the session exactly as stuck:
-     *   1. the NODE comes back, at the same peer id, or the counterparty can never dial us again;
-     *   2. the STATUS comes back to `active`, or every send still refuses with `session_not_active`.
-     *
-     * **DEMAND-DRIVEN ONLY.** Nothing calls this on a timer. That is the `REDIAL-1` discipline and it
-     * is also Andre's tenet — a background rebuilder would hold a dialable endpoint open for a session
-     * nobody is using, which is the "open connection a malicious agent can farm for" in as many words.
-     *
-     * **TERMINAL IS TERMINAL.** A sealed or abandoned session had its seed zeroed in the same step
-     * that wrote its status, so there is nothing to come back on. This refuses by name rather than
-     * minting a fresh identity — a revival that quietly mints would hand one session a second peer id
-     * and break the invariant while appearing to work.
-     *
-     * Idempotent: a session that already has a live node returns ok without building a second one.
-     */
-    reviveSessionNode(agentName: string, sessionId: string): Promise<{
-        ok: true;
-        peerId: string;
-    } | {
-        ok: false;
-        reason: string;
-        guidance?: string;
-    }>;
-    /**
-     * DOD-M12B-SESSION-SEED-1 — the DEMAND edge: a send on an interrupted session revives it.
-     *
-     * One of TWO production callers of `reviveSessionNode` — `reviveIfNeededForRead` is the other —
-     * and both are deliberately demand paths rather than timers. The `REDIAL-1` discipline and Andre's tenet say the same thing from two
-     * directions: nothing may re-open on its own, because a background rebuilder would hold a dialable
-     * endpoint open for a session nobody is using — the *"open connection a malicious agent can farm
-     * for"*. The operator sending is the demand; there is no other trigger.
-     *
-     * A no-op for the normal case. An `active` session with a live node returns immediately without
-     * touching it — this sits on the hot path of every send, and replacing a healthy node would be
-     * churn that changes the peer id for no reason.
-     */
-    reviveIfNeededForSend(agentName: string, sessionId: string): Promise<{
-        ok: true;
-    } | {
-        ok: false;
-        reason: string;
-        guidance?: string;
-    }>;
-    /**
-     * DOD-M12B-SESSION-SEED-1 (case B) — the INBOUND half of the demand edge.
-     *
-     * `reviveIfNeededForSend` covers the operator waking first. Case B's triggers are symmetric — a
-     * wifi hop, a relay restart, a directory node cycling — so half the time the COUNTERPARTY wakes
-     * first. They send; we have no node yet, because revival is demand-driven and we have demanded
-     * nothing. Their content parks at the relay, which is the backstop working as designed.
-     *
-     * Then the operator comes back and READS, and until now that told them nothing: the receive
-     * handler reads the transcript and never gates on status, so it happily reports what is already
-     * stored while messages sit parked, waiting for a node that will not exist until the operator
-     * happens to SEND. An operator who only reads was stuck forever with a surface that looked fine.
-     *
-     * **WHY A READ MAY TRIGGER THIS AND AN INBOUND DIAL MAY NOT.** Andre's tenet is about what a
-     * REMOTE party can cause: *"an open connection that a malicious agent can farm for."* Reviving
-     * because a peer dialled us would hand that lever straight to the peer — a stranger could keep our
-     * endpoints open indefinitely by poking dead sessions. A read is the OPERATOR asking, on their own
-     * machine, for their own session: the same class of demand as a send, and the class the tenet
-     * allows. That distinction is the whole reason this is a separate entry point rather than a
-     * revival triggered from the inbound handler.
-     */
-    reviveIfNeededForRead(agentName: string, sessionId: string): Promise<{
-        ok: true;
-    } | {
-        ok: false;
-        reason: string;
-        guidance?: string;
-    }>;
-    /** DOD-M12B-REVIVE-PARK-1 test seam: the relay the live entry will park to. Not otherwise
-     *  observable — `#activeNodes` is private and the park's own refusal is silent about which of its
-     *  four preconditions was missing. */
-    getSessionRelayForTest(agentName: string, sessionId: string): {
-        relayPeerId?: string;
-        relayAddrs?: string[];
-    } | null;
     /** DOD-M12B-SESSION-SEED-1 test seams: the counterparty addresses a re-dial depends on. Not
      *  otherwise observable — they are set from a signed relay assignment that a fixture cannot mint. */
     setCounterpartyAddrsForTest(agentName: string, sessionId: string, addrs: string[]): void;
@@ -1493,11 +800,5 @@ export declare class SessionNodeManager {
      * locked out by the acceptance bound forever.
      */
     countEstablishedReceived(agentName: string, sessionId: string): number;
-    /** CC-5/F21: unilaterally mark a session locally-terminal ("abandoned") — retire its live node and
-     *  set the DB status, with NO bilateral seal (a dead half-open handshake has nothing to notarize).
-     *  Used by cello_close_session { force } and the dead-half-open reaper. Idempotent: a missing/already-
-     *  abandoned session is a no-op. Resolves true iff the status flip was actually written (CC-10
-     *  reviewer LOW: callers must not report a reap as successful when the write failed). */
-    abandonSession(agentName: string, sessionId: string): Promise<boolean>;
 }
 //# sourceMappingURL=session-node-manager.d.ts.map