@cello-protocol/daemon 0.0.227 → 0.0.229

package/dist/session-schema.js.map

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

package/dist/session-seal-leaf-store.d.ts

@@ -0,0 +1,70 @@
+/**
+ * SessionSealLeafStore — FED-OPTIONB-SEAL-001.
+ *
+ * The per-session leaf log a UNILATERAL seal CARRIES to the directory so the directory rebuilds + verifies
+ * the Merkle tree OFFLINE (no directory→relay getSealLeaves dial). It holds BOTH parties' leaves, because a
+ * unilateral seal's reported_root spans the whole conversation:
+ *   - PRESENT-party (own) leaves: captured from this agent's own hash_submit_ack — they carry the relay's
+ *     signed RECEIPT (relay_id + timestamp + signature over buildRelayAckTbs(content_hash, seq, ts)). That
+ *     signature is the teeth that pins each own leaf to its canonical sequence (Structure1 does NOT bind
+ *     seq/prev_root, so without it a supplier could reorder its own leaves).
+ *   - COUNTERPARTY leaves: captured from leaf_deliver — they carry structure1/structure2 but NO relay
+ *     receipt (the relay does not ack-sign a delivery to the recipient). They are pinned by the absent
+ *     party's sender_signature (unforgeable) + the prev_root chain + the signed last_seen_seq causal check +
+ *     sequence contiguity against the receipt-pinned own leaves.
+ *
+ * Immutable at a position (agent, session, sequence): INSERT OR IGNORE keeps the first record for a seq.
+ */
+import type { DaemonDatabase } from "./sqlcipher-db.js";
+import type { Logger } from "./types.js";
+/** A carried leaf for the unilateral-seal offline rebuild. Relay-receipt fields present only for own leaves. */
+export interface SealCarryLeaf {
+    sequenceNumber: number;
+    /** 0x00 message / 0x02 control (SEAL). */
+    leafKind: number;
+    /** Hex of the leaf author's 32-byte pubkey (present party for own leaves, counterparty for received). */
+    senderPubkeyHex: string;
+    /** The relay's committed Structure2 (CBOR) for this leaf. */
+    structure2Cbor: Uint8Array;
+    /** The sender-signed Structure1 (CBOR) for this leaf. */
+    structure1Cbor: Uint8Array;
+    /** Relay ack-signing pubkey hex (own leaves only). */
+    relayId?: string;
+    /** Unix ms embedded in the relay ACK TBS (own leaves only). */
+    relayTimestamp?: number;
+    /** Hex of the 64-byte relay ACK signature (own leaves only). */
+    relaySignatureHex?: string;
+    /**
+     * 069-ORDERPROOF: hex of the 32-byte running root the relay bound into its attestation for this
+     * position (own leaves only). Part of the signed statement, so without it the directory cannot
+     * rebuild the bytes and refuses the leaf as unwitnessed.
+     */
+    relayRunningRootHex?: string;
+}
+export declare class SessionSealLeafStore {
+    #private;
+    constructor(db: DaemonDatabase, logger: Logger);
+    /**
+     * Persist a leaf at its canonical position. IMMUTABLE: INSERT OR IGNORE keeps the FIRST record for an
+     * (agent, session, sequence) — a later record for the same position (e.g. a re-delivery, or a relay
+     * equivocation) cannot overwrite it. Returns true iff a new row was written.
+     */
+    store(agentPubkeyHex: string, sessionIdHex: string, leaf: SealCarryLeaf, storedAtMs: number): boolean;
+    /**
+     * The last acknowledgement the live path recorded for this agent and session (`session_last_ack`):
+     * a RELAY position and its hash. A message that arrives on the direct path is acknowledged without
+     * ever being written to this leaf table, so a resumed session reads this too. Joined through
+     * `agents` on the stable agent_id, never the name.
+     */
+    recordedAcknowledgement(agentPubkeyHex: string, sessionIdHex: string): {
+        seq: number;
+        hash: Uint8Array;
+    } | undefined;
+    /**
+     * The complete carried leaf chain for a session's UNILATERAL seal, ordered by canonical sequence. The
+     * directory rebuilds + verifies this tree OFFLINE. Returns ALL recorded leaves (both parties); the caller
+     * carries them verbatim and the directory enforces contiguity + the per-leaf relay-receipt teeth.
+     */
+    getCarry(agentPubkeyHex: string, sessionIdHex: string): SealCarryLeaf[];
+}
+//# sourceMappingURL=session-seal-leaf-store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"session-seal-leaf-store.d.ts","sourceRoot":"","sources":["../src/session-seal-leaf-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEzC,gHAAgH;AAChH,MAAM,WAAW,aAAa;IAC5B,cAAc,EAAE,MAAM,CAAC;IACvB,0CAA0C;IAC1C,QAAQ,EAAE,MAAM,CAAC;IACjB,yGAAyG;IACzG,eAAe,EAAE,MAAM,CAAC;IACxB,6DAA6D;IAC7D,cAAc,EAAE,UAAU,CAAC;IAC3B,yDAAyD;IACzD,cAAc,EAAE,UAAU,CAAC;IAC3B,sDAAsD;IACtD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,+DAA+D;IAC/D,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gEAAgE;IAChE,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAsBD,qBAAa,oBAAoB;;gBAInB,EAAE,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM;IAsB9C;;;;OAIG;IACH,KAAK,CAAC,cAAc,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO;IAwBrG;;;;;OAKG;IACH,uBAAuB,CAAC,cAAc,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,UAAU,CAAA;KAAE,GAAG,SAAS;IAcpH;;;;OAIG;IACH,QAAQ,CAAC,cAAc,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,aAAa,EAAE;CAmBxE"}

