@cello-protocol/daemon 0.0.53 → 0.0.55

package/dist/seal-flows.d.ts

@@ -0,0 +1,50 @@
+import { SignalingManager } from "@cello-protocol/transport";
+import type { KeyProvider } from "@cello-protocol/crypto";
+import type { SessionNodeManager } from "./session-node-manager.js";
+import type { AgentInfo, Logger } from "./types.js";
+export type SealFlowResult = {
+    ok: true;
+    sessionId: string;
+    status: "seal_interrupted_pending";
+} | {
+    ok: false;
+    reason: string;
+    guidance: string;
+};
+export type ActiveSealResult = {
+    ok: true;
+    sessionId: string;
+    status: "seal_interrupted_pending";
+    rootHex: string;
+} | {
+    ok: false;
+    reason: string;
+    guidance: string;
+};
+export interface SealFlowDeps {
+    logger: Logger;
+    sessionNodeManager: SessionNodeManager;
+    agents: AgentInfo[];
+    getKeyProvider: (agentName: string) => KeyProvider | undefined;
+    /** This agent's directory signaling stream, or undefined if it has none. */
+    signalingFor: (agentName: string) => SignalingManager | undefined;
+    sendOver: (agentName: string, frame: Record<string, unknown>) => Promise<{
+        ok: boolean;
+        reason?: string;
+    }>;
+}
+export declare function createSealFlows(deps: SealFlowDeps): {
+    awaitSealAck: (sessionId: string, mgr: SignalingManager | undefined) => Promise<{
+        type: "seal_interrupted_ack";
+        sealInterruptedLeaf: Record<string, unknown>;
+        nonce: string | null;
+    } | {
+        type: "seal_interrupted_rejection";
+        reason: string;
+    } | {
+        type: "timeout";
+    }>;
+    handleSealInterruptedFlow: (sessionId: string, record: import("./types.js").SessionRecord, correlationId: string, merkleRootAtInterruption: string) => Promise<SealFlowResult>;
+    handleActiveSealFlow: (sessionId: string, record: import("./types.js").SessionRecord, correlationId: string) => Promise<ActiveSealResult>;
+};
+//# sourceMappingURL=seal-flows.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"seal-flows.d.ts","sourceRoot":"","sources":["../src/seal-flows.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAE7D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEpD,MAAM,MAAM,cAAc,GACtB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,0BAA0B,CAAA;CAAE,GACnE;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpD,MAAM,MAAM,gBAAgB,GACxB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,0BAA0B,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACpF;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpD,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,kBAAkB,EAAE,kBAAkB,CAAC;IACvC,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,cAAc,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,WAAW,GAAG,SAAS,CAAC;IAC/D,4EAA4E;IAC5E,YAAY,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,gBAAgB,GAAG,SAAS,CAAC;IAClE,QAAQ,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC;QAAE,EAAE,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC5G;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,YAAY;8BAyCf,MAAM,OAAO,gBAAgB,GAAG,SAAS,KAAG,OAAO;cAJxE,sBAAsB;6BAAuB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;eAAS,MAAM,GAAG,IAAI;;cAC1F,4BAA4B;gBAAU,MAAM;;cAC5C,SAAS;MAE8E;2CAmCtF,MAAM,UACT,OAAO,YAAY,EAAE,aAAa,iBAC3B,MAAM,4BACK,MAAM,KAC/B,OAAO,CAAC,cAAc,CAAC;sCA4Nb,MAAM,UACT,OAAO,YAAY,EAAE,aAAa,iBAC3B,MAAM,KACpB,OAAO,CAAC,gBAAgB,CAAC;EA+K7B"}

package/dist/seal-flows.js

