@cello-protocol/daemon 0.0.227 → 0.0.228

package/dist/inclusion-proof-handlers.js

@@ -0,0 +1,565 @@
+/**
+ * `cello_get_inclusion_proof` and `cello_verify_inclusion_proof` — the two halves of proving that
+ * ONE sentence is in a sealed conversation.
+ *
+ * Until `DOD-M15-INCLUSION-1` the first of these was a registered tool that returned
+ * `not_implemented`. That was honest, and it cost the product its central claim: an operator could
+ * say *"this conversation was notarized"* and could not say *"and here is the proof the sentence you
+ * are disputing is in it, unaltered."*
+ *
+ * ─── THE TWO THINGS THAT MAKE THIS A PROOF ────────────────────────────────────────────────────
+ *
+ * **The path is built over the CERTIFIED leaf set, not the local tree.** They are different trees.
+ * `SessionTree` holds content leaves; the certified root covers the seal's CONTROL leaves too. A
+ * path built from the local tree lands on a root no certificate names — proving only that this
+ * machine agrees with itself, which is worth nothing to the third party the proof is for. The
+ * certified set is stored at seal time only after it reproduces the FROST-signed root
+ * (`sealed-leaf-set.ts`), so it is the consortium's leaf set and not the directory's word for it.
+ *
+ * **The leaf is recomputed from the operator's message.** The daemon's own `contentHashFor` derives
+ * it; the proof carries the algorithm name and the session salt so a stranger can repeat the
+ * derivation. Change one byte of the message and the leaf changes and the proof fails, which is the
+ * assertion this feature exists to make.
+ *
+ * ─── WHY THE VERIFY HALF IS A TOOL AND NOT A DOCUMENT ─────────────────────────────────────────
+ *
+ * A proof nobody can check is a data structure. `cello_verify_inclusion_proof` reads no session, no
+ * certificate store and no tree — proof, message, root, and nothing else — so it answers for a
+ * session this daemon has never seen, on a machine that has never spoken to the counterparty.
+ */
+import { CONTENT_HASH_ALGS, contentHashFor } from "./wire-content-hash.js";
+import { proofPathFor, rootOverLeafHashes, verifyInclusionProof, } from "./inclusion-proof.js";
+/** How a caller checks a proof — named in every success response, because a proof nobody runs is inert. */
+const VERIFY_AFFORDANCE = "To check this, call cello_verify_inclusion_proof with { proof, message, certified_root }, where " +
+    "certified_root is the sealed_root from cello_sealed_receipt — NOT the root inside the proof. It " +
+    "needs no access to this daemon, so a third party can run it against the certificate you give them.";
+export function registerInclusionProofHandlers(deps) {
+    const { handlers, logger, sessionNodeManager, getConnState, resolveCurrentAgent, NO_CURRENT_AGENT_RESPONSE } = deps;
+    handlers.set("cello_get_inclusion_proof", async (params, connectionId) => {
+        const sessionId = params?.["session_id"];
+        if (!sessionId || typeof sessionId !== "string") {
+            return {
+                ok: false,
+                reason: "missing_session_id",
+                guidance: "Provide the session_id (hex) of the sealed session. cello_sessions lists the full ids.",
+            };
+        }
+        const message = params?.["message"];
+        if (typeof message !== "string" || message.length === 0) {
+            return {
+                ok: false,
+                reason: "missing_message",
+                guidance: "Provide { message } — the EXACT text of the message you want to prove, copied from " +
+                    `cello_transcript ${sessionId}. The proof is over the message's bytes, so a paraphrase, a ` +
+                    "trimmed quote, or added whitespace produces a different message and will not be found.",
+            };
+        }
+        const connState = getConnState(connectionId);
+        const agentName = resolveCurrentAgent(connState, params?.["agent"]);
+        if (!agentName)
+            return NO_CURRENT_AGENT_RESPONSE;
+        // ─── Is there a certificate at all? "not sealed" and "unknown" are different situations ─────
+        const cert = sessionNodeManager.getSealCertificate(agentName, sessionId);
+        if (!cert) {
+            if (!sessionNodeManager.getSessionRecord(agentName, sessionId)) {
+                return {
+                    ok: false,
+                    reason: "unknown_session",
+                    guidance: "No session with this id belongs to the current agent. Run cello_sessions to see the full ids.",
+                };
+            }
+            return {
+                ok: false,
+                reason: "not_sealed_yet",
+                guidance: "There is no certificate for this session yet, so there is no notarized root for a proof to " +
+                    `land on. Close it with cello_close_session ${sessionId} and retry once cello_sealed_receipt ` +
+                    "reports a sealed_root. A proof against this machine's own record would prove only that this " +
+                    "machine agrees with itself, so none is issued.",
+            };
+        }
+        // ─── The certified leaf set: the tree the signature actually covers ─────────────────────────
+        const certifiedLeaves = sessionNodeManager.getCertifiedLeafSet(agentName, sessionId);
+        if (!certifiedLeaves) {
+            return missingLeafSetRefusal(logger, sessionNodeManager.getCertifiedLeafSetState(agentName, sessionId), agentName, sessionId, cert.sealed_root);
+        }
+        /**
+         * RE-PROVE THE STORED SET AGAINST THE CERTIFICATE ON EVERY READ.
+         *
+         * It was already proved at seal time, and that check ran against the seal frame. This one runs
+         * against the DATABASE — the two are not the same claim. The local store is a SQLCipher file on
+         * the operator's own disk, which is the thing a sceptic is entitled to doubt, and re-deriving
+         * costs one Merkle build over an already-sealed session.
+         */
+        const storedRoot = rootOverLeafHashes(certifiedLeaves);
+        if (storedRoot !== cert.sealed_root.toLowerCase()) {
+            logger.error("inclusion.certified_leaves.root_mismatch", {
+                agentName,
+                sessionId,
+                storedRoot,
+                certifiedRoot: cert.sealed_root,
+                impact: "the leaf set held for this session no longer hashes to the certified root, so no proof " +
+                    "can be issued from it — the local copy has changed since the seal",
+            });
+            return {
+                ok: false,
+                reason: "certified_leaves_root_mismatch",
+                sealed_root: cert.sealed_root,
+                guidance: "The leaf set stored on this machine no longer reproduces the root in the certificate, so " +
+                    "nothing here can be proved against it. The certificate itself is untouched and still valid " +
+                    "— take it and the counterparty's copy of the conversation to establish what was said. Do " +
+                    "not treat any proof from this machine as reliable until that is resolved.",
+            };
+        }
+        /**
+         * DOES THIS AGENT'S OWN RECORD AGREE WITH WHAT WAS CERTIFIED? — and a disagreement REFUSES.
+         *
+         * The certified set opens with the content leaves in canonical order and ends with the seal's
+         * control leaves, so this side's tree should be a prefix of it. When it is not, the operator's
+         * transcript and the notarized record are two different conversations. Emitting a proof anyway
+         * would be true about the certified leaf and misleading about the message the operator is
+         * reading, which is worse than refusing.
+         */
+        const tree = sessionNodeManager.getSessionTree(agentName, sessionId);
+        const localSize = tree.size();
+        if (localSize > certifiedLeaves.length) {
+            return divergenceRefusal(logger, agentName, sessionId, cert.sealed_root, {
+                detail: `this side holds ${localSize} content leaves and the certificate covers only ${certifiedLeaves.length} leaves in total`,
+            });
+        }
+        for (let i = 0; i < localSize; i++) {
+            const local = tree.hashAt(i);
+            if (local !== certifiedLeaves[i]) {
+                return divergenceRefusal(logger, agentName, sessionId, cert.sealed_root, {
+                    detail: `leaf ${i} of this side's record is ${local ?? "absent"} and the certified leaf at that position is ${certifiedLeaves[i]}`,
+                });
+            }
+        }
+        /**
+         * ─── The salt, without which a proof is about a number rather than a sentence ───────────────
+         *
+         * `getSessionContentSaltState`, NOT `getSessionContentSalt` — fallback-finder finding 2. The
+         * plain accessor answers `null` for a session that never agreed a salt AND for one whose salt
+         * row is corrupt or unreadable, and those need opposite sentences: the first is a fact about the
+         * conversation, the second is damage to this operator's own database, and telling them the
+         * second is the first sends them to their counterparty over a local disk problem.
+         */
+        const saltState = sessionNodeManager.getSessionContentSaltState(agentName, sessionId);
+        if (saltState.salt === null && saltState.reason === "unreadable") {
+            logger.error("inclusion.salt.unreadable", {
+                agentName,
+                sessionId,
+                impact: "this session HOLDS a salt that could not be read, so its messages cannot be re-hashed and " +
+                    "no inclusion proof can be issued — the conversation and its receipt are unaffected",
+            });
+            return {
+                ok: false,
+                reason: "session_salt_unreadable",
+                sealed_root: cert.sealed_root,
+                guidance: "This session DOES have a salt and this machine could not read it, so the message cannot be " +
+                    "re-hashed and no proof can be issued. THIS IS A PROBLEM WITH THIS MACHINE'S DATABASE, not " +
+                    "with the session, the counterparty or their build — do not ask them to upgrade and do not " +
+                    "start a new session to fix it. Look for session.salt.read.failed in the daemon log; it " +
+                    "names the row. The receipt itself is unaffected and still proves the conversation sealed.",
+            };
+        }
+        if (saltState.salt === null) {
+            return {
+                ok: false,
+                reason: "session_unsalted",
+                sealed_root: cert.sealed_root,
+                guidance: "This session's content hashes are UNSALTED, and no proof is issued over one. An unsalted " +
+                    "leaf is sha256 of the message, which anyone holding a copy of the text can recompute — so " +
+                    "it links this message to every other record carrying the same words, which is what the " +
+                    "session salt exists to prevent. cello_sealed_receipt reports a session's salt state; a " +
+                    "session opened while both agents are connected agrees one at open.",
+            };
+        }
+        const salt = saltState.salt;
+        const messageBytes = new TextEncoder().encode(message);
+        const leafHash = Buffer.from(contentHashFor(messageBytes, { alg: CONTENT_HASH_ALGS.HMAC_SALT_V1, salt })).toString("hex");
+        /**
+         * WHICH LEAF — and identical text twice is two messages, not one.
+         *
+         * `SessionTree.indexOfHash` answers "is this content anywhere", and `DOD-FRONTIER-STRAND-1`
+         * already paid for treating that as "is this content at THIS position": a session stranded
+         * because a genuine second send of the same words was dropped as a redelivery. So a repeated
+         * message is not resolved by picking the first — it is refused with the candidate positions, and
+         * the caller says which one they mean.
+         */
+        const matches = [];
+        for (let i = 0; i < certifiedLeaves.length; i++)
+            if (certifiedLeaves[i] === leafHash)
+                matches.push(i);
+        const requestedIndex = params?.["leaf_index"];
+        let leafIndex;
+        if (requestedIndex !== undefined && requestedIndex !== null) {
+            if (typeof requestedIndex !== "number" || !Number.isInteger(requestedIndex) || requestedIndex < 0) {
+                return {
+                    ok: false,
+                    reason: "invalid_leaf_index",
+                    guidance: `leaf_index must be a whole number 0 or greater. Omit it unless a previous call reported this message at more than one position.`,
+                };
+            }
+            if (certifiedLeaves[requestedIndex] !== leafHash) {
+                return {
+                    ok: false,
+                    reason: "leaf_index_mismatch",
+                    leaf_index: requestedIndex,
+                    candidate_leaf_indices: matches,
+                    guidance: matches.length > 0
+                        ? `The certified leaf at position ${requestedIndex} is not this message. This message is at ${matches.join(", ")} — retry with one of those.`
+                        : `The certified leaf at position ${requestedIndex} is not this message, and this message is not at any position in this session. Copy the text exactly from cello_transcript ${sessionId}.`,
+                };
+            }
+            leafIndex = requestedIndex;
+        }
+        else if (matches.length === 0) {
+            /**
+             * BEFORE ASSERTING ABSENCE, CHECK THE OTHER ALGORITHM — review F5, error substitution.
+             *
+             * This handler picks the hash algorithm from salt POSSESSION, and possession is not the same
+             * as use: `#suspendSalt` deliberately keeps the salt bytes on disk while the session hashes
+             * `sha256`, so a session can hold salted leaves next to unsalted ones. For any leaf on the
+             * other side of that split, "no match" is this daemon having guessed the algorithm — and the
+             * guidance said *"this message is genuinely not in this sealed conversation"*, which is an
+             * affirmatively false statement about the product's central claim wearing an exit-point label.
+             *
+             * One extra hash buys the distinction. Finding the message under the other algorithm does NOT
+             * produce a proof: this build issues salted proofs only (DoD 8), and an unsalted leaf is a
+             * value anyone holding the plaintext can recompute. It produces a REFUSAL that names what
+             * actually happened.
+             */
+            const unsaltedHash = Buffer.from(contentHashFor(messageBytes, { alg: CONTENT_HASH_ALGS.SHA256, salt: null })).toString("hex");
+            const unsaltedAt = certifiedLeaves.indexOf(unsaltedHash);
+            if (unsaltedAt !== -1) {
+                logger.error("inclusion.alg.split", {
+                    agentName,
+                    sessionId,
+                    leafIndex: unsaltedAt,
+                    impact: "this message is in the notarized record but was hashed UNSALTED while the session holds " +
+                        "a salt, so the two halves of this conversation are verifiable under different rules and " +
+                        "no salted proof can be issued for this one",
+                });
+                return {
+                    ok: false,
+                    reason: "message_hashed_under_other_alg",
+                    sealed_root: cert.sealed_root,
+                    leaf_index: unsaltedAt,
+                    leaf_count: certifiedLeaves.length,
+                    guidance: `THIS MESSAGE IS IN THE SEALED RECORD — at position ${unsaltedAt} — and it was hashed ` +
+                        "WITHOUT this session's salt, while the session holds one. That happens when a session " +
+                        "stopped using its salt partway through, so half the conversation is verifiable under one " +
+                        "rule and half under another. No proof is issued for this message because an unsalted one " +
+                        "carries weaker protection than this build will put its name to. Do NOT conclude the " +
+                        "message is absent — it is not. Report the session id and this reason; messages hashed " +
+                        "under the salt can still be proved normally.",
+                };
+            }
+            return {
+                ok: false,
+                reason: "message_not_in_session",
+                sealed_root: cert.sealed_root,
+                leaf_count: certifiedLeaves.length,
+                guidance: `No leaf in this session's notarized record is this message, under either the salted or the ` +
+                    `unsalted hash. Copy the text exactly from cello_transcript ${sessionId} — the proof is over ` +
+                    "the bytes, so a changed character, a trimmed quote or a trailing newline is a different " +
+                    "message. If the text IS exact, this message is genuinely not in this sealed conversation.",
+            };
+        }
+        else if (matches.length > 1) {
+            return {
+                ok: false,
+                reason: "message_ambiguous",
+                candidate_leaf_indices: matches,
+                guidance: `This exact text was sent ${matches.length} times in this session, at positions ` +
+                    `${matches.join(", ")} — they are different messages that happen to read the same, and a ` +
+                    "proof names one of them. Retry with { leaf_index } set to the one you mean.",
+            };
+        }
+        else {
+            leafIndex = matches[0];
+        }
+        const proof = {
+            version: 1,
+            session_id: sessionId,
+            certified_root: cert.sealed_root.toLowerCase(),
+            leaf_index: leafIndex,
+            leaf_count: certifiedLeaves.length,
+            leaf_hash: leafHash,
+            proof_path: proofPathFor(certifiedLeaves, leafIndex),
+            content_hash_alg: CONTENT_HASH_ALGS.HMAC_SALT_V1,
+            content_salt: Buffer.from(salt).toString("hex"),
+        };
+        /**
+         * RUN THE VERIFIER BEFORE HANDING THE PROOF OVER.
+         *
+         * ⚠️ UNREACHABLE BY CONSTRUCTION, AND THAT IS STATED RATHER THAN IMPLIED — review F8. The
+         * previous wording ("a proof that does not verify is worse than no proof") implied a live
+         * failure mode and would send a reader hunting for the path that reaches it. There is none:
+         * every field is built from values already checked above, `storedRoot === cert.sealed_root` was
+         * asserted twenty lines up, and the leaf came from `certifiedLeaves` by equality.
+         *
+         * WHAT IT CAN ACTUALLY FIRE ON: a drift between `inclusionProof` and `verifyInclusion` inside
+         * `@cello-protocol/crypto` — the two halves of one RFC 6962 implementation disagreeing. That is
+         * the failure this whole unit is written to avoid causing by hand, and it is worth one Merkle
+         * verification per issued proof to turn it into a named refusal rather than evidence that fails
+         * in front of the person it was shown to. `proof_self_check_failed` therefore has NO test: it
+         * has no reachable input, and a test that reached it would have to break the crypto package.
+         */
+        const selfCheck = verifyInclusionProof(proof, messageBytes, cert.sealed_root);
+        if (!selfCheck.ok) {
+            logger.error("inclusion.proof.self_check_failed", {
+                agentName,
+                sessionId,
+                leafIndex,
+                reason: selfCheck.reason,
+                detail: selfCheck.detail,
+                impact: "a proof was constructed for this message and did not verify against the certified root, so it was NOT returned",
+            });
+            return {
+                ok: false,
+                reason: "proof_self_check_failed",
+                detail: selfCheck.detail,
+                guidance: "This daemon built a proof for that message and it failed its own check against the " +
+                    "certified root, so nothing was returned rather than handing you evidence that would fail " +
+                    "in front of whoever you showed it to. Report the session id and this reason; the receipt " +
+                    "itself is unaffected and still valid.",
+            };
+        }
+        logger.info("inclusion.proof.issued", {
+            agentName,
+            sessionId,
+            leafIndex,
+            leafCount: certifiedLeaves.length,
+            contentHashAlg: proof.content_hash_alg,
+        });
+        return {
+            ok: true,
+            session_id: sessionId,
+            proof,
+            // Repeated outside the proof so a caller reading the response does not have to open it.
+            certified_root: proof.certified_root,
+            leaf_index: leafIndex,
+            leaf_count: certifiedLeaves.length,
+            guidance: VERIFY_AFFORDANCE,
+            /**
+             * THE PROOF CARRIES THE SESSION SALT, AND THAT IS A DISCLOSURE — review F2.
+             *
+             * The salt has to travel or the proof is about a number rather than a sentence. But it is
+             * per-SESSION, so handing over one proof hands over the ability to test guessed text against
+             * every leaf hash in that session — which is the exact capability `unsalted_proof_refused`
+             * spends four lines refusing to grant. Saying nothing here would leave this surface arguing
+             * for a privacy property while quietly trading it away.
+             */
+            discloses: "This proof CONTAINS this session's content salt, which it must in order to be checkable. " +
+                "With it, whoever holds the proof can test guessed wording against any leaf hash from this " +
+                "session — so share a proof with the same care you would share the transcript. It does not " +
+                "let them forge a message into the record, or read anything they were not given.",
+        };
+    });
+    /**
+     * THE THIRD-PARTY VERIFIER. Touches no session, no certificate store, no tree.
+     *
+     * Registered on the daemon because that is where the tool surface lives, not because it needs
+     * anything the daemon holds — which is exactly the property that lets someone who has never spoken
+     * to either party check the proof on their own machine.
+     */
+    handlers.set("cello_verify_inclusion_proof", async (params) => {
+        const rawProof = params?.["proof"];
+        if (rawProof === undefined || rawProof === null) {
+            return {
+                ok: false,
+                reason: "missing_proof",
+                guidance: "Provide { proof } — the object cello_get_inclusion_proof returned, verbatim.",
+            };
+        }
+        // Accepted as an object OR as the JSON text of one: a proof travels between people by paste, and
+        // refusing a pasted string would send the reader to reformat evidence by hand, which is the one
+        // step most likely to alter it.
+        let proof = rawProof;
+        if (typeof rawProof === "string") {
+            try {
+                proof = JSON.parse(rawProof);
+            }
+            catch {
+                return {
+                    ok: false,
+                    reason: "proof_malformed",
+                    guidance: "The proof was supplied as text and is not valid JSON. Paste the whole object " +
+                        "cello_get_inclusion_proof returned, braces included, with nothing trimmed.",
+                };
+            }
+        }
+        const message = params?.["message"];
+        if (typeof message !== "string" || message.length === 0) {
+            return {
+                ok: false,
+                reason: "missing_message",
+                guidance: "Provide { message } — the exact text being proved. Verification recomputes the message's " +
+                    "hash, so this is what makes the answer about a sentence rather than about a number.",
+            };
+        }
+        const certifiedRoot = params?.["certified_root"];
+        if (typeof certifiedRoot !== "string" || certifiedRoot.length === 0) {
+            return {
+                ok: false,
+                reason: "missing_certified_root",
+                guidance: "Provide { certified_root } — the sealed_root from the certificate (cello_sealed_receipt " +
+                    "reports it). It is REQUIRED and it must come from the certificate, never from the proof: a " +
+                    "proof checked against its own root proves only that whoever wrote it was consistent.",
+            };
+        }
+        const result = verifyInclusionProof(proof, new TextEncoder().encode(message), certifiedRoot);
+        if (!result.ok) {
+            logger.info("inclusion.proof.verify.refused", { reason: result.reason, detail: result.detail });
+            return { ok: false, reason: result.reason, detail: result.detail, guidance: result.guidance };
+        }
+        logger.info("inclusion.proof.verify.ok", {
+            sessionId: result.session_id,
+            leafIndex: result.leaf_index,
+            leafCount: result.leaf_count,
+        });
+        return {
+            ok: true,
+            verified: true,
+            session_id: result.session_id,
+            leaf_index: result.leaf_index,
+            leaf_count: result.leaf_count,
+            certified_root: result.certified_root,
+            content_hash_alg: result.content_hash_alg,
+            // Carried through so a caller cannot read `session_id` above as something that was checked.
+            // The anchor is the ROOT; nothing here binds a session id (fallback-finder finding 6).
+            session_id_verified: result.session_id_verified,
+            // WHAT THIS DOES AND DOES NOT ESTABLISH. The proof binds a message to a root; it says nothing
+            // about whether that root is the one a directory signed. Claiming more here would be the
+            // "partially true is false" failure the claims ledger exists to catch.
+            means: "This exact message is at position " + result.leaf_index + " of the " + result.leaf_count +
+                " leaves under root " + result.certified_root + " (that count includes the seal's own control " +
+                "leaves, so it is larger than the number of messages in the conversation). It has not been " +
+                "altered by a single byte. " +
+                "This does NOT by itself establish that the root is genuine — verify the certificate's own " +
+                "signature (cello_sealed_receipt) to establish that, then this proof binds the message to it. " +
+                "The session_id above is copied from the proof and was NOT checked: nothing here binds a " +
+                "session id, so treat it as a label rather than as a finding.",
+        };
+    });
+}
+/**
+ * WHY there is no certified leaf set — one reason string per cause, never one for all four.
+ *
+ * ⚠️ THIS USED TO BE A SINGLE `certified_leaves_unavailable` WHOSE GUIDANCE ASSERTED THE MOST BENIGN
+ * OF FOUR CAUSES — fallback-finder finding 1, and it is the defect this milestone is named for.
+ *
+ * `getCertifiedLeafSet` answers null when: no seal frame carried the leaves, the DIRECTORY shipped a
+ * set that does not reproduce the root its own FROST signature covers, a leaf was malformed, or the
+ * write failed. The text said *"the normal state for the party that was ABSENT at seal time … ask
+ * your counterparty."* So an operator who was present throughout, whose directory had just
+ * contradicted its own signature — the strongest misbehaviour signal this client can produce — was
+ * told they had been absent, and sent to a counterparty who has nothing to give them. The detection
+ * was correct and its only consumer was a log line.
+ *
+ * `session_certified_leaves_state` is written at every one of those four points, so the cause
+ * survives to here. A state this build does not recognise is named as such rather than folded into
+ * the nearest familiar one.
+ */
+function missingLeafSetRefusal(logger, recorded, agentName, sessionId, sealedRoot) {
+    const base = { ok: false, sealed_root: sealedRoot, ...(recorded?.detail ? { detail: recorded.detail } : {}) };
+    switch (recorded?.state) {
+        case "sealed_leaves_root_disagrees":
+            // THE LOUD ONE. Not a degradation — a party that signed one thing and shipped another.
+            logger.error("inclusion.certified_leaves.directory_disagreed", {
+                agentName, sessionId, detail: recorded.detail,
+                impact: "the leaf set delivered with this seal does not reproduce the root the consortium signed, " +
+                    "so it was refused and no message in this session can be proved from this side",
+            });
+            return {
+                ...base,
+                reason: "certified_leaves_root_disagrees",
+                guidance: "THIS IS NOT THE ORDINARY 'no leaves' CASE. The leaf set delivered with this seal does not " +
+                    "hash to the root the directory consortium signed — the same party gave two answers that " +
+                    "cannot both be true, so it was refused rather than stored. Your receipt is unaffected and " +
+                    "still proves this conversation was sealed; what is unavailable is proof about an " +
+                    "individual message. Keep the receipt, note the session id, and raise this with the " +
+                    "operator — a directory contradicting its own signature is worth investigating, not " +
+                    "retrying.",
+            };
+        case "sealed_leaves_malformed":
+            return {
+                ...base,
+                reason: "certified_leaves_malformed",
+                guidance: "The signed leaves delivered with this seal could not be read, so none were stored and no " +
+                    "message in this session can be proved from this side. The receipt is unaffected. This is " +
+                    "a version or transport problem rather than a dispute — nothing local repairs it, and " +
+                    "re-closing the session will not re-deliver them.",
+            };
+        case "persist_failed":
+            return {
+                ...base,
+                reason: "certified_leaves_persist_failed",
+                guidance: "The leaf set for this session arrived and verified, and this machine failed to write it. " +
+                    "THE FAULT IS LOCAL — do not ask your counterparty for anything. Look for " +
+                    "seal.certified_leaves.persist.failed in the daemon log; it names the write. Your " +
+                    "counterparty's copy can still issue a proof for the same messages in the meantime.",
+            };
+        case "not_carried_present_party":
+            // The false-remedy case: on this path the counterparty is the ABSENT one, who has less.
+            return {
+                ...base,
+                reason: "certified_leaves_not_carried",
+                guidance: "This seal completed with your counterparty absent, and the directory sent no signed leaves " +
+                    "with it — so NEITHER side can prove an individual message in this session. Do not ask them " +
+                    "for a proof; they were not there and hold even less than you do. Your receipt is complete " +
+                    "and still proves the conversation was sealed. Nothing local repairs this.",
+            };
+        case "not_carried_absent_party":
+            return {
+                ...base,
+                reason: "certified_leaves_unavailable",
+                guidance: "You were the ABSENT party when this session sealed, and the signed leaves only ever reach " +
+                    "the party that was present — so this side can never prove an individual message here, and " +
+                    "re-closing will not change that. Ask your counterparty to issue the proof; their copy can. " +
+                    "Your receipt is unaffected and still proves the conversation was sealed.",
+            };
+        default:
+            // Includes `recorded === null`: no seal has been processed on this side at all, which is a
+            // different sentence again — and an unrecognised state, which is named rather than guessed.
+            return {
+                ...base,
+                reason: "certified_leaves_unavailable",
+                ...(recorded ? { recorded_state: recorded.state } : {}),
+                guidance: "This side holds the receipt for this session but not the leaf set it is signed over, and " +
+                    "no cause was recorded for that — most often because the seal was processed by a build " +
+                    "older than this one. No message-level proof can be built here. Ask your counterparty to " +
+                    "issue the proof; their copy may still be able to. The receipt itself is unaffected.",
+            };
+    }
+}
+/**
+ * The refusal for a local record that does not match what was certified.
+ *
+ * One function because both callers must produce the SAME reason string: the operator's next step is
+ * identical either way, and two spellings of one situation is how a reason code stops being usable
+ * as a signal.
+ */
+function divergenceRefusal(logger, agentName, sessionId, sealedRoot, args) {
+    logger.error("inclusion.local_tree.diverged", {
+        agentName,
+        sessionId,
+        sealedRoot,
+        detail: args.detail,
+        impact: "this side's own record of the conversation is not the record that was notarized, so no " +
+            "message-level proof is issued from it",
+    });
+    return {
+        ok: false,
+        reason: "local_tree_diverged",
+        detail: args.detail,
+        sealed_root: sealedRoot,
+        guidance: "This machine's record of the conversation does not match the one the certificate covers, so " +
+            "any proof built here could be true about the certified record and wrong about the messages " +
+            "you are reading. Read cello_transcript " + sessionId + " and compare it with your " +
+            "counterparty's copy out of band. The certificate is unaffected and still proves the " +
+            "conversation was sealed; what is in doubt is this side's copy of it.",
+    };
+}
+//# sourceMappingURL=inclusion-proof-handlers.js.map

package/dist/inclusion-proof-handlers.js.map

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