@cello-protocol/daemon 0.0.16 → 0.0.18

package/dist/daemon.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"daemon.d.ts","sourceRoot":"","sources":["../src/daemon.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAKH,OAAO,KAAK,EACV,YAAY,EACZ,oBAAoB,EAQrB,MAAM,YAAY,CAAC;AAIpB,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAM/D,OAAO,EAAoD,KAAK,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAoB7G,OAAO,KAAK,EAAE,kBAAkB,EAA+C,MAAM,yBAAyB,CAAC;AAM/G,OAAO,EAAoB,KAAK,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAqInF,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpC,SAAS,IAAI,oBAAoB,CAAC;IAClC;;;;OAIG;IACH,qBAAqB,IAAI,kBAAkB,CAAC;IAC5C;;;;;;;;OAQG;IACH,gBAAgB,IAAI,SAAS,GAAG,IAAI,CAAC;IACrC;;;;OAIG;IACH,oBAAoB,IAAI,kBAAkB,CAAC;IAC3C;;;OAGG;IACH,iBAAiB,IAAI,eAAe,CAAC;CACtC;AAyCD,wBAAsB,WAAW,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAyzH7E"}
+{"version":3,"file":"daemon.d.ts","sourceRoot":"","sources":["../src/daemon.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAKH,OAAO,KAAK,EACV,YAAY,EACZ,oBAAoB,EAQrB,MAAM,YAAY,CAAC;AAIpB,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAM/D,OAAO,EAAoD,KAAK,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAqB7G,OAAO,KAAK,EAAE,kBAAkB,EAA+C,MAAM,yBAAyB,CAAC;AAM/G,OAAO,EAAoB,KAAK,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAqInF,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpC,SAAS,IAAI,oBAAoB,CAAC;IAClC;;;;OAIG;IACH,qBAAqB,IAAI,kBAAkB,CAAC;IAC5C;;;;;;;;OAQG;IACH,gBAAgB,IAAI,SAAS,GAAG,IAAI,CAAC;IACrC;;;;OAIG;IACH,oBAAoB,IAAI,kBAAkB,CAAC;IAC3C;;;OAGG;IACH,iBAAiB,IAAI,eAAe,CAAC;CACtC;AAyCD,wBAAsB,WAAW,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAg6H7E"}

package/dist/daemon.js

@@ -51,7 +51,7 @@ import { MAX_CONTENT_BYTES, computeGenesisPrevRoot, buildAgentRevocationTbs } fr
 import { resolveCelloEnv, createTransportSelector, isProductionVariant, } from "./transport-composition.js";
 import { selectAdvertisedAddress } from "./transport-selector.js";
 import { parseSessionAssignment, sessionRequestErrorReason } from "./session-assignment-parser.js";
-import { wireSessionCeremonyHandler, wireSessionOfferHandler, wireSealCeremonyHandler, verifyUnilateralCertificate, verifyBilateralSealCertificate } from "./session-ceremony.js";
+import { wireSessionCeremonyHandler, wireSessionOfferHandler, wireSealCeremonyHandler, verifyUnilateralCertificate, verifyBilateralSealCertificate, runAgentRefresh } from "./session-ceremony.js";
 import { reDeriveFrontiers, findInflatedFrontier } from "./seal-frontier-verify.js";
 import { LocalAutoNatStub } from "@cello-protocol/transport";
 import { startHttpManifestPoll } from "./http-manifest-poll.js";
@@ -387,12 +387,42 @@ export async function startDaemon(config) {
         if (!kp || !endpoint || !endpoint.peer_id || !endpoint.multiaddrs || endpoint.multiaddrs.length === 0) {
             return undefined;
         }
+        // FED-OPTIONB-SETUP-001 (Option B): when the directory included the per-node relay-assignment
+        // signature, carry the assignment so the client presents it to its chosen relay (replacing the
+        // directory→relay dial). Built only for relay-mode assignments that carry relay_directory_signature;
+        // absent ⇒ the client skips client_record_assignment (direct/legacy/pre-M8B).
+        const relayDirSig = assignment.relay_directory_signature;
+        // FED-OPTIONB-SETUP-001 (fallback-finder #1/#5): a relay-mode assignment MUST carry a
+        // relay_directory_signature — the directory always signs one. If it is absent or malformed (the
+        // parser dropped it to undefined) for a relay-mode session, the session silently degrades to "no
+        // relay witness" and looks indistinguishable from a legitimate direct-mode session. Warn LOUD so the
+        // missing/corrupt witness has a named cause (this is the only diagnosable signal on a PURE RECEIVER,
+        // which never submits and so never surfaces relay_unavailable). Unwitnessed is an allowed sovereign-
+        // redundancy state, but it must not be invisible.
+        if (assignment.transport_mode === "relay" && !relayDirSig) {
+            logger.warn("session.relay.assignment.signature.missing", {
+                agentName,
+                sessionId: Buffer.from(assignment.session_id).toString("hex").slice(0, 16),
+                reason: "relay_mode_assignment_without_directory_signature",
+            });
+        }
+        const carry = relayDirSig
+            ? {
+                participantA: assignment.participant_a.pubkey,
+                participantB: assignment.participant_b.pubkey,
+                sessionTimestamp: assignment.session_timestamp,
+                initiatorSessionPeerId: assignment.initiator_session_peer_id,
+                counterpartySessionPeerId: assignment.counterparty_session_peer_id,
+                assignmentSignature: relayDirSig,
+            }
+            : undefined;
         return {
             relayPeerId: endpoint.peer_id,
             relayAddrs: endpoint.multiaddrs,
             keyProvider: kp,
             senderPubkey: await kp.getPublicKey(),
             sessionIdBytes: assignment.session_id,
+            assignment: carry,
         };
     };
     // Stub: all connections marked as 'unverified' until connection validation is wired
@@ -1776,6 +1806,60 @@ export async function startDaemon(config) {
             void attemptSealUpgrade(signaling, agentName, agentPubkeyHex, sidHex, frame);
         });
     }
