@cello-protocol/daemon 0.0.211 → 0.0.213

package/dist/session-relay-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session-relay-client.d.ts","sourceRoot":"","sources":["../src/session-relay-client.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"session-relay-client.d.ts","sourceRoot":"","sources":["../src/session-relay-client.ts"],"names":[],"mappings":"AAiCA,OAAO,EAIL,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACrB,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAU,KAAK,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAClE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEzC,OAAO,EAAuC,KAAK,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AACvG,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACzE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAqBzE,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,eAAe,CAAC;IAC1B,0EAA0E;IAC1E,UAAU,EAAE,MAAM,CAAC;IACnB,2EAA2E;IAC3E,UAAU,CAAC,EAAE,iBAAiB,CAAC;IAC/B;;;;;OAKG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,kFAAkF;IAClF,OAAO,CAAC,EAAE,IAAI,CAAC;CAChB;AAGD,eAAO,MAAM,iBAAiB,uBAAuB,CAAC;AAEtD;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,OAAQ,CAAC;AAC1C,eAAO,MAAM,iBAAiB,wBAAwB,CAAC;AACvD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,uBAAuB,EAAE,WAAW,CAAC,MAAM,CAgBtD,CAAC;AAEH,kFAAkF;AAClF,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAE1E;AAED;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,OAAO,CAAC;IACzB,+EAA+E;IAC/E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,qDAAqD;IACrD,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AA+CD,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEhE;AAED;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,MAAM,EACd,KAAK,GAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAAO,GAC1E,gBAAgB,CA8ElB;AAED,uGAAuG;AACvG,eAAO,MAAM,aAAa,IAAO,CAAC;AAClC,iGAAiG;AACjG,eAAO,MAAM,cAAc,IAAO,CAAC;AACnC,uFAAuF;AACvF,eAAO,MAAM,aAAa,IAAO,CAAC;AAClC,uFAAuF;AACvF,eAAO,MAAM,gBAAgB,IAAO,CAAC;AAKrC;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,GAAG,UAAU,CAIvF;AAED,MAAM,WAAW,gBAAgB;IAC/B,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,UAAU,CAAC;IAC5B,eAAe,EAAE,UAAU,CAAC;IAC5B;;;;;OAKG;IACH,cAAc,EAAE,OAAO,CAAC;CACzB;AAED,gDAAgD;AAChD,MAAM,MAAM,YAAY,GACpB;IACE,EAAE,EAAE,IAAI,CAAC;IACT,eAAe,EAAE,MAAM,CAAC;IAKxB,eAAe,CAAC,EAAE,UAAU,CAAC;IAC7B,eAAe,CAAC,EAAE,UAAU,CAAC;IAC7B;;;;;;;;;;;;;OAaG;IACH,gBAAgB,CAAC,EAAE,UAAU,CAAC;CAC/B,GACD;IACE,EAAE,EAAE,KAAK,CAAC;IACV,MAAM,EAAE,MAAM,CAAC;IACf;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC;AAGN,MAAM,WAAW,oBAAoB;IACnC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,sEAAsE;IACtE,WAAW,EAAE,WAAW,CAAC;IACzB,iFAAiF;IACjF,YAAY,EAAE,UAAU,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,YAAY,CAAC,EAAE,iBAAiB,CAAC;IACjC;;;;;OAKG;IACH,aAAa,CAAC,EAAE,oBAAoB,CAAC;IACrC;;;;OAIG;IACH,aAAa,CAAC,EAAE,oBAAoB,CAAC;IACrC;;;;;;;;;;;;OAYG;IACH,WAAW,CAAC,EAAE,MAAM,UAAU,GAAG,SAAS,CAAC;IAC3C;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAC;IACpD;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CAClE;AAED;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,YAAY,EAAE,MAAM,CAAC;IACrB;;;;;;;;OAQG;IACH,MAAM,EAAE,oCAAoC,GAAG,gCAAgC,CAAC;IAChF,oGAAoG;IACpG,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,yFAAyF;IACzF,uBAAuB,EAAE,OAAO,CAAC;IACjC;;;OAGG;IACH,aAAa,EAAE,MAAM,CAAC;IACtB;;;;;;;;;;OAUG;IACH,UAAU,EAAE,OAAO,CAAC;CACrB;AAqBD;;;;;;GAMG;AACH;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B,2DAA2D;IAC3D,cAAc,EAAE,UAAU,CAAC;IAC3B,oEAAoE;IACpE,eAAe,EAAE,UAAU,CAAC;CAC7B;AAED,MAAM,WAAW,oBAAoB;IACnC,YAAY,EAAE,UAAU,CAAC;IACzB,YAAY,EAAE,UAAU,CAAC;IACzB,gBAAgB,EAAE,MAAM,CAAC;IACzB,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,yBAAyB,CAAC,EAAE,MAAM,CAAC;IACnC;;;;;;;;;;OAUG;IACH,mBAAmB,CAAC,EAAE,UAAU,CAAC;IACjC;;;;;;OAMG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAsDD;;;;GAIG;AACH,qBAAa,gBAAgB;;IAO3B,4EAA4E;IAC5E,kBAAkB,IAAI,MAAM,GAAG,IAAI;IA2DnC,+FAA+F;IAC/F,kBAAkB,IAAI,gBAAgB,GAAG,IAAI;gBAqHjC,IAAI,EAAE,oBAAoB;IA8BtC,2FAA2F;IAC3F,IAAI,eAAe,IAAI,MAAM,CAE5B;IAED;;;;OAIG;IACH,eAAe,CACb,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,SAAS,EACf,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,IAAI,EACjD,UAAU,CAAC,EAAE,oBAAoB;IACjC;;;;;;;;;;;;;;OAcG;IACH,eAAe,CAAC,EAAE,UAAU;IAC5B;;;;;;;;OAQG;IACH,cAAc,CAAC,EAAE,MAAM,GACtB,IAAI;IAwCP;;;;;;;;;;;;;;;;;OAiBG;IACG,uBAAuB,CAAC,IAAI,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAmFtF,0EAA0E;IAC1E,iBAAiB,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;IAM7C,WAAW,IAAI,OAAO;IAItB;;;;;;;;OAQG;IACH,UAAU,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO;IAqrBzC;;;;OAIG;IACG,OAAO,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC;IAIhD;;;;;;;;;;;;;;;;;OAiBG;IACH;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACG,gBAAgB,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC;IA0JzD;;;;;;;;;;;;;;;;;;OAkBG;IACH;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,kBAAkB,CAChB,IAAI,EAAE,SAAS,EACf,SAAS,EAAE,UAAU,EACrB,UAAU,EAAE,iBAAiB,GAC5B,IAAI;IA+BP;;;;;;;;;;;OAWG;IACH;;;;;;;;;;;;OAYG;IACH,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAC1C,eAAe,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAE/C,aAAa,CACjB,SAAS,EAAE,UAAU,EACrB,kBAAkB,EAAE,UAAU,GAC7B,OAAO,CAAC,cAAc,CAAC;IAiDpB,kBAAkB,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC;IAgU3D;;;;;;;;;OASG;IACG,iBAAiB,CACrB,IAAI,EAAE,SAAS,EACf,SAAS,EAAE,UAAU,EACrB,WAAW,EAAE,UAAU;IACvB;;;;;OAKG;IACH,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,YAAY,CAAC;IAQxB;;;;;;;;;;;;;;;;;;OAkBG;IACG,mBAAmB,CACvB,IAAI,EAAE,SAAS,EACf,SAAS,EAAE,UAAU,EACrB,WAAW,EAAE,UAAU,EACvB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,YAAY,CAAC;IAIxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0CG;IACG,UAAU,CACd,IAAI,EAAE,SAAS,EACf,SAAS,EAAE,UAAU,EACrB,WAAW,EAAE,UAAU,EACvB,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,UAAU,GAAG,IAAI;IAC/B;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,CAAC,YAAY,CAAC;IAmjBxB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,gBAAgB,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,UAAU,GAAG,IAAI;IAIvF;;;;;;;;;;;;OAYG;IACH,WAAW,CAAC,YAAY,EAAE,MAAM,GAAG;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,UAAU,CAAA;KAAE,GAAG,SAAS;IAIhF;;;;;;;;;;;OAWG;IACH,WAAW,CAAC,YAAY,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS;IAMzD;;;;;;OAMG;IACH,WAAW,CAAC,YAAY,EAAE,MAAM,EAAE,WAAW,EAAE,UAAU,GAAG,IAAI;IAKhE,KAAK,IAAI,IAAI;CAWd"}