package/dist/session-seal-leaf-store.js

@@ -0,0 +1,105 @@
+const CREATE_SQL = `
+  CREATE TABLE IF NOT EXISTS session_seal_leaves (
+    agent_pubkey      TEXT    NOT NULL,
+    session_id        TEXT    NOT NULL,
+    sequence_number   INTEGER NOT NULL,
+    leaf_kind         INTEGER NOT NULL,
+    sender_pubkey_hex TEXT    NOT NULL,
+    structure2_cbor   BLOB    NOT NULL,
+    structure1_cbor   BLOB    NOT NULL,
+    relay_id          TEXT,
+    relay_timestamp   INTEGER,
+    relay_signature   TEXT,
+    -- 069-ORDERPROOF. NULLABLE: rows written before this order keep working, and a session created
+    -- before it still opens, reads and seals bilaterally exactly as it did.
+    relay_running_root TEXT,
+    stored_at         INTEGER NOT NULL,
+    PRIMARY KEY (agent_pubkey, session_id, sequence_number)
+  );
+`;
+export class SessionSealLeafStore {
+    #db;
+    #logger;
+    constructor(db, logger) {
+        this.#db = db;
+        this.#logger = logger;
+        this.#db.exec(CREATE_SQL);
+        this.#migrateRunningRoot();
+    }
+    /**
+     * 069-ORDERPROOF: add `relay_running_root` to a table created before this order. `CREATE TABLE IF
+     * NOT EXISTS` leaves an existing table untouched, so without this an upgraded daemon would write
+     * to a column that is not there. Idempotent, additive and nullable — no row is rewritten and no
+     * existing evidence is invalidated.
+     */
+    #migrateRunningRoot() {
+        const cols = new Set(this.#db.prepare(`PRAGMA table_info(session_seal_leaves)`).all().map((c) => c.name));
+        if (!cols.has("relay_running_root")) {
+            this.#db.exec(`ALTER TABLE session_seal_leaves ADD COLUMN relay_running_root TEXT`);
+        }
+    }
+    /**
+     * Persist a leaf at its canonical position. IMMUTABLE: INSERT OR IGNORE keeps the FIRST record for an
+     * (agent, session, sequence) — a later record for the same position (e.g. a re-delivery, or a relay
+     * equivocation) cannot overwrite it. Returns true iff a new row was written.
+     */
+    store(agentPubkeyHex, sessionIdHex, leaf, storedAtMs) {
+        const info = this.#db
+            .prepare(`INSERT OR IGNORE INTO session_seal_leaves
+           (agent_pubkey, session_id, sequence_number, leaf_kind, sender_pubkey_hex, structure2_cbor, structure1_cbor, relay_id, relay_timestamp, relay_signature, relay_running_root, stored_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(agentPubkeyHex, sessionIdHex, leaf.sequenceNumber, leaf.leafKind, leaf.senderPubkeyHex, Buffer.from(leaf.structure2Cbor), Buffer.from(leaf.structure1Cbor), leaf.relayId ?? null, leaf.relayTimestamp ?? null, leaf.relaySignatureHex ?? null, leaf.relayRunningRootHex ?? null, storedAtMs);
+        return Number(info.changes) > 0;
+    }
+    /**
+     * The last acknowledgement the live path recorded for this agent and session (`session_last_ack`):
+     * a RELAY position and its hash. A message that arrives on the direct path is acknowledged without
+     * ever being written to this leaf table, so a resumed session reads this too. Joined through
+     * `agents` on the stable agent_id, never the name.
+     */
+    recordedAcknowledgement(agentPubkeyHex, sessionIdHex) {
+        // The session schema creates the table; a database without it (a leaf store used on its own)
+        // has recorded no acknowledgement, which is the same fact.
+        if (this.#db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'session_last_ack'").get() === undefined)
+            return undefined;
+        const row = this.#db
+            .prepare(`SELECT k.relay_seq AS seq, k.hash_hex AS hash FROM session_last_ack k
+           JOIN agents a ON a.agent_id = k.agent_id
+          WHERE a.k_local_pubkey = ? AND k.session_id = ?`)
+            .get(agentPubkeyHex, sessionIdHex);
+        return row ? { seq: row.seq, hash: new Uint8Array(Buffer.from(row.hash, "hex")) } : undefined;
+    }
+    /**
+     * The complete carried leaf chain for a session's UNILATERAL seal, ordered by canonical sequence. The
+     * directory rebuilds + verifies this tree OFFLINE. Returns ALL recorded leaves (both parties); the caller
+     * carries them verbatim and the directory enforces contiguity + the per-leaf relay-receipt teeth.
+     */
+    getCarry(agentPubkeyHex, sessionIdHex) {
+        const rows = this.#db
+            .prepare(`SELECT sequence_number, leaf_kind, sender_pubkey_hex, structure2_cbor, structure1_cbor, relay_id, relay_timestamp, relay_signature, relay_running_root
+           FROM session_seal_leaves WHERE agent_pubkey = ? AND session_id = ? ORDER BY sequence_number ASC`)
+            .all(agentPubkeyHex, sessionIdHex);
+        return rows.map((r) => ({
+            sequenceNumber: r.sequence_number,
+            leafKind: r.leaf_kind,
+            senderPubkeyHex: r.sender_pubkey_hex,
+            structure2Cbor: toU8(r.structure2_cbor),
+            structure1Cbor: toU8(r.structure1_cbor),
+            relayId: r.relay_id ?? undefined,
+            relayTimestamp: r.relay_timestamp ?? undefined,
+            relaySignatureHex: r.relay_signature ?? undefined,
+            relayRunningRootHex: r.relay_running_root ?? undefined,
+        }));
+    }
+}
+/** Normalize a SQLite BLOB (Buffer/Uint8Array/ArrayBuffer) to a Uint8Array. */
+function toU8(v) {
+    if (v instanceof Uint8Array)
+        return v;
+    if (Buffer.isBuffer(v))
+        return new Uint8Array(v);
+    if (v instanceof ArrayBuffer)
+        return new Uint8Array(v);
+    return new Uint8Array();
+}
+//# sourceMappingURL=session-seal-leaf-store.js.map

package/dist/session-seal-leaf-store.js.map

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

package/dist/session-seal.d.ts

@@ -0,0 +1,334 @@
+import type { KeyProvider } from "@cello-protocol/crypto";
+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>>;
+    /** DOD-M15-SEALPRECOND-1 — our own leaves the relay has ordered and this tree has not placed. */
+    readonly ownLeavesOrdered: 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;
+    /**
+     * 070-CARRIEDSEAL: the agent's own signing key, for the closing leaf this side writes when no
+     * relay is left to order one. `undefined` when the agent is not loaded in this daemon — which is
+     * a refusal with its own name, never a leaf signed by something else.
+     */
+    getKeyProvider(agentName: string): KeyProvider | undefined;
+    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);
+    /**
+     * Does a certificate describe the leaf set this daemon holds? The judgement lives in
+     * `seal-certified-root-check.ts`; this binds it to this instance's carry.
+     */
+    verifyCertifiedRoot(agentPubkeyHex: string, sessionIdHex: string, certifiedRoot: Uint8Array, certifiedLeafCount: number, evidence: readonly unknown[] | undefined): {
+        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;
+    submitSealLeaf(agentName: string, sessionId: string, correlationId?: string): Promise<{
+        ok: true;
+        sequenceNumber: number;
+        reportedRootHex: string;
+        /**
+         * 070-CARRIEDSEAL: this leaf was signed HERE because no relay answered, so no relay holds
+         * it. The caller must not then wait out the bilateral window: a bilateral seal is a ceremony
+         * the RELAY runs from its own leaf log, and there is no relay. Waiting eleven minutes for a
+         * ceremony that cannot begin is eleven minutes of an operator watching nothing happen before
+         * the solo seal that was always the only outcome.
+         */
+        viaLocalTerminus?: true;
+    } | {
+        ok: false;
+        reason: string;
+        reportedRootHex?: string;
+        sequenceNumber?: number;
+        viaLocalTerminus?: true;
+    }>;
+    /**
+     * 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-M15-SEALPRECOND-1 — leaves of OUR OWN the relay has ordered and this tree has not placed.
+         *
+         * The fourth term, and the one the 2026-09-11 lost receipt needed. The other three describe the
+         * counterparty's leaves or a permanent parting, and none of them moves when the relay orders a
+         * send of ours — `relayLeafHandler` records a witness only for leaves NOT authored by us. So a
+         * close landing between the ordering and `placeOwnLeaf` read a clean readiness and signed short.
+         * Unlike `diverged`, this RESOLVES in milliseconds, which is why its consumer waits.
+         */
+        ownLeavesOrdered: number;
+    };
+    /**
+     * 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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"}