+    // ─── M8B DOD-REFRESH-1: cello_refresh_shares — proactive share refresh / epoch rollover ───
+    handlers.set("cello_refresh_shares", async (params, connectionId) => {
+        const connState = perConnectionState.get(connectionId);
+        const agentName = params?.name ?? connState?.currentAgent;
+        if (!agentName) {
+            return { ok: false, reason: "no_current_agent", guidance: "Select an agent with cello_use_agent, or pass { name }." };
+        }
+        const loaded = loadedAgents.find((a) => a.name === agentName);
+        if (!loaded) {
+            return { ok: false, reason: "agent_not_found", guidance: `No agent named '${agentName}'. Create + register it first.` };
+        }
+        // The refresh ceremony reaches the consortium over the agent's signaling node — ensure it is up.
+        const entry = getAgentSignaling(agentName, loaded.keyProvider, loaded.pubkey);
+        const connected = await waitForSignalingConnected(entry.signaling, 15_000);
+        if (!connected) {
+            return { ok: false, reason: "directory_unreachable", guidance: "The agent's directory signaling is not connected; start the agent and retry." };
+        }
+        const result = await runAgentRefresh({
+            agentName,
+            persistence: getPersistence(agentName),
+            agentPubkeyHex: loaded.pubkey,
+            getNode: entry.getNode,
+            getDirectoryEndpoint: async () => (directoryEndpointResolver ? (await directoryEndpointResolver()) ?? null : null),
+            getConsortiumEndpoints: resolveConsortiumRoster,
+            signaling: entry.signaling,
+            logger,
+        });
+        if (!result.ok) {
+            return { ok: false, reason: result.reason, guidance: "Share refresh did not complete — see the daemon log (refresh.ceremony.*) for the cause." };
+        }
+        return { ok: true, epoch: result.toEpochN, primary_pubkey: result.primaryPubkey, verifying_shares_digest: result.verifyingSharesDigest };
+    });
+    // ─── M8B DOD-RELAYSIG-1: cello_get_relay_receipts — the agent's stored relay ordering receipts ───
+    handlers.set("cello_get_relay_receipts", async (params, connectionId) => {
+        const connState = perConnectionState.get(connectionId);
+        const agentName = params?.name ?? connState?.currentAgent;
+        if (!agentName) {
+            return { ok: false, reason: "no_current_agent", guidance: "Select an agent with cello_use_agent, or pass { name }." };
+        }
+        const loaded = loadedAgents.find((a) => a.name === agentName);
+        if (!loaded) {
+            return { ok: false, reason: "agent_not_found", guidance: `No agent named '${agentName}'.` };
+        }
+        const sessionIdHex = typeof params?.session_id === "string" ? params.session_id : undefined;
+        const receipts = sessionNodeManager.getRelayReceipts(loaded.pubkey, sessionIdHex).map((r) => ({
+            hash_hex: r.hashHex,
+            session_id: r.sessionIdHex,
+            relay_id: r.relayId,
+            sequence_number: r.sequenceNumber,
+            timestamp: r.timestamp,
+            signature_hex: r.signatureHex,
+        }));
+        return { ok: true, receipts };
+    });
     // ─── MCP-001: cello_status (per-connection perspective) ───
     handlers.set("cello_status", async (_params, connectionId) => {
         return {
@@ -2082,11 +2166,28 @@ export async function startDaemon(config) {
                 let resolveUni;
                 const uniP = new Promise((r) => { resolveUni = r; });
                 pendingUnilateralWaiters.set(sessionId, resolveUni);
+                // FED-OPTIONB-SEAL-001 (Option B): carry the full leaf chain (both parties) + the relay receipts so
+                // the directory rebuilds + verifies the tree OFFLINE — no directory→relay getSealLeaves dial. The
+                // store is keyed by the agent's K_local pubkey (the same key the relay client recorded under).
+                const sealAgentKp = keyProviders.get(record.agent_name);
+                const sealAgentPubkeyHex = sealAgentKp ? Buffer.from(await sealAgentKp.getPublicKey()).toString("hex") : "";
+                const sealCarry = sealAgentPubkeyHex ? sessionNodeManager.getSealCarry(sealAgentPubkeyHex, sessionId) : [];
+                const seal_leaves = sealCarry.map((l) => ({
+                    sequence_number: l.sequenceNumber,
+                    leaf_kind: l.leafKind,
+                    structure2_cbor: l.structure2Cbor,
+                    structure1_cbor: l.structure1Cbor,
+                    // Relay receipt (present only for the present party's OWN leaves — the seq-pinning teeth).
+                    relay_id: l.relayId,
+                    relay_timestamp: l.relayTimestamp,
+                    relay_signature: l.relaySignatureHex ? new Uint8Array(Buffer.from(l.relaySignatureHex, "hex")) : undefined,
+                }));
                 const sent = await sendOver(record.agent_name, {
                     type: "seal_unilateral",
                     session_id: new Uint8Array(Buffer.from(sessionId, "hex")),
                     reported_root: new Uint8Array(Buffer.from(submit.reportedRootHex, "hex")),
                     reported_seq: submit.sequenceNumber,
+                    seal_leaves,
                 });
                 if (!sent.ok) {
                     pendingUnilateralWaiters.delete(sessionId);