package/dist/session-relay-client.js

@@ -32,9 +32,28 @@ import { createHash } from "node:crypto";
 import * as lp from "it-length-prefixed";
 import { decode } from "cbor-x";
 import { encodeCbor, decodeSealPayload, encodeStructure1, decodeStructure1, computeGenesisPrevRoot } from "@cello-protocol/protocol-types";
+import { encodeSessionLivenessQuery, decodeSessionLivenessResponse, encodeSessionAttendanceNotice, } from "@cello-protocol/protocol-types";
 import { verify } from "@cello-protocol/crypto";
 import { extractErrorMessage } from "./error-message.js";
-import { evaluateRelayAck } from "./relay-receipt-store.js";
+import { evaluateRelayAck, readSubmittedLeaf } from "./relay-receipt-store.js";
+/**
+ * DOD-M15-AWAYSCOPE-1 — what a liveness query answers with.
+ *
+ * `refused` is kept separate from the values rather than folded into `liveness`, because it means
+ * something different: the relay declined to say, most likely because this caller is not a
+ * participant of the session it named. The liveness is 'unknown' either way — the operator surface
+ * shows the same thing — but a caller that wants to tell "the relay would not tell me" from "the
+ * relay does not know" can, and a log line that conflated them would send the next investigation
+ * looking at the counterparty instead of at the session id.
+ */
+/**
+ * The key an answer is matched to its question by: the two fields the RESPONSE carries back. One
+ * relay client serves every session an agent holds there, so two concurrent queries on one stream
+ * is ordinary — and an answer routed to whatever was asked last shows the wrong counterparty's row.
+ */
+function livenessKey(sessionId, counterpartyPubkey) {
+    return `${Buffer.from(sessionId).toString("hex")}:${Buffer.from(counterpartyPubkey).toString("hex")}`;
+}
 export const RELAY_PROTOCOL_ID = "/cello/relay/1.0.0";
 /**
  * How long to wait before re-proving after a transport-class failure.
@@ -47,7 +66,6 @@ export const RELAY_PROTOCOL_ID = "/cello/relay/1.0.0";
  */
 export const PROOF_RETRY_DELAY_MS = 1_000;
 export const RELAY_AUTH_DOMAIN = "CELLO-RELAY-AUTH-v1";
