@cello-protocol/daemon 0.0.196 → 0.0.198

package/dist/session-seal.d.ts

@@ -0,0 +1,336 @@
+import type { SealUpgradeReadiness } from "./seal-upgrade.js";
+import type { Logger, SealReadinessView } from "./types.js";
+import type { SessionTree } from "./session-tree.js";
+import type { DaemonDatabase } from "./sqlcipher-db.js";
+import { type AgentRelayClient } from "./session-relay-client.js";
+import { RelayReceiptStore } from "./relay-receipt-store.js";
+import { SessionSealLeafStore, type SealCarryLeaf } from "./session-seal-leaf-store.js";
+import type { SessionOwnChainStore } from "./session-own-chain-store.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, HeldEntry } from "./held-content.js";
+import type { SessionLeafRecords } from "./session-leaf-records.js";
+import type { StandingReceivers } from "./standing-receivers.js";
+import type { ActiveSessionEntry } from "./session-node-types.js";
+/** What the seal path needs from the manager. */
+export interface SessionSealContext {
+    readonly logger: Logger;
+    readonly records: SessionRecords;
+    readonly queries: SessionQueries;
+    readonly park: ParkRecovery;
+    readonly held: HeldContent;
+    readonly leafRecords: SessionLeafRecords;
+    readonly receivers: StandingReceivers;
+    /** A function: the manager opens its database after construction. Re-exposed below as `#db`. */
+    db(): DaemonDatabase | null;
+    readonly activeNodes: Map<string, ActiveSessionEntry>;
+    readonly heldContent: Map<string, Map<number, HeldEntry>>;
+    readonly witnessedSeq: Map<string, Map<string, number>>;
+    readonly highWaterSeq: Map<string, number>;
+    readonly orderingObserved: Set<string>;
+    readonly contentDesynced: Map<string, "tampered" | "unverifiable">;
+    readonly responderSealSubmitted: Map<string, {
+        reportedRootHex: string;
+        sequenceNumber: number;
+    } | null>;
+    readonly relayClients: Map<string, AgentRelayClient>;
+    /**
+     * ⚠️ READ-WRITE, both of them, and deliberately so — see the file header. They are `null` until
+     * something needs them, and whichever side reaches for one first is the side that opens it. A
+     * read-only view here would have meant this file opening its own second instance over the same
+     * rows the manager writes.
+     */
+    relayReceiptStore: RelayReceiptStore | null;
+    sealLeafStore: SessionSealLeafStore | null;
+    /**
+     * Assigned by `setEnsureSealBroker`, which lives here; the manager only forwards to it.
+     *
+     * ⚠️ `undefined`, not `null` — matching the manager's field exactly rather than tidying it. The
+     * broker returns a HANDLE with a `stop`, not a boolean: it is the thing keeping a seal ceremony
+     * alive, and a caller has to be able to end it. Simplifying that to a success flag here would
+     * have compiled against a wrapper and lost the only way to cancel.
+     */
+    ensureSealBroker: ((agentName: string, sessionId: string) => Promise<{
+        stop: (reason: string) => Promise<void>;
+    } | null>) | undefined;
+    /**
+     * ⚠️ FOUR PARAMETERS. The last two — the state name and the counterparty key — are what the
+     * notification carries to the operator's channel; a two-parameter version would have type-checked
+     * at the call site and delivered a state change with no state in it.
+     */
+    readonly onSessionStateChanged: ((agentName: string, sessionId: string, state: string, counterpartyPubkey: string | null) => void) | null;
+    readonly ownChainStore: SessionOwnChainStore | null;
+    /**
+     * ⚠️ THE `stores` ARGUMENT IS NOT OPTIONAL DECORATION. A client built without it has no receipt
+     * store and no seal-leaf store, so `#captureReceipt` silently returns false: the submit reports
+     * ok while the relay's signed receipt — the evidence the seal rests on — is never written.
+     */
+    readonly detachedRelayClientBuilder: ((agentName: string, relayPeerId: string, relayAddrs: string[], stores: {
+        receiptStore?: RelayReceiptStore;
+        sealLeafStore?: SessionSealLeafStore;
+        ownChainStore?: SessionOwnChainStore;
+        onlineToken: () => Uint8Array | undefined;
+    }) => AgentRelayClient | undefined) | 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;
+    getSessionTree(agentName: string, sessionId: string): SessionTree;
+    getSessionTreeRootHex(agentName: string, sessionId: string): string;
+    getDirectoryOnlineToken(agentName: string): Uint8Array | undefined;
+    destroySessionSeed(agentName: string, sessionId: string): void;
+    updateSessionStatus(agentName: string, sessionId: string, status: "active" | "sealed" | "interrupted" | "abandoned", interruptedBy?: "local"): boolean;
+}
+export declare class SessionSeal {
+    #private;
+    constructor(ctx: SessionSealContext);
+    /**
+     * 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;
+    };
+    /**
+     * 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.
+     *
+     * ⚠️ Stranded on `verifyCertifiedRoot` before this split — the third block found doing that, and the
+     * reason the rule is now written down: a method reduced to a delegator leaves its documentation
+     * behind, and the block below it ends up carrying two descriptions of which the first is a stranger.
+     */
+    getSealCarry(agentPubkeyHex: string, sessionIdHex: string): SealCarryLeaf[];
+    /** 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;
+    /**
+     * 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 (a manager delegator onto `session-queries.ts`) 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 (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;
+    /**
+     * 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;
+    /**
+     * M7-UPGRADE-002: auto-acknowledge close (POSTMORTEM Workstream E / C-5). When B's daemon
+     * ingests the COUNTERPARTY's SEAL control leaf and B has verified the content, B's OWN node
+     * auto-co-signs + submits its responder SEAL leaf WITHOUT waiting for B's agent to call
+     * cello_close_session — so a bilateral seal completes promptly instead of degrading to
+     * unilateral on a slow/busy/crashed agent.
+     *
+     * SI-001 (non-negotiable): B's signature is ALWAYS produced by B's own node — submitSealLeaf
+     * signs the responder SEAL leaf with B's K_local. We remove the agent PROMPT, never the SIGNER;
+     * nothing here lets the directory or the peer synthesize B's acknowledgement.
+     *
+     * SI-002 (verifiability gate): auto-ack ONLY content B has verified. A session whose content
+     * cross-check failed (content_hash_mismatch = tamper, recorded in #contentDesynced) is NEVER
+     * auto-signed — it surfaces to the agent as a genuine decision point. DISAGREEMENT with the
+     * content is NOT a gate failure (C-6): the gate is "can I verify integrity?", never "do I agree?"
+     * — a verified-but-disliked tail is auto-sealed and the transcript speaks for B.
+     *
+     * Idempotent + non-throwing: marks #responderSealSubmitted BEFORE the async submit so a
+     * redelivered ctrl leaf cannot double-submit; clears the mark on submit failure so a later
+     * agent close / reconnect can still complete the seal (DB-001 — never a silent half-seal).
+     */
+    maybeAutoAcknowledgeSeal(agentName: string, sessionId: string, correlationId: string): void;
+    /**
+     * 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;
+    /**
+     * 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;
+}
+//# sourceMappingURL=session-seal.d.ts.map

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

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