@@ -0,0 +1,454 @@
+/**
+ * The two seal-initiation flows that cello_close_session dispatches into.
+ *
+ *   handleSealInterruptedFlow — the counterparty is GONE. Exchange seal-interrupted leaves over the
+ *     directory pass-through, then freeze the session at seal_interrupted_pending.
+ *   handleActiveSealFlow — the counterparty is LIVE. Run the bilateral close.
+ *
+ * The daemon holds no FrostThresholdSigner and no directory FROST ceremony client, so it CANNOT
+ * produce a threshold signature by itself. That is the sovereign-node invariant, and it is why these
+ * functions only ever assemble and exchange leaves — the notarization happens at the directory.
+ */
+import { randomUUID } from "node:crypto";
+import { buildSignedSealInterruptedLeaf, verifyCounterpartySealLeaf } from "./seal-leaf.js";
+export function createSealFlows(deps) {
+    const { logger, sessionNodeManager, agents, getKeyProvider, signalingFor, sendOver } = deps;
+    const keyProviders = { get: getKeyProvider };
+    // Seal-interrupted bilateral INITIATOR flow.
+    //
+    // ⚠️ SCOPE — this flow does NOT complete a FROST-notarized seal, and must not pretend to.
+    //
+    //   What it DOES: both parties produce and exchange real K_local Ed25519-signed SEAL-INTERRUPTED
+    //   leaves over an agreed {leafCount, merkleRoot}; the initiator verifies the signature, the
+    //   echoed nonce, and the cross-checks; the verified bilateral commitment is persisted; the
+    //   session advances to the NON-TERMINAL 'seal_interrupted_pending' state.
+    //
+    //   What it does NOT do: the FROST threshold notarization. The daemon holds no
+    //   FrostThresholdSigner and no directory FROST ceremony client, so it CANNOT produce a threshold
+    //   seal here. The session therefore STOPS at the persisted bilateral commitment rather than
+    //   claim a completed seal. Wiring the real seal means injecting a SealManager adapter.
+    //
+    //   Merkle-ROOT agreement is deliberately NOT compared at this layer. Under concurrent
+    //   bidirectional traffic the two sides' local append orders — and therefore their roots — can
+    //   legitimately diverge until the relay-assigned canonical sequence exists. Comparing roots here
+    //   would reject honest sessions. leafCount agreement (each side against its own tree size, or
+    //   message_count when no tree exists) is the bilateral check available at this layer; true root
+    //   agreement belongs to the FROST seal against the directory-held tree.
+    //
+    //   Both sides bind over their OWN tree root + size (SI-001) whenever a non-empty tree exists —
+    //   e.g. reloaded from session_tree_leaves after a restart. Only sessions with no persisted tree
+    //   fall back to message_count plus the caller-supplied root.
+    // M7-SESSION-001 / DAEMON-004: shared bilateral ack-await machinery. The
+    // interrupted-seal flow AND the active-session seal flow both send a
+    // `seal_interrupted_request` and wait on the directory signaling stream for the
+    // counterparty's `seal_interrupted_ack` / `seal_interrupted_rejection` (or time
+    // out). Extracted so the two flows wait identically — the directory pass-through
+    // routing (directory-node.ts) is the only wired transport for this exchange.
+    const SEAL_INTERRUPTED_TIMEOUT_MS = 30_000;
+    function awaitSealAck(sessionId, mgr) {
+        return new Promise((resolve) => {
+            // CONN-001: await the ack on the OWNING agent's own stream (per-agent in prod, shared in test).
+            if (!mgr) {
+                resolve({ type: "timeout" });
+                return;
+            }
+            const timeoutHandle = setTimeout(() => {
+                unregister();
+                resolve({ type: "timeout" });
+            }, SEAL_INTERRUPTED_TIMEOUT_MS);
+            const unregister = mgr.registerInboundHandler((frame) => {
+                if (frame.type !== "seal_interrupted_ack" && frame.type !== "seal_interrupted_rejection") {
+                    return;
+                }
+                if (typeof frame.sessionId !== "string" || frame.sessionId !== sessionId)
+                    return;
+                clearTimeout(timeoutHandle);
+                unregister();
+                if (frame.type === "seal_interrupted_ack") {
+                    resolve({
+                        type: "seal_interrupted_ack",
+                        sealInterruptedLeaf: frame.sealInterruptedLeaf ?? {},
+                        nonce: typeof frame.nonce === "string" ? frame.nonce : null,
+                    });
+                }
+                else {
+                    resolve({
+                        type: "seal_interrupted_rejection",
+                        reason: typeof frame.reason === "string" ? frame.reason : "unknown",
+                    });
+                }
+            });
+        });
+    }
+    async function handleSealInterruptedFlow(sessionId, record, correlationId, merkleRootAtInterruption) {
+        const nonce = randomUUID();
+        // Retrieve the agent's own pubkey from the agent list
+        // (the agent_name stored in the session record identifies which agent was in session)
+        const agent = agents.find((a) => a.name === record.agent_name);
+        const myPubkeyHex = agent?.pubkey ?? "";
+        const counterpartyPubkey = record.counterparty_pubkey;
+        // DAEMON-004 (AC-007 / SI-001 / finding #2): prefer the daemon-owned tree.
+        // After a SIGKILL+restart the active session is forced to 'interrupted' and
+        // its Merkle tree is reloaded from session_tree_leaves. When that reloaded
+        // tree is non-empty it is the authoritative transcript: the seal binds over
+        // the daemon's OWN reloaded root + size, and any caller-supplied
+        // merkleRootAtInterruption is IGNORED (SI-001). Only when no tree was ever
+        // persisted (legacy / pre-DAEMON-004 sessions) do we fall back to the
+        // caller-supplied root and the message_count column (SESSION-001 behavior).
+        const reloadedTree = sessionNodeManager.getSessionTree(record.agent_name, sessionId);
+        const hasOwnTree = reloadedTree.size() > 0;
+        const ownLeafCount = hasOwnTree ? reloadedTree.size() : (record.message_count ?? 0);
+        const effectiveRoot = hasOwnTree
+            ? sessionNodeManager.getSessionTreeRootHex(record.agent_name, sessionId)
+            : merkleRootAtInterruption;
+        // DB-001: check signaling status before attempting to send
+        if (signalingFor(record.agent_name)?.status === "reconnecting") {
+            logger.error("session.interrupted.seal.failed", {
+                sessionId,
+                agentName: record.agent_name,
+                reason: "signaling_reconnecting",
+                error: "directory_signaling_reconnecting",
+                correlationId,
+            });
+            return {
+                ok: false,
+                reason: "signaling_reconnecting",
+                guidance: "The directory signaling stream is reconnecting. Wait for directory_signaling to show connected in cello status before initiating seal-interrupted. The daemon reconnects automatically — no manual intervention required.",
+            };
+        }
+        // H-1: construct and K_local-sign our OWN SEAL-INTERRUPTED leaf before sending.
+        const myKeyProvider = keyProviders.get(record.agent_name);
+        if (!myKeyProvider) {
+            logger.error("session.interrupted.seal.failed", {
+                sessionId,
+                agentName: record.agent_name,
+                reason: "signing_key_unavailable",
+                error: "no_key_provider_for_agent",
+                correlationId,
+            });
+            return {
+                ok: false,
+                reason: "signing_key_unavailable",
+                guidance: "The signing key for the agent that owned this session could not be loaded. Confirm the agent's key file exists under ~/.cello/agents and restart the daemon.",
+            };
+        }
+        const ownLeaf = await buildSignedSealInterruptedLeaf(myKeyProvider, {
+            sessionId,
+            leafCount: ownLeafCount,
+            merkleRootAtInterruption: effectiveRoot,
+            signerPubkeyHex: myPubkeyHex,
+        });
+        // Send SealInterruptedRequest via directory signaling
+        const request = {
+            type: "seal_interrupted_request",
+            sessionId,
+            initiatorPubkey: myPubkeyHex,
+            counterpartyPubkey,
+            leafCountAtInterruption: ownLeafCount,
+            merkleRootAtInterruption: effectiveRoot,
+            nonce,
+        };
+        const sendResult = await sendOver(record.agent_name, request);
+        if (!sendResult.ok) {
+            logger.error("session.interrupted.seal.failed", {
+                sessionId,
+                agentName: record.agent_name,
+                reason: "seal_interrupted_counterparty_unavailable",
+                error: sendResult.reason,
+                correlationId,
+            });
+            return {
+                ok: false,
+                reason: "seal_interrupted_counterparty_unavailable",
+                guidance: "The counterparty is not currently reachable to complete the seal-interrupted flow. Retry when the counterparty is online — check their connection status via cello_status.",
+            };
+        }
+        // Wait for counterparty ack/rejection via the shared signaling await machinery.
+        const ackResult = await awaitSealAck(sessionId, signalingFor(record.agent_name));
+        if (ackResult.type === "timeout") {
+            logger.error("session.interrupted.seal.failed", {
+                sessionId,
+                agentName: record.agent_name,
+                reason: "seal_interrupted_counterparty_unavailable",
+                error: "seal_interrupted_response_timeout",
+                correlationId,
+            });
+            return {
+                ok: false,
+                reason: "seal_interrupted_counterparty_unavailable",
+                guidance: "The counterparty is not currently reachable to complete the seal-interrupted flow. Retry when the counterparty is online — check their connection status via cello_status.",
+            };
+        }
+        if (ackResult.type === "seal_interrupted_rejection") {
+            logger.error("session.interrupted.seal.failed", {
+                sessionId,
+                agentName: record.agent_name,
+                reason: "seal_interrupted_rejected_by_counterparty",
+                error: ackResult.reason,
+                correlationId,
+            });
+            return {
+                ok: false,
+                reason: "seal_interrupted_rejected_by_counterparty",
+                guidance: "The counterparty rejected the seal-interrupted request. This may indicate their session state is inconsistent. Ask the counterparty to check their interrupted sessions via cello status on their end.",
+            };
+        }
+        // ackResult.type === "seal_interrupted_ack"
+        {
+            const leaf = ackResult.sealInterruptedLeaf;
+            // C-1 / SI-002 / SI-003: nonce (L-2), leafCount agreement, and the
+            // counterparty's own Ed25519 signature are verified by the shared helper.
+            // We compare against our OWN ownLeafCount (an independent value) so a real
+            // divergence in transcript length is caught. Merkle-root agreement is NOT
+            // verified at this leaf-exchange layer (it is the FROST-seal step's job
+            // against the directory-held tree); see the H-1 SCOPE note above.
+            const verified = verifyCounterpartySealLeaf({
+                leaf,
+                sentNonce: nonce,
+                ackNonce: ackResult.nonce,
+                ownLeafCount,
+                expectedCounterpartyPubkey: record.counterparty_pubkey,
+            });
+            if (!verified.ok) {
+                const reasonMap = {
+                    nonce_mismatch: "seal_interrupted_nonce_mismatch",
+                    leaf_count_mismatch: "seal_interrupted_leaf_count_mismatch",
+                    leaf_signature_invalid: "seal_interrupted_leaf_signature_invalid",
+                };
+                const guidanceMap = {
+                    nonce_mismatch: "The counterparty's acknowledgement did not echo the expected nonce. This indicates a stale or replayed response. The session remains interrupted — retry cello_close_session.",
+                    leaf_count_mismatch: "The counterparty's recorded message count at interruption does not match ours. The two sides have divergent session histories and cannot form a bilateral commitment. Compare cello status on both ends before retrying.",
+                    leaf_signature_invalid: "The counterparty's SEAL-INTERRUPTED leaf signature did not verify. The seal flow has been aborted. The session remains interrupted — retry cello_close_session after confirming the counterparty is using a compatible version.",
+                };
+                logger.error("session.interrupted.seal.failed", {
+                    sessionId,
+                    agentName: record.agent_name,
+                    reason: reasonMap[verified.reason],
+                    error: verified.error,
+                    correlationId,
+                });
+                return { ok: false, reason: reasonMap[verified.reason], guidance: guidanceMap[verified.reason] };
+            }
+            // H-1: signature + nonce + cross-checks all passed. We have a VERIFIED
+            // bilateral commitment (both K_local-signed leaves over the same
+            // {leafCount, merkleRoot}). Persist BOTH leaves and advance the session to
+            // the NON-TERMINAL 'seal_interrupted_pending' state. We do NOT write
+            // 'sealed' — the FROST threshold notarization has not run (see the H-1
+            // SCOPE note above for exactly what blocks it).
+            const advanced = sessionNodeManager.persistSealInterruptedCommitment({
+                agentName: record.agent_name,
+                sessionId,
+                role: "initiator",
+                ownLeaf,
+                counterpartyLeaf: leaf,
+                merkleRoot: effectiveRoot,
+                nonce,
+            });
+            if (!advanced) {
+                logger.error("session.interrupted.seal.failed", {
+                    sessionId,
+                    agentName: record.agent_name,
+                    reason: "seal_interrupted_persist_failed",
+                    error: "session row was not in 'interrupted' state at commit time",
+                    correlationId,
+                });
+                return {
+                    ok: false,
+                    reason: "seal_interrupted_persist_failed",
+                    guidance: "The bilateral commitment could not be persisted because the session was no longer in the interrupted state. Re-check cello status — it may already be pending or sealed.",
+                };
+            }
+            logger.info("session.interrupted.pending", {
+                sessionId,
+                agentName: record.agent_name,
+                leafCount: ownLeafCount,
+                correlationId,
+            });
+            return { ok: true, sessionId, status: "seal_interrupted_pending" };
+        }
+    }
+    // ─── CELLO-M7-DAEMON-004: active-session seal initiation ─────────────────────
+    //
+    // Pseudocode (SPARC Phase P):
+    //   1. DB-002: if signaling reconnecting → return signaling_reconnecting and do
+    //      NOT initiate a partial seal that cannot be notarized.
+    //   2. SI-001: read the merkle root from the daemon's OWN tree (never a caller param).
+    //   3. K_local-sign a SEAL ctrl leaf over that root (SI-003: signed by our own node).
+    //   4. Fire session.seal.initiated with rootHex == our own tree root, role:'initiator'.
+    //   5. Submit the SEAL to the relay/counterparty + coordinate FROST via signaling,
+    //      reusing the same signaling stream the interrupted-seal flow (SESSION-001) uses.
+    //      The bilateral counterparty ack + FROST threshold notarization complete the
+    //      seal end-to-end (AC-004, exercised under CELLO_E2E_LIVE) — the daemon never
+    //      synthesizes the counterparty's signature.
+    // round-2 [medium]: the IPC return status MUST match the persisted row. The
+    // active-seal flow advances the session to 'seal_interrupted_pending' (the same
+    // non-terminal bilateral-commitment state the interrupted flow uses); returning
+    // a distinct 'seal_initiated' here meant the close response and a subsequent
+    // cello_status / cello_list_sessions showed two names for one state. One name.
+    async function handleActiveSealFlow(sessionId, record, correlationId) {
+        const agent = agents.find((a) => a.name === record.agent_name);
+        const myPubkeyHex = agent?.pubkey ?? "";
+        const kp = keyProviders.get(record.agent_name);
+        // DB-002: never initiate a partial seal while signaling is reconnecting.
+        if (signalingFor(record.agent_name)?.status === "reconnecting") {
+            return {
+                ok: false,
+                reason: "signaling_reconnecting",
+                guidance: "The directory signaling stream is reconnecting. Wait for directory_signaling to show connected in cello status before retrying the close. The daemon reconnects automatically.",
+            };
+        }
+        if (!kp || !myPubkeyHex) {
+            logger.error("session.seal.initiate.failed", {
+                sessionId,
+                reason: "signing_key_unavailable",
+                errorMessage: "no key provider or pubkey for the agent that owns this session",
+                correlationId,
+            });
+            return {
+                ok: false,
+                reason: "signing_key_unavailable",
+                guidance: "The signing key for the agent that owns this session could not be loaded. Confirm the agent's key file exists under ~/.cello/agents and restart the daemon.",
+            };
+        }
+        // SI-001: the root is the daemon's OWN tree root — computed from the leaves it
+        // appended itself. Any caller-supplied merkleRoot is never read here.
+        const ownRootHex = sessionNodeManager.getSessionTreeRootHex(record.agent_name, sessionId);
+        const leafCount = sessionNodeManager.getSessionTree(record.agent_name, sessionId).size();
+        const nonce = randomUUID();
+        // SI-003: K_local-sign our OWN SEAL leaf over our own root. We reuse the
+        // wired SEAL-INTERRUPTED leaf shape so the counterparty co-signs an identical
+        // canonical form (the active and interrupted bilateral exchanges share the
+        // directory pass-through routing — there is no separate `seal_request`
+        // transport, and inventing one silently drops the frame at the directory).
+        let ownLeaf;
+        try {
+            ownLeaf = await buildSignedSealInterruptedLeaf(kp, {
+                sessionId,
+                leafCount,
+                merkleRootAtInterruption: ownRootHex,
+                signerPubkeyHex: myPubkeyHex,
+            });
+        }
+        catch (err) {
+            logger.error("session.seal.initiate.failed", {
+                sessionId,
+                reason: "seal_leaf_signing_failed",
+                errorMessage: err instanceof Error ? err.message : String(err),
+                correlationId,
+            });
+            return {
+                ok: false,
+                reason: "seal_leaf_signing_failed",
+                guidance: "The SEAL leaf could not be signed. Check the daemon logs for the signing error and confirm the agent key is intact.",
+            };
+        }
+        // AC-003: session.seal.initiated — rootHex MUST equal the daemon's own root.
+        logger.info("session.seal.initiated", {
+            sessionId,
+            rootHex: ownRootHex,
+            role: "initiator",
+            correlationId,
+        });
+        // Submit the SEAL request over the directory signaling stream (the SAME wired
+        // pass-through the interrupted-seal flow uses) and AWAIT the counterparty's
+        // bilateral ack. We never report success on a fire-and-forget send.
+        const sendResult = await sendOver(record.agent_name, {
+            type: "seal_interrupted_request",
+            sessionId,
+            initiatorPubkey: myPubkeyHex,
+            counterpartyPubkey: record.counterparty_pubkey,
+            leafCountAtInterruption: leafCount,
+            merkleRootAtInterruption: ownRootHex,
+            nonce,
+        });
+        if (!sendResult.ok) {
+            logger.error("session.seal.initiate.failed", {
+                sessionId,
+                reason: sendResult.reason,
+                errorMessage: sendResult.reason,
+                correlationId,
+            });
+            return {
+                ok: false,
+                reason: sendResult.reason ?? "directory_unreachable",
+                guidance: "guidance" in sendResult && typeof sendResult.guidance === "string"
+                    ? sendResult.guidance
+                    : "The seal could not be submitted to the directory. Retry once cello status shows directory_signaling connected.",
+            };
+        }
+        // Wait for the counterparty's bilateral ack (or rejection / timeout).
+        const ackResult = await awaitSealAck(sessionId, signalingFor(record.agent_name));
+        if (ackResult.type === "timeout" || ackResult.type === "seal_interrupted_rejection") {
+            const reason = ackResult.type === "timeout" ? "seal_counterparty_unavailable" : "seal_rejected_by_counterparty";
+            logger.error("session.seal.initiate.failed", {
+                sessionId,
+                reason,
+                errorMessage: ackResult.type === "timeout" ? "seal_response_timeout" : ackResult.reason,
+                correlationId,
+            });
+            return {
+                ok: false,
+                reason,
+                guidance: ackResult.type === "timeout"
+                    ? "The counterparty did not acknowledge the seal in time. Retry when they are online — check cello_status. The session remains active and usable."
+                    : "The counterparty rejected the seal request. Their session state may be inconsistent. Ask them to check cello status before retrying.",
+            };
+        }
+        // SI-002 / SI-003: verify the counterparty's own-signed ack leaf over our root.
+        const verified = verifyCounterpartySealLeaf({
+            leaf: ackResult.sealInterruptedLeaf,
+            sentNonce: nonce,
+            ackNonce: ackResult.nonce,
+            ownLeafCount: leafCount,
+            expectedCounterpartyPubkey: record.counterparty_pubkey,
+        });
+        if (!verified.ok) {
+            logger.error("session.seal.initiate.failed", {
+                sessionId,
+                reason: `seal_${verified.reason}`,
+                errorMessage: verified.error,
+                correlationId,
+            });
+            return {
+                ok: false,
+                reason: `seal_${verified.reason}`,
+                guidance: "The counterparty's seal acknowledgement failed verification (nonce, leaf count, or signature). The session remains active — retry cello_close_session once both sides agree on the transcript.",
+            };
+        }
+        // Verified bilateral commitment over the daemon's OWN root. Persist both
+        // signed leaves and advance the session out of 'active'. As in the
+        // interrupted flow, we stop at the bilateral commitment ('seal_interrupted_pending');
+        // the FROST threshold notarization that finalizes 'sealed' is the deferred
+        // directory step (AC-004, exercised under CELLO_E2E_LIVE).
+        const advanced = sessionNodeManager.persistSealInterruptedCommitment({
+            agentName: record.agent_name,
+            sessionId,
+            role: "initiator",
+            ownLeaf,
+            counterpartyLeaf: ackResult.sealInterruptedLeaf,
+            merkleRoot: ownRootHex,
+            nonce,
+        });
+        if (!advanced) {
+            logger.error("session.seal.initiate.failed", {
+                sessionId,
+                reason: "seal_persist_failed",
+                errorMessage: "session row was not in an active/interrupted state at commit time",
+                correlationId,
+            });
+            return {
+                ok: false,
+                reason: "seal_persist_failed",
+                guidance: "The bilateral seal commitment could not be persisted because the session changed state. Re-check cello status — it may already be pending or sealed.",
+            };
+        }
+        // round-2 finding #5: the session is now frozen at 'seal_interrupted_pending'.
+        // Retire its live libp2p node so no further inbound content can arrive (which
+        // ingestReceivedContent now also rejects) and so the node is not leaked per
+        // active close. retireSessionNode stops the node WITHOUT changing the DB status.
+        await sessionNodeManager.retireSessionNode(record.agent_name, sessionId);
+        return { ok: true, sessionId, status: "seal_interrupted_pending", rootHex: ownRootHex };
+    }
+    return { awaitSealAck, handleSealInterruptedFlow, handleActiveSealFlow };
+}
+//# sourceMappingURL=seal-flows.js.map