-/** Structure 1 leaf kind: 0x00 = message, 0x02 = control (matches the relay). */
 /**
  * DOD-WITNESS-STALL-1 — relay refusals that can NEVER resolve.
  *
@@ -218,6 +236,7 @@ export function classifyRelayAuthRefusal(reason, extra = {}) {
         ...(extra.retryAfterMs !== undefined ? { retryAfterMs: extra.retryAfterMs } : {}),
     };
 }
+/** Structure 1 leaf kind — these values match the relay's. Message leaf (the `cello_send` default). */
 export const LEAF_KIND_MSG = 0x00;
 /** Control leaf (SEAL etc.) — two distinct-sender ctrl leaves trigger directory notarization. */
 export const LEAF_KIND_CTRL = 0x02;
@@ -384,9 +403,9 @@ export class AgentRelayClient {
     /**
      * PER-SESSION acknowledgement state (session_id hex → the position AND the content at it).
      *
-     * `seq` is the highest relay-assigned sequence. The relay's `seq_counter` is per session, and it
-     * rejects `last_seen_seq > seq_counter`, so each session's submit MUST carry that session's own
-     * high-water mark — NOT an agent-global one (which would make a newer session's first submit look
+     * `seq` is the highest relay-assigned sequence, advanced by an ack or a deliver. The relay's
+     * `seq_counter` is per session and it rejects `last_seen_seq > seq_counter`, so each session's
+     * submit MUST carry that session's own high-water mark — NOT an agent-global one (which would make a newer session's first submit look
      * ahead and get rejected).
      *
      * ⚠️ `hash` IS THE SAME FACT AS `seq`, WHICH IS WHY THEY LIVE IN ONE ENTRY — 033-ACKEMIT.
@@ -431,6 +450,18 @@ export class AgentRelayClient {
      * serialized on the shared stream, exactly like `#pendingRecord`, whose ack also carries no id.
      */
     #pendingRelease = null;
+    /**
+     * DOD-M15-AWAYSCOPE-1 — in-flight liveness queries, keyed `sessionIdHex:counterpartyHex`.
+     *
+     * ⚠️ A MAP, NOT A SLOT, and the first version was a slot. One `AgentRelayClient` serves EVERY
+     * session an agent holds on a relay and both callers fan out with `Promise.all`, so `cello status`
+     * with two open conversations fired two queries on one stream: the second overwrote the first's
+     * resolver, the first answer resolved the WRONG session's promise, and the other waited the full
+     * submit timeout — blowing the caller's budget so every row came back unenriched. With more than
+     * one session the feature did nothing, and when it did something it could show the wrong
+     * counterparty. The key is what the RESPONSE carries, so an answer is matched to its question.
+     */
+    #pendingLiveness = new Map();
     /** Serializes submits so only one is in flight at a time across all sessions. */
     #submitChain = Promise.resolve();
     /** session_id hex → { the live node to (re)dial from, inbound leaf handler, Option-B assignment to present }. */
@@ -488,14 +519,28 @@ export class AgentRelayClient {
      * point has nothing for them to anchor to and every submit on it is refused by name. Registering
      * without a seed is therefore a real fault, not a degraded mode.
      */
-    genesisPrevRoot) {
+    genesisPrevRoot, 
+    /**
+     * 069-ORDERPROOF — the relay key this session's ordering attestations verify under, from
+     * `relay_id` on the directory-signed assignment. Supplied by the caller because
+     * `session-node-manager` is where the durable copy lives, exactly as with the genesis above.
+     *
+     * ⚠️ ABSENT IS NOT A DEGRADED MODE. A session with no anchor refuses every attestation that
+     * arrives on it, by name, because the only alternative is checking a signature against a key
+     * the signer handed us.
+     */
+    relayAnchorHex) {
         const existing = this.#sessions.get(sessionIdHex);
         const carriedAssignment = assignment ?? existing?.assignment;
+        // The anchor is carried forward for the same reason the assignment is: a re-registration with
+        // nothing in hand must not silently strip a session of the key it verifies against.
+        const carriedAnchor = relayAnchorHex ?? carriedAssignment?.relayPubkeyHex ?? existing?.relayAnchorHex;
         this.#sessions.set(sessionIdHex, {
             node,
             onLeafDeliver: onLeafDeliver ?? (() => { }),
             // Carry the assignment forward across re-registration; never lose a recorded flag on re-register.
             assignment: carriedAssignment,
+            ...(carriedAnchor ? { relayAnchorHex: carriedAnchor } : {}),
             recorded: existing?.recorded ?? false,
             recordRejected: existing?.recordRejected ?? false,
             recordTimedOut: existing?.recordTimedOut ?? false,
@@ -560,6 +605,10 @@ export class AgentRelayClient {
         const sess = this.#sessions.get(sessionIdHex);
         if (!sess || !sess.assignment)
             return true;
+        // Nothing to PRESENT. The carry may exist only to name the relay this session's attestations
+        // verify against; there is no frame to send and nothing to wait for, so the submit proceeds.
+        if (!sess.assignment.assignmentSignature)
+            return true;
         if (sess.recorded)
             return true;
         // Terminal rejection: a relay that cleanly rejected this assignment will reject it
@@ -724,52 +773,73 @@ export class AgentRelayClient {
         return Buffer.from(s1.fields.senderPubkey).equals(Buffer.from(this.#senderPubkey));
     }
     /**
-     * Verify a relay `hash_submit_ack`'s signed ordering record and durably store the receipt.
-     * The relay signs TBS = SHA-256(content_hash || seq_BE4 || ts_BE8) with its ack-signing key, whose hex is
-     * `relay_id`. We verify SELF-CONSISTENCY (the signature binds the sequence ⇒ a FORGED sequence fails) and
-     * record the immutable receipt. The authoritative registered-relay check is the directory's at seal
-     * (OPTIONB-SEAL). No-op when there is no receipt store, no pending leaf, or the ACK is unsigned.
+     * The relay pubkey the DIRECTORY named for a session — 069-ORDERPROOF, and the only key a relay
+     * ordering attestation is ever checked against.
+     *
+     * It rides the assignment carry, which is built from an assignment whose FROST signature this
+     * daemon verified before the session began, so it is anchored to something the relay does not
+     * control. `undefined` means no such key was recorded, and every attestation on that session is
+     * then refused for want of an anchor — never accepted against whatever key the frame supplies.
+     */
+    #expectedRelayPubkeyHex(sessionIdHex) {
+        return this.#sessions.get(sessionIdHex)?.relayAnchorHex;
+    }
+    /**
+     * Verify a relay `hash_submit_ack`'s ordering attestation and durably store the receipt.
+     *
+     * The relay signs the session, the content hash, the position it assigned and the running root of
+     * the tree after this leaf. We verify it **against the relay key on the directory-signed
+     * assignment**, and refuse otherwise — missing, malformed and mismatched all take the one path.
+     *
+     * Returns true to REJECT the submit. A send must not settle ok on a position nothing witnessed.
      */
     #captureReceipt(frame, structure1Cbor, seq) {
-        if (seq < 0 || !structure1Cbor)
-            return false;
-        // Structure 1 = [version, content_hash(32), sender_pubkey(32), session_id(16), last_seen_seq,
-        // ts], plus last_seen_hash(32) at index 6 on a v2 claim (020-ACKHASH). content_hash is index 1
-        // and session_id index 3 in both.
-        const s1 = decodeStructure1(structure1Cbor);
-        if (!s1.ok) {
-            // Our OWN just-signed bytes — near-impossible to fail; surface it rather than drop silently.
-            // The reason is carried because "we cannot read what we just wrote" and "we wrote a layout we
-            // cannot name" are different faults with the same symptom.
-            this.#logger.warn("relay.receipt.undecodable_leaf", { seq, structure1Reason: s1.reason });
+        // ⚠️ REJECTS WHEN THE CHECK COULD NOT BE RUN, not only when it failed — `readSubmittedLeaf`
+        // carries the reasoning. Both of these used to settle the send ok having verified nothing.
+        const leaf = readSubmittedLeaf(structure1Cbor, seq);
+        if (leaf.kind === "none")
             return false;
+        if (leaf.kind === "unreadable") {
+            this.#logger.warn(leaf.event, { seq, structure1Reason: leaf.reason, impact: "this side cannot read the leaf it just submitted, so the relay's ordering attestation has " +
+                    "nothing to be checked against. The send is refused rather than settled on a position " +
+                    "nothing witnessed." });
+            return true;
         }
-        const contentHash = s1.fields.contentHash;
-        const sessionId = s1.fields.sessionId;
+        const { contentHash, sessionId } = leaf;
+        const sessionIdHex = Buffer.from(sessionId).toString("hex");
         const ev = evaluateRelayAck({
+            sessionId,
             contentHash,
-            sessionIdHex: Buffer.from(sessionId).toString("hex"),
+            runningRoot: frame["running_root"] instanceof Uint8Array ? frame["running_root"] : undefined,
+            sessionIdHex,
             agentPubkeyHex: this.senderPubkeyHex,
+            expectedRelayPubkeyHex: this.#expectedRelayPubkeyHex(sessionIdHex),
             relayId: typeof frame["relay_id"] === "string" ? frame["relay_id"] : undefined,
             relaySignature: frame["relay_signature"] instanceof Uint8Array ? frame["relay_signature"] : undefined,
             timestamp: typeof frame["timestamp"] === "number" ? frame["timestamp"] : undefined,
             sequenceNumber: seq,
         });
         switch (ev.kind) {
-            case "unsigned":
-                // A relay that SHOULD sign but didn't → no durable witness for this message. Unsigned ACKs are
-                // tolerated, but make it diagnosable instead of invisible.
-                this.#logger.debug("relay.receipt.unsigned", { seq, hashShort: Buffer.from(contentHash).toString("hex").slice(0, 16) });
-                return false;
-            case "bad_relay_id":
-                this.#logger.warn("relay.receipt.bad_relay_id", { seq });
-                return false;
-            case "invalid_signature":
-                // FORGED / corrupt ACK — the signature does not bind (hash, seq, ts). REJECT the submit so the send
-                // does NOT settle ok on an unverified sequence (a forged ordering record must not drive ordering),
-                // and store nothing. The send still completes via the direct
-                // content path — the relay witness simply degrades to absent for this leaf.
-                this.#logger.warn("relay.receipt.signature_invalid", { seq });
+            case "refused":
+                /**
+                 * ONE OUTCOME, and the cause is in the log rather than in the control flow.
+                 *
+                 * The submit is rejected for all five causes. A message whose position no assigned relay
+                 * attested has no ordering evidence behind it, and letting the send settle ok would report
+                 * a witnessed message that nothing witnessed. `attestation_absent` takes this path with the
+                 * rest deliberately: the party who can produce the absence is the relay, which is the party
+                 * the check exists to constrain, so a softer answer for absence is a mute button with our
+                 * own name on it.
+                 */
+                this.#logger.warn("relay.attestation.refused", {
+                    seq,
+                    session: sessionIdHex,
+                    cause: ev.cause,
+                    hashShort: Buffer.from(contentHash).toString("hex").slice(0, 16),
+                    impact: "the relay's ordering attestation for this message was refused, so this send did not " +
+                        "settle and no evidence was stored. This agent holds no proof of where this message " +
+                        "sits in the conversation, and nothing was recorded that could later be presented as one.",
+                });
                 return true;
             case "store": {
                 if (!this.#receiptStore)
@@ -821,6 +891,7 @@ export class AgentRelayClient {
                                     relayId: ev.receipt.relayId,
                                     relayTimestamp: ev.receipt.timestamp,
                                     relaySignatureHex: ev.receipt.signatureHex,
+                                    ...(ev.receipt.runningRootHex ? { relayRunningRootHex: ev.receipt.runningRootHex } : {}),
                                 }
                                 : {}),
                         }, Date.now());
@@ -857,11 +928,77 @@ export class AgentRelayClient {
             // signed-but-INVALID ACK rejects the submit so the send does not settle ok on an unverified sequence.
             const rejectSubmit = this.#captureReceipt(frame, structure1Cbor, seq);
             this.#settlePending(rejectSubmit
-                ? { ok: false, reason: "relay_ack_signature_invalid" }
+                /**
+                 * ONE REASON for every refusal cause — 069-ORDERPROOF Done When 3. A distinct reason per
+                 * cause would be observable, and the clause requires that a missing attestation and a
+                 * malformed one look the same from outside. The cause is named in the log line above.
+                 */
+                ? { ok: false, reason: "relay_ack_unverified" }
                 : seq >= 0
                     ? { ok: true, sequence_number: seq, structure1_cbor: structure1Cbor, structure2_cbor: structure2Cbor, sender_signature: senderSignature }
                     : { ok: false, reason: "relay_ack_malformed" });
         }
