@cello-protocol/daemon 0.0.225 → 0.0.227

package/dist/inclusion-proof-handlers.js

@@ -1,565 +0,0 @@
-/**
- * `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

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