package/dist/seal-flows.js.map

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

package/dist/seal-frontier-verify.d.ts

@@ -1,5 +1,5 @@
 /**
- * DOD-LEG-2 (SESSION-004 SI-002) — client-side content-frontier re-derivation.
+ * Client-side content-frontier re-derivation.
  *
  * The directory builds + signs the seal legibility, including each party's
  * `content_frontier_seq` ("the highest message the party provably received"). The client
@@ -65,12 +65,12 @@ export interface UnilateralFrontierCheck {
      *  - verified:           leaves present, no CLIENT-VERIFIABLE ('live') frontier exceeded its leaves.
      *  - corrected:          leaves present, one or more 'live' frontiers were inflated and overridden
      *                        DOWN to the re-derived value (see `corrections`).
-     *  - directory_attested: no frontier_leaves shipped (a pre-FINDING-5 directory) — the cert stays
-     *                        directory-attested (FINDING-3 behavior). No correction possible.
+     *  - directory_attested: no frontier_leaves shipped (an older directory) — the cert stays
+     *                        directory-attested. No correction possible.
      *  - leaves_invalid:     frontier_leaves are forged / cross-session (reDeriveFrontiers failed) — a
      *                        tamper signal; persist the directory-attested frontiers, log loudly. NEVER
-     *                        rejected (the unilateral dedup guard makes rejection an unrecoverable
-     *                        dead-end — cascade-2 reviewer Critical 2).
+     *                        rejected: the unilateral dedup guard makes rejection an unrecoverable
+     *                        dead-end.
      */
     status: "verified" | "corrected" | "directory_attested" | "leaves_invalid";
     /** lowercased pubkey → corrected content_frontier_seq, for inflated 'live' parties. The caller
@@ -79,14 +79,14 @@ export interface UnilateralFrontierCheck {
     reason?: string;
 }
 /**
- * FINDING-5 — the present party independently re-verifies (and CORRECTS) the UNILATERAL receipt's
- * frontiers. OVERRIDE, never reject.
+ * The present party independently re-verifies (and CORRECTS) the UNILATERAL receipt's frontiers.
+ * OVERRIDE, never reject.
  *
  * The unilateral legibility is FROST-notarized by the directory but the frontier VALUES are NOT bound
  * into the seal signature (unlike the bilateral seal, whose signer binds the legibility hash), so the
  * client must not trust them blindly. Because the directory-side dedup guard makes a client REJECTION
- * of a unilateral cert unrecoverable (a retry close is silently ignored — no receipt ever produced,
- * worse than FINDING-3), the client CORRECTS rather than rejects:
+ * of a unilateral cert unrecoverable (a retry close is silently ignored — no receipt is ever
+ * produced), the client CORRECTS rather than rejects:
  *   - CLIENT-VERIFIABLE ('live') party: the present (submitting) party carries all its own signed
  *     leaves, so its content_frontier_seq is fully re-derivable. The directory cannot forge signed
  *     leaves, so the re-derived value is the provable truth → an inflated published value is OVERRIDDEN

package/dist/seal-frontier-verify.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"seal-frontier-verify.d.ts","sourceRoot":"","sources":["../src/seal-frontier-verify.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAKH,MAAM,WAAW,gBAAgB;IAC/B,eAAe,EAAE,UAAU,CAAC;IAC5B,aAAa,EAAE,UAAU,CAAC;IAC1B,gBAAgB,EAAE,UAAU,CAAC;CAC9B;AAED,MAAM,MAAM,cAAc,GACtB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GAC5C;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,wBAAwB,GAAG,gBAAgB,GAAG,uBAAuB,CAAA;CAAE,CAAC;AAQjG;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,gBAAgB,EAAE,EAAE,iBAAiB,EAAE,UAAU,GAAG,cAAc,CA0B3G;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,YAAY,EAAE,aAAa,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,oBAAoB,EAAE,MAAM,CAAA;CAAE,CAAC,EAC7E,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAC3B;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,iBAAiB,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAQ9E;AAID,MAAM,WAAW,6BAA6B;IAC5C,MAAM,EAAE,MAAM,CAAC;IACf,oBAAoB,EAAE,MAAM,CAAC;IAC7B,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,uBAAuB;IACtC;;;;;;;;;;OAUG;IACH,MAAM,EAAE,UAAU,GAAG,WAAW,GAAG,oBAAoB,GAAG,gBAAgB,CAAC;IAC3E;kHAC8G;IAC9G,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,uBAAuB,CACrC,YAAY,EAAE,aAAa,CAAC,6BAA6B,CAAC,EAC1D,cAAc,EAAE,gBAAgB,EAAE,GAAG,SAAS,EAC9C,SAAS,EAAE,UAAU,GACpB,uBAAuB,CAyBzB"}
+{"version":3,"file":"seal-frontier-verify.d.ts","sourceRoot":"","sources":["../src/seal-frontier-verify.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAKH,MAAM,WAAW,gBAAgB;IAC/B,eAAe,EAAE,UAAU,CAAC;IAC5B,aAAa,EAAE,UAAU,CAAC;IAC1B,gBAAgB,EAAE,UAAU,CAAC;CAC9B;AAED,MAAM,MAAM,cAAc,GACtB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GAC5C;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,wBAAwB,GAAG,gBAAgB,GAAG,uBAAuB,CAAA;CAAE,CAAC;AAQjG;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,gBAAgB,EAAE,EAAE,iBAAiB,EAAE,UAAU,GAAG,cAAc,CA0B3G;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,YAAY,EAAE,aAAa,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,oBAAoB,EAAE,MAAM,CAAA;CAAE,CAAC,EAC7E,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAC3B;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,iBAAiB,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAQ9E;AAID,MAAM,WAAW,6BAA6B;IAC5C,MAAM,EAAE,MAAM,CAAC;IACf,oBAAoB,EAAE,MAAM,CAAC;IAC7B,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,uBAAuB;IACtC;;;;;;;;;;OAUG;IACH,MAAM,EAAE,UAAU,GAAG,WAAW,GAAG,oBAAoB,GAAG,gBAAgB,CAAC;IAC3E;kHAC8G;IAC9G,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,uBAAuB,CACrC,YAAY,EAAE,aAAa,CAAC,6BAA6B,CAAC,EAC1D,cAAc,EAAE,gBAAgB,EAAE,GAAG,SAAS,EAC9C,SAAS,EAAE,UAAU,GACpB,uBAAuB,CAwBzB"}

package/dist/seal-frontier-verify.js

@@ -1,5 +1,5 @@
 /**
- * DOD-LEG-2 (SESSION-004 SI-002) — client-side content-frontier re-derivation.
+ * Client-side content-frontier re-derivation.
  *
  * The directory builds + signs the seal legibility, including each party's
  * `content_frontier_seq` ("the highest message the party provably received"). The client
@@ -85,14 +85,14 @@ export function findInflatedFrontier(participants, derived) {
     return null;
 }
 /**
- * FINDING-5 — the present party independently re-verifies (and CORRECTS) the UNILATERAL receipt's
- * frontiers. OVERRIDE, never reject.
+ * The present party independently re-verifies (and CORRECTS) the UNILATERAL receipt's frontiers.
+ * OVERRIDE, never reject.
  *
  * The unilateral legibility is FROST-notarized by the directory but the frontier VALUES are NOT bound
  * into the seal signature (unlike the bilateral seal, whose signer binds the legibility hash), so the
  * client must not trust them blindly. Because the directory-side dedup guard makes a client REJECTION
- * of a unilateral cert unrecoverable (a retry close is silently ignored — no receipt ever produced,
- * worse than FINDING-3), the client CORRECTS rather than rejects:
+ * of a unilateral cert unrecoverable (a retry close is silently ignored — no receipt is ever
+ * produced), the client CORRECTS rather than rejects:
  *   - CLIENT-VERIFIABLE ('live') party: the present (submitting) party carries all its own signed
  *     leaves, so its content_frontier_seq is fully re-derivable. The directory cannot forge signed
  *     leaves, so the re-derived value is the provable truth → an inflated published value is OVERRIDDEN
@@ -108,17 +108,16 @@ export function findInflatedFrontier(participants, derived) {
 export function checkUnilateralFrontier(participants, frontierLeaves, sessionId) {
     const corrections = new Map();
     const haveLeaves = Array.isArray(frontierLeaves) && frontierLeaves.length > 0;
-    // Pre-FINDING-5 directory (no leaves): keep FINDING-3's directory-attested behavior. Never reject —
-    // rejecting would regress the shipped FINDING-3 receipt and break unilateral seals against a
-    // not-yet-upgraded directory during rollout.
+    // A directory that ships no leaves leaves the cert directory-attested. Never reject — rejecting
+    // would break unilateral seals against a not-yet-upgraded directory during rollout.
     if (!haveLeaves)
         return { status: "directory_attested", corrections };
     const rederived = reDeriveFrontiers(frontierLeaves, sessionId);
     // Forged / cross-session leaves are the STRONGEST tamper evidence, so they get the strongest
-    // correction — treat them as ZERO trustworthy evidence (an empty derived map), which drives any
-    // 'live' frontier > 0 down to 0. (Leaving the published value untouched would make malformed leaves
-    // an EASIER inflation bypass than shipping none — cascade-2 re-review.) We still never REJECT
-    // (the directory dedup guard makes rejection an unrecoverable dead-end); the caller logs loudly.
+    // correction: treat them as ZERO trustworthy evidence (an empty derived map), which drives any
+    // 'live' frontier > 0 down to 0. Do NOT leave the published value untouched on invalid leaves —
+    // that would make malformed leaves an EASIER inflation bypass than shipping none. Still never
+    // REJECT (the directory dedup guard makes rejection an unrecoverable dead-end); the caller logs.
     const derived = rederived.ok ? rederived.frontiers : new Map();
     // Only CLIENT-VERIFIABLE ('live') parties are re-derivable; override any value above the provable
     // one DOWN to it. The absent party is directory-attested (its remainder is not re-derivable here).