+        else if (type === "session_liveness_response" || type === "session_liveness_refused") {
+            /**
+             * DOD-M15-AWAYSCOPE-1 — the relay's answer to "is my counterparty reachable, and is anyone
+             * attending it". Decoded through the shared codec rather than read field by field here: that
+             * codec is what refuses an attendance paired with a non-alive liveness, and re-reading the
+             * fields inline would quietly reintroduce the tolerance branch it exists to prevent.
+             *
+             * A REFUSAL resolves the waiter rather than dropping it. The relay refuses a query naming a
+             * session the caller is not in, and it deliberately does not say which of the two reasons —
+             * so the honest local answer is "unknown", not a hang until the timeout.
+             */
+            /**
+             * ⚠️ A REFUSAL NAMES NOTHING, so it cannot be matched. The relay refuses without echoing the
+             * session or the subject — deliberately, because telling "no such session" from "not your
+             * session" is the enumeration signal `DOD-M15-RELAYAUTH-1` closed. So there is nothing to key
+             * on, and the only sound reading is that every outstanding query on this stream was refused:
+             * the refusal is a property of the CALLER, and the caller is the same for all of them.
+             */
+            if (type === "session_liveness_refused") {
+                for (const r of this.#pendingLiveness.values())
+                    r({ liveness: "unknown", observedAt: 0, refused: true });
+                this.#pendingLiveness.clear();
+            }
+            else {
+                const decoded = decodeSessionLivenessResponse(encodeCbor(frame));
+                if (decoded === null) {
+                    // Malformed fails exactly like missing. A frame this build cannot read is not evidence of
+                    // anything, and reporting it as 'gone' would invent an observation nobody made. It also
+                    // cannot be matched to a waiter, so every outstanding query is answered 'unknown' rather
+                    // than left to time out on a stream that just proved it speaks a shape we cannot read.
+                    this.#logger.warn("session.relay.liveness.response_malformed", {
+                        relayPeerId: this.#relayPeerId,
+                        impact: "the counterparty's reachability is reported as unknown, which is what it is",
+                    });
+                    for (const r of this.#pendingLiveness.values())
+                        r({ liveness: "unknown", observedAt: 0 });
+                    this.#pendingLiveness.clear();
+                }
+                else {
+                    // MATCHED ON WHAT THE ANSWER ITSELF NAMES. Resolving the most recent waiter instead would
+                    // be right exactly once — when only one query is outstanding — and silently wrong the
+                    // moment an agent holds two conversations through one relay, which is ordinary.
+                    const key = livenessKey(decoded.session_id, decoded.counterparty_pubkey);
+                    const r = this.#pendingLiveness.get(key);
+                    if (r) {
+                        this.#pendingLiveness.delete(key);
+                        r({
+                            liveness: decoded.liveness,
+                            observedAt: decoded.observed_at,
+                            ...(decoded.attendance !== undefined ? { attendance: decoded.attendance } : {}),
+                            ...(decoded.attendance_observed_at !== undefined ? { attendanceObservedAt: decoded.attendance_observed_at } : {}),
+                        });
+                    }
+                    else {
+                        // A late answer to a query that already timed out, or one nobody asked for. Dropped —
+                        // handing it to a different session's waiter is exactly the defect this key exists for.
+                        this.#logger.debug("session.relay.liveness.response_unmatched", { relayPeerId: this.#relayPeerId });
+                    }
+                }
+            }
+        }
         else if (type === "hash_submit_error") {
             const reason = typeof frame["reason"] === "string" ? frame["reason"] : "relay_rejected";
             // Carry the relay's `detail` through — see `SubmitResult`. Reading the class and discarding
@@ -1046,6 +1183,69 @@ export class AgentRelayClient {
                     this.#logger.warn("relay.seal_leaf.counterparty.capture_skipped", { seq, session: sidHex, hasS2: !!structure2Cbor, hasS1: s1.length > 0, hasSender: !!senderHex });
                 }
             }
