@cello-protocol/daemon 0.0.227 → 0.0.228

package/dist/session-lifecycle.d.ts

@@ -0,0 +1,303 @@
+import { SessionTree } from "./session-tree.js";
+import { type Logger } from "./types.js";
+import type { CelloNode } from "@cello-protocol/transport";
+import type { DaemonDatabase } from "./sqlcipher-db.js";
+import type { SessionRecords } from "./session-records.js";
+import type { SessionQueries } from "./session-queries.js";
+import type { ParkRecovery } from "./park-recovery.js";
+import type { HeldContent } from "./held-content.js";
+import type { SessionLeafRecords } from "./session-leaf-records.js";
+import type { StandingReceivers } from "./standing-receivers.js";
+import type { SessionEphemerals } from "./session-ephemerals.js";
+import type { SessionLiveness } from "./session-liveness.js";
+import type { SessionContentIngest } from "./session-content-ingest.js";
+import type { SessionContentSender } from "./session-content-send.js";
+import type { SessionRelay } from "./session-relay.js";
+import { SessionConnectionGater } from "./session-connection-gater.js";
+import { NodeAutoNatService } from "@cello-protocol/transport";
+import { type AbandonNoticeResult, type ActiveSessionEntry, type CreateSessionResult, type RelayConnectParams, type SessionRevivalIdentity } from "./session-node-types.js";
+/** What the session-lifecycle path needs from the manager. */
+export interface SessionLifecycleContext {
+    readonly logger: Logger;
+    readonly records: SessionRecords;
+    readonly queries: SessionQueries;
+    readonly park: ParkRecovery;
+    readonly held: HeldContent;
+    readonly leafRecords: SessionLeafRecords;
+    readonly receivers: StandingReceivers;
+    readonly ephemerals: SessionEphemerals;
+    readonly liveness: SessionLiveness;
+    readonly contentIn: SessionContentIngest;
+    readonly contentOut: SessionContentSender;
+    readonly relay: SessionRelay;
+    /** A function: the manager opens its database after construction. Re-exposed below as `#db`. */
+    db(): DaemonDatabase | null;
+    readonly activeNodes: Map<string, ActiveSessionEntry>;
+    readonly standingReceivers: Map<string, {
+        node: CelloNode;
+        gater: SessionConnectionGater;
+        autoNat: NodeAutoNatService;
+        seed: Uint8Array;
+        relayPeerIds: string[];
+    }>;
+    readonly standingReceiverCreating: Set<string>;
+    readonly agentsWantingReceiver: Set<string>;
+    readonly counterpartyAddrs: Map<string, string[]>;
+    /**
+     * ⚠️ THE DURABLE IDENTITY A REVIVAL COMES BACK ON. Without the seed a rebuilt node gets a fresh
+     * key: it can dial the counterparty and they can never dial back — a session reporting itself
+     * healthy while silently one-way. A terminal session's seed is destroyed with it, which is what
+     * makes "terminal is terminal" enforceable rather than merely intended.
+     */
+    readonly sessionSeeds: Map<string, SessionRevivalIdentity>;
+    readonly frozenSessions: Map<string, {
+        reason: string;
+        guidance: string;
+    }>;
+    readonly sessionTerminal: Map<string, {
+        type: "sealed";
+        unreadCount: number;
+    }>;
+    readonly shuttingDown: boolean;
+    readonly autoNatProbers: () => string[];
+    readonly onSessionStateChanged: ((agentName: string, sessionId: string, state: string, counterpartyPubkey: string | null) => void) | null;
+    readonly onSessionTerminal: ((sessionId: string, terminalStatus: "sealed" | "abandoned") => void) | null;
+    readonly retryDrainHook: ((agentName: string, sessionId: string) => void) | null;
+    /** DOD-LOOP-1: (agentName, sessionId), never sessionId alone — see the manager's own note. */
+    sessionKey(agentName: string, sessionId: string): string;
+    requireAgentId(agentName: string): string;
+    resolveAgentId(agentName: string): string;
+    getSessionTree(agentName: string, sessionId: string): SessionTree;
+    /**
+     * ⚠️ STAYS ON THE MANAGER, and is reached rather than moved. It clears the shared maps every
+     * collaborator writes — it is the method that proves how much of this class was one blob of
+     * session state, and it belongs with whoever owns those maps.
+     */
+    evictSessionCaches(agentName: string, sessionId: string): void;
+}
+export declare class SessionLifecycle {
+    #private;
+    constructor(ctx: SessionLifecycleContext);
+    /**
+     * 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;
+    /**
+     * 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>;
+    /**
+     * 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>;
+    /**
+     * Graceful shutdown: mark all active sessions as interrupted, stop all nodes.
+     * Called from the SIGTERM / cello logout path (AC-009).
+     * SQLite writes complete before this method returns.
+     */
+    /**
+     * DOD-M12B-SHUTDOWN-1 — wait for a teardown step, but never forever.
+     *
+     * Every step of shutdown used to be an unbounded `await` on libp2p. That is what makes "the
+     * daemon acknowledged the request but is still running" possible: nothing on the daemon side
+     * emits a word while it hangs, so the operator's own message ("it may be stuck closing sessions
+     * or its database") was a guess. Past the deadline the step is ABANDONED and SAID — the resources
+     * it was closing are reclaimed by the OS on exit, and an exit is worth more than a tidy one.
+     */
+    boundedTeardown(work: Promise<unknown>, step: string, count: number): Promise<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>;
+    /**
+     * 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;
+    }>;
+    /**
+     * 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-M12B-SESSION-SEED-1 — destroy a session's transport identity.
+     *
+     * Called from `#updateSessionStatus` on a terminal status, in the SAME step that writes it, so
+     * there is no window in which a session is closed on paper and still revivable in memory.
+     *
+     * **WHAT THE ZERO-FILL DOES AND DOES NOT DO** — checked against the derivation, not assumed.
+     * `createNode` hands the buffer to `generateKeyPairFromSeed`, and `@libp2p/crypto` COPIES it
+     * (`uint8arrayConcat([seed, publicKeyRaw])`, then `Uint8Array.from`). Two consequences:
+     *   - zeroing after the node has started is SAFE — the running node holds its own copy;
+     *   - it does NOT erase the key from the heap. An identical usable copy is the first 32 bytes of
+     *     `privateKey.raw` on the node object until that node is dropped.
+     * So this removes OUR long-lived copy — the one that would otherwise sit in a map for the life of
+     * the process, decoupled from any node — and that is worth doing. It is not a heap scrub, and
+     * the DoD already says the bound rather than secrecy is the control.
+     */
+    destroySessionSeed(agentName: string, sessionId: string): void;
+    /**
+     * 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;
+    }>;
+    /** 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>;
+    updateSessionStatus(agentName: string, sessionId: string, status: "active" | "sealed" | "interrupted" | "abandoned", interruptedBy?: "local"): boolean;
+}
+//# sourceMappingURL=session-lifecycle.d.ts.map

package/dist/session-lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-lifecycle.d.ts","sourceRoot":"","sources":["../src/session-lifecycle.ts"],"names":[],"mappings":"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"}