+            /**
+             * ─── THE RECIPIENT KEEPS THE ORDERING PROOF TOO — 069-ORDERPROOF unit 2 ──────────────────
+             *
+             * Before this, the relay's attestation went to the SENDER alone, on the submit
+             * acknowledgement. The recipient held no proof of where a single message of the conversation
+             * sat. That made one party's copy the only copy, which is the dependency this order exists to
+             * remove wearing a different coat.
+             *
+             * It is verified here exactly as on the send path — against the relay key the DIRECTORY named
+             * for this session, never `relay_id` on the frame — and an attestation that does not verify is
+             * refused and NOT stored. Nothing else changes: the leaf is still delivered to the session, the
+             * acknowledgement still advances, and no tree, root or leaf count is touched. This is evidence
+             * recorded beside the chain, never in it.
+             *
+             * Our own echoed leaf comes through here too. Storing it is a no-op — the ack path already
+             * wrote the same row at the same position, and the store is INSERT OR IGNORE — but it is not
+             * skipped, because the echo is the only copy a leaf COUNTER-SUBMITTED by the counterparty
+             * ever produces for us.
+             */
+            if (this.#receiptStore && seq >= 0 && deliveredS1.ok) {
+                const ev = evaluateRelayAck({
+                    sessionId: deliveredS1.fields.sessionId,
+                    contentHash: deliveredS1.fields.contentHash,
+                    runningRoot: frame["running_root"] instanceof Uint8Array ? frame["running_root"] : undefined,
+                    sessionIdHex: sidHex,
+                    agentPubkeyHex: this.senderPubkeyHex,
+                    expectedRelayPubkeyHex: this.#expectedRelayPubkeyHex(sidHex),
+                    relayId: typeof frame["relay_id"] === "string" ? frame["relay_id"] : undefined,
+                    relaySignature: frame["relay_signature"] instanceof Uint8Array ? frame["relay_signature"] : undefined,
+                    timestamp: typeof frame["timestamp"] === "number" ? frame["timestamp"] : undefined,
+                    sequenceNumber: seq,
+                });
+                if (ev.kind === "refused") {
+                    /**
+                     * LOUD, AND THE DELIVERY STILL LANDS. This is the one place the two halves differ, and
+                     * deliberately: on the send path a refusal means OUR message has no witness, so the send
+                     * must not settle. Here the counterparty's message has already been written and read —
+                     * dropping it would let a relay silence a conversation by withholding its own signature,
+                     * which hands the party the check constrains a far better weapon than the one it takes
+                     * away. So the message arrives and the evidence is recorded as absent.
+                     */
+                    this.#logger.warn("relay.attestation.delivered.refused", {
+                        seq,
+                        session: sidHex,
+                        cause: ev.cause,
+                        impact: "this message arrived, but the relay's proof of WHERE it sits in the conversation did " +
+                            "not, so this agent cannot later show a third party that this message was ordered here. " +
+                            "The message itself is unaffected and is in the transcript.",
+                    });
+                }
+                else {
+                    try {
+                        this.#receiptStore.store(ev.receipt, Date.now());
+                    }
+                    catch (err) {
+                        // A durable-evidence write failure is LOUD: the relay never re-sends a delivery, so a
+                        // swallowed write permanently loses this side's only copy of the ordering proof.
+                        this.#logger.error("relay.attestation.delivered.store_failed", {
+                            seq, session: sidHex, error: extractErrorMessage(err),
+                        });
+                    }
+                }
+            }
             const session = this.#sessions.get(sidHex);
             if (session && seq >= 0) {
                 session.onLeafDeliver({
@@ -1446,6 +1646,139 @@ export class AgentRelayClient {
      * ⚠️ **THE FRAME CARRIES NO PEER ID, deliberately.** The relay frees the peer this connection
      * authenticated as. A peer id on the wire would let any registered agent free another's.
      */
+    /**
+     * DOD-M15-AWAYSCOPE-1 — tell this relay whether anyone is attending this agent, for one session.
+     *
+     * ── WHY THIS EXISTS AT ALL ──────────────────────────────────────────────────────────────────────
+     *
+     * An unattended agent used to answer inbound messages with its away greeting. That greeting took a
+     * hash-chain leaf inside a live conversation, and on session `e7dd3f43…` it cost two operators a
+     * completed conversation's receipt, permanently. The fact itself is worth telling — a counterparty
+     * mid-exchange genuinely needs to know whether to wait — but it is a fact ABOUT the session, not a
+     * sentence IN it. So it rides here instead, and takes no leaf.
+     *
+     * ── FIRE AND FORGET, AND THAT IS THE DESIGN ─────────────────────────────────────────────────────
+     *
+     * Nothing is awaited and the relay sends no ack. The notice may be dropped, duplicated or arrive
+     * out of order; `observed_at` settles it, last-write-wins. A failure changes nothing the operator
+     * is doing — the counterparty reads "unknown" until the next notice, which is what is true.
+     *
+     * ⚠️ NO RETRY, NO QUEUE. Anything that made this reliable would want ordering, ordering wants a
+     * witness, and a witnessed position is how machine chatter reached the leaf set. A status hint
+     * that is allowed to be lost is the safe shape.
+     */
+    announceAttendance(node, sessionId, attendance) {
+        if (this.#closed)
+            return;
+        void (async () => {
+            try {
+                if (!(await this.#ensureConnected(node)))
+                    return;
+                const stream = this.#stream;
+                if (!stream)
+                    return;
+                stream.send(lp.encode.single(encodeSessionAttendanceNotice({
+                    type: "session_attendance_notice",
+                    session_id: sessionId,
+                    attendance,
+                    // OUR clock, stated plainly. The relay bounds it against its own and refuses a value too
+                    // far ahead rather than clamping — clamping would turn a hostile timestamp into a valid
+                    // recent one, and this client is the code an adversary gets to rewrite.
+                    observed_at: Date.now(),
+                })));
+                this.#logger.debug("session.relay.attendance.announced", {
+                    relayPeerId: this.#relayPeerId,
+                    sessionId: Buffer.from(sessionId).toString("hex").slice(0, 16),
+                    attendance,
+                });
+            }
+            catch (err) {
+                this.#logger.debug("session.relay.attendance.announce_failed", {
+                    relayPeerId: this.#relayPeerId,
+                    error: extractErrorMessage(err),
+                    impact: "the counterparty reads 'unknown' for this agent until the next notice lands",
+                });
+            }
+        })();
+    }
+    /**
+     * DOD-M15-AWAYSCOPE-1 — ask the relay about the counterparty: reachable, and attended?
+     *
+     * Two facts with two producers, which is why they are separate fields. `liveness` is the RELAY's
+     * observation — it holds that agent's standing connection or it does not. `attendance` is the far
+     * DAEMON's assertion about itself, which the relay was told and repeats; absent whenever
+     * `liveness` is not 'alive', because a daemon nobody can reach asserts nothing.
+     *
+     * ⚠️ EVERY FAILURE ANSWERS 'unknown', never 'gone'. A timeout, a dead stream, a refusal and an
+     * unparseable frame all mean "this side learned nothing"; reporting any as `gone` invents an
+     * observation nobody made, and `gone` is the value that tells an operator their peer has left.
+     */
+    /**
+     * Test-only seams for the liveness query path, which cannot be reached any other way.
+     *
+     * ⚠️ THEY EXIST BECAUSE A ONE-SESSION FAKE HID A REAL DEFECT. Every other test of this feature
+     * stubs `queryLiveness` outright, so the code that matches an ANSWER to its QUESTION never ran —
+     * and it was wrong: a single resolver slot handed one session's answer to another session's
+     * promise the moment an agent held two conversations through one relay, which is ordinary.
+     * Reaching that code needs a live stream and a dispatched frame, and both are private.
+     *
+     * Named `ForTest` like `__setLastActivityAtForTest` and `patchRelayClientForTest`, and doing
+     * nothing production does not: one installs the stream a dial would have produced, the other
+     * feeds the reader loop a frame the relay would have sent.
+     */
+    installStreamForTest(stream) { this.#stream = stream; }
+    dispatchForTest(frame) { this.#dispatch(frame); }
+    async queryLiveness(sessionId, counterpartyPubkey) {
+        const unknown = { liveness: "unknown", observedAt: 0 };
+        if (this.#closed)
+            return unknown;
+        /**
+         * ⚠️ IT DOES NOT DIAL — the one place in this client that refuses to connect. Every other caller
+         * here does the operator's work; this one serves a READ (`cello status`, `cello sessions`), and
+         * a status command that opens a connection as a side effect changes what it is reporting on. It
+         * would also make a read of a dozen sessions pay a dial each, against a budget measured in what
+         * a person waits at a terminal. The cost is small and precise: right after a daemon restart a
+         * status read says 'unknown' instead of dialling; the first real message establishes the stream.
+         */
+        const stream = this.#stream;
+        if (!stream)
+            return unknown;
+        let resolveLiveness;
+        const answer = new Promise((r) => { resolveLiveness = r; });
+        const key = livenessKey(sessionId, counterpartyPubkey);
+        this.#pendingLiveness.set(key, resolveLiveness);
+        try {
+            stream.send(lp.encode.single(encodeSessionLivenessQuery({
+                type: "session_liveness_query",
+                session_id: sessionId,
+                counterparty_pubkey: counterpartyPubkey,
+            })));
+        }
+        catch (err) {
+            this.#pendingLiveness.delete(key);
+            this.#logger.debug("session.relay.liveness.query_failed", {
+                relayPeerId: this.#relayPeerId, error: extractErrorMessage(err),
+            });
+            return unknown;
+        }
+        let timer;
+        const timeout = new Promise((r) => { timer = setTimeout(() => r("timeout"), HASH_SUBMIT_TIMEOUT_MS); });
+        try {
+            const result = await Promise.race([answer, timeout]);
+            if (result === "timeout") {
+                // NOT a stream reset, for the same reason a release timeout is not: a liveness query is not
+                // ordered against anything, so tearing the shared stream down would cost every sibling
+                // session its in-flight submits to tidy up one status read.
+                this.#pendingLiveness.delete(key);
+                this.#logger.debug("session.relay.liveness.query_timeout", { relayPeerId: this.#relayPeerId });
+                return unknown;
+            }
+            return result;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
     async releaseReservation(node) {
         if (this.#closed)
             return false;
@@ -1761,6 +2094,13 @@ export class AgentRelayClient {
                     if (r)
                         r(false);
                 }
+                // DOD-M15-AWAYSCOPE-1: and an in-flight liveness query, so a status read does not wait its
+                // whole timeout on a stream that is already gone. "unknown" is the honest answer.
+                {
+                    for (const r of this.#pendingLiveness.values())
+                        r({ liveness: "unknown", observedAt: 0 });
+                    this.#pendingLiveness.clear();
+                }
                 // A pure-receiver session issues no submit, so it would never trigger a re-dial
                 // after the node that owned the stream is torn down. If sessions remain, proactively
                 // re-establish from any still-live registered session node so queued leaf_delivers
@@ -2436,7 +2776,6 @@ export class AgentRelayClient {
             }
         }
     }
-    /** The highest relay-assigned sequence observed for a given session (ack or deliver). */
     /**
      * Advance this session's acknowledgement from a message that ARRIVED — 033-ACKEMIT review F1.
      *