@cello-protocol/daemon 0.0.227 → 0.0.229

package/dist/register-handler.d.ts

@@ -0,0 +1,36 @@
+import type { StartAgentResult } from "./start-agent.js";
+import type { IpcHandler } from "./ipc-server.js";
+import type { Logger } from "./types.js";
+import type { KeyProvider } from "@cello-protocol/crypto";
+import type { SignalingManager, CelloNode } from "@cello-protocol/transport";
+import type { DbRegistrationPersistence } from "./db-identity-store.js";
+import type { IManifestProvider } from "@cello-protocol/transport";
+export interface RegisterHandlerDeps {
+    handlers: Map<string, IpcHandler>;
+    logger: Logger;
+    keyProviders: Map<string, KeyProvider>;
+    getPersistence: (agentName: string) => DbRegistrationPersistence;
+    getAgentSignaling: (agentName: string, keyProvider: KeyProvider, pubkeyHex: string) => {
+        signaling: SignalingManager;
+        getNode: () => CelloNode | null;
+    };
+    waitForSignalingConnected: (mgr: SignalingManager, timeoutMs: number) => Promise<boolean>;
+    dropAgentSignaling: (agentName: string) => Promise<void>;
+    /**
+     * ⚠️ THE THREE-WAY UNION, NOT `{ ok: true }`. The readiness half is the point: an agent can be
+     * online and DEAF — marked started while its standing receiver never came up — and the two states
+     * render identically at every surface without it. Declared narrow, dropping it is invisible to the
+     * type checker.
+     */
+    startAgentInternal: (name: string) => StartAgentResult;
+    directoryEndpointResolver?: () => Promise<import("./signaling-connect.js").DirectoryEndpoint | null>;
+    loadedAgents: Array<{
+        name: string;
+        pubkey: string;
+        keyProvider: KeyProvider;
+    }>;
+    registrationGuidance: (reason: string, detail?: string) => string;
+    manifestProvider?: IManifestProvider;
+}
+export declare function registerRegisterHandler(deps: RegisterHandlerDeps): void;
+//# sourceMappingURL=register-handler.d.ts.map

package/dist/register-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-handler.d.ts","sourceRoot":"","sources":["../src/register-handler.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAC1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAC7E,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AACxE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAQnE,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IACvC,cAAc,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,yBAAyB,CAAC;IACjE,iBAAiB,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,KAAK;QAAE,SAAS,EAAE,gBAAgB,CAAC;QAAC,OAAO,EAAE,MAAM,SAAS,GAAG,IAAI,CAAA;KAAE,CAAC;IACxJ,yBAAyB,EAAE,CAAC,GAAG,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC1F,kBAAkB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACzD;;;;;OAKG;IACH,kBAAkB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,gBAAgB,CAAC;IACvD,yBAAyB,CAAC,EAAE,MAAM,OAAO,CAAC,OAAO,wBAAwB,EAAE,iBAAiB,GAAG,IAAI,CAAC,CAAC;IACrG,YAAY,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,WAAW,CAAA;KAAE,CAAC,CAAC;IAChF,oBAAoB,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAClE,gBAAgB,CAAC,EAAE,iBAAiB,CAAC;CACtC;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,mBAAmB,GAAG,IAAI,CA4QvE"}

package/dist/register-handler.js

@@ -0,0 +1,285 @@
+/**
+ * cello_register — DKG with the directory consortium.
+ *
+ * The one invariant, and it is the whole reason CELLO exists: NO SINGLE NODE can complete this
+ * ceremony alone. Registration runs a T-of-N distributed key generation across the consortium
+ * roster, so a compromised directory cannot forge an identity. If the code below ever lets one node
+ * produce a valid ceremony output, that is a security violation regardless of whether tests pass.
+ *
+ * registrationInProgress is DAEMON-WIDE, and the reason matters: the directory's registration reply
+ * frames (dkg_ready / register_success / register_error) carry NO AGENT IDENTIFIER. Two concurrent
+ * registrations over the one shared signaling stream would each arm a resolver and both receive the
+ * same reply — CROSS-WIRING THE CEREMONIES. It is the registration analogue of the
+ * sealInterruptedInProgress guard, but global rather than per-key precisely because the frames are
+ * not agent-tagged. Do not "improve" it into a per-agent map.
+ */
+import { Buffer } from "node:buffer";
+import { manifestNodesToEndpoints } from "./directory-bootstrap.js";
+import { DaemonRegistrationContext } from "./registration-context.js";
+import { RegistrationManager } from "./registration-manager.js";
+import { validatorNodes } from "@cello-protocol/protocol-types";
+import { classifyManifestValidity } from "./manifest-validity.js";
+import { extractErrorMessage } from "./error-message.js";
+export function registerRegisterHandler(deps) {
+    const { handlers, logger, keyProviders, getPersistence, getAgentSignaling, waitForSignalingConnected, dropAgentSignaling, startAgentInternal, directoryEndpointResolver, loadedAgents, registrationGuidance, manifestProvider, } = deps;
+    // Single-flight guard (M1): the directory's registration reply frames (dkg_ready /
+    // register_success / register_error) carry NO agent identifier, so two concurrent registrations
+    // over the one shared directory signaling stream would each arm a resolver and both receive the
+    // same reply — cross-wiring the ceremonies. Serialize registration daemon-wide (it is a rare,
+    // once-per-agent, human-initiated operation). This is the registration analogue of the
+    // sealInterruptedInProgress guard, but GLOBAL rather than per-key because the frames are not
+    // agent-tagged. A per-agent guard would reintroduce the cross-wiring it exists to prevent.
+    let registrationInProgress = false;
+    handlers.set("cello_register", async (params, _connectionId) => {
+        const name = params?.agent;
+        const preAuthToken = params?.preAuthToken;
+        const phoneStub = params?.phoneStub ?? "";
+        if (!name) {
+            return { ok: false, reason: "missing_params", guidance: "Provide 'agent' (the agent name to register) and 'preAuthToken' (the pre-authorization ticket from the CELLO Operations Agent)." };
+        }
+        if (!preAuthToken) {
+            return { ok: false, reason: "missing_preauth_token", guidance: "Registration requires a 'preAuthToken' issued by the CELLO Operations Agent (Telegram). Obtain one, then retry 'cello register-agent'." };
+        }
+        // M16: a broadcast channel is registered with `channel: true` AND the administering agent's
+        // pubkey. The two travel together or not at all. The manager checks the pubkey's shape.
+        const channelParam = params?.channel;
+        const adminPubkeyParam = params?.adminPubkeyHex;
+        if (channelParam !== undefined && channelParam !== true) {
+            return { ok: false, reason: "invalid_channel_registration", guidance: "'channel' must be true to register a broadcast channel, or omitted for an ordinary agent." };
+        }
+        if (channelParam === true && typeof adminPubkeyParam !== "string") {
+            return { ok: false, reason: "invalid_channel_registration", guidance: "Registering a channel requires 'adminPubkeyHex': the public key of the agent that will administer it." };
+        }
+        if (channelParam === undefined && adminPubkeyParam !== undefined) {
+            return { ok: false, reason: "invalid_channel_registration", guidance: "'adminPubkeyHex' only applies to a channel registration. Pass 'channel: true' with it, or omit both for an ordinary agent." };
+        }
+        const channelOpts = channelParam === true
+            ? { channel: true, adminPubkeyHex: adminPubkeyParam }
+            : undefined;
+        const keyProvider = keyProviders.get(name);
+        if (!keyProvider) {
+            return { ok: false, reason: "agent_not_found", guidance: `Agent '${name}' does not exist. Create it first with 'cello create-agent ${name}', then retry 'cello register-agent'.` };
+        }
+        if (!directoryEndpointResolver) {
+            return { ok: false, reason: "directory_unreachable", guidance: "The daemon has no directory endpoint resolver configured, so it cannot reach the directory to register." };
+        }
+        // M1: claim the single-flight slot synchronously (no await between the check
+        // and the set) so two concurrent calls cannot both proceed.
+        if (registrationInProgress) {
+            return { ok: false, reason: "registration_already_in_progress", guidance: "Another agent registration is already in progress on this daemon. Registration runs one at a time because the directory's reply frames are not agent-tagged. Wait for it to finish (check the daemon logs for registration.succeeded/failed), then retry." };
+        }
+        registrationInProgress = true;
+        try {
+            // Resolve the directory endpoint once for this registration (the context's
+            // getDirectoryEndpoint is synchronous; the daemon's resolver is async).
+            // FINDING-4 scope note: this uses the PRIMARY resolver directly (not the roster-aware
+            // failover resolver — registration is deliberately out of FINDING-4's "signaling +
+            // ceremony" scope). Because that primary is now built with staleFallback:false (so the
+            // failover wrapper sees a dead primary as null), a transient /bootstrap blip here resolves
+            // to null → directory_unreachable rather than riding through on a stale last-known-good;
+            // registration is a rare, manual, retryable op, so failing fast (retry) is acceptable. With
+            // a manifest configured the DKG fans out over the independently-probed roster regardless of
+            // this endpoint. The endpoint is stable for one registration — if it changed mid-flow the
+            // DKG streams would break anyway.
+            const ep = await directoryEndpointResolver();
+            if (!ep || !ep.multiaddr) {
+                // FROST DKG must dial the directory's /cello/frost/1.0.0 — a dialable
+                // multiaddr is required (DirectoryEndpoint.multiaddr is optional for the
+                // already-connected signaling case, but registration needs to open streams).
+                // The primary resolver uses staleFallback:false, so a transient /bootstrap blip returns null
+                // here. Registration is a rare manual operation — failing fast with a clear retry message is
+                // correct. (Signaling has richer failover because it runs continuously; registration runs once.)
+                return { ok: false, reason: "directory_unreachable", guidance: "Could not reach a directory node to start registration — this is often a transient network blip. Wait a few seconds and retry. If it persists, check your internet connection." };
+            }
+            const directoryEndpoint = { peer_id: ep.peerId, multiaddrs: [ep.multiaddr] };
+            // Multi-agent: register over THIS agent's own directory signaling stream (authed
+            // as this agent), so the directory routes its dkg_complete/register_success back
+            // to it. CONN-001: every agent has its own dedicated stream (no shared keystone). The
+            // DKG's FROST streams open on this agent's directory node.
+            const agentRecord = loadedAgents.find((a) => a.name === name);
+            const agentPubkeyHex = agentRecord?.pubkey ?? Buffer.from(await keyProvider.getPublicKey()).toString("hex");
+            const { signaling: agentSignaling, getNode: agentGetNode } = getAgentSignaling(name, keyProvider, agentPubkeyHex);
+            // A non-primary agent's stream connects lazily — wait for it before the DKG
+            // (RegistrationManager returns directory_unreachable if signaling isn't connected).
+            const signalingConnected = await waitForSignalingConnected(agentSignaling, 10_000);
+            if (!signalingConnected) {
+                // Distinct cause → distinct code (M7 error discipline): this is specifically the
+                // per-agent signaling stream failing to come up in time, not a missing/unresolvable
+                // directory endpoint. Drop the manager so it doesn't reconnect forever for an
+                // unregistered agent (it is re-created on the next cello_register).
+                await dropAgentSignaling(name);
+                return {
+                    ok: false,
+                    reason: "directory_signaling_timeout",
+                    guidance: `Agent '${name}' could not establish its directory signaling stream within 10s. Check CELLO_DIRECTORY_URL and that the directory is reachable, then retry 'cello register-agent'.`,
+                };
+            }
+            const persistence = getPersistence(name);
+            // DOD-DKG-1 + M12 ROLE-MANIFEST-1: resolve the consortium roster from the VERIFIED
+            // manifest, restricted to VALIDATOR-role nodes — replicas hold no shares and take no part
+            // in a DKG, so including one would either strand registration on a quorum-count mismatch
+            // or deal a share to a share-less node. The directory computes its quorum over validators
+            // too; the two sides must agree on N. Re-resolved here (ceremony time) for fresh failover
+            // coordinates. NULL when NO manifest is configured (→ single-node DKG, M6/M7 back-compat);
+            // a (possibly EMPTY) array when a manifest IS configured. The null-vs-empty distinction is
+            // load-bearing: an empty roster (consortium configured but unreachable) must REFUSE in
+            // registration-manager, NOT downgrade to single-node (code-reviewer B1 / fallback-finder).
+            const currentManifest = manifestProvider?.getCurrentManifest();
+            /**
+             * DOD-M15-EXPIRY-CONSUMER-POLICY-1 — this consumer PROCEEDS on a lapsed manifest, and that is
+             * now a decision rather than an omission. Written down because the split looked accidental:
+             * `signal-submission` REFUSES on expiry while this, the higher-stakes consumer, did not even
+             * look.
+             *
+             * **Why it proceeds.** Startup already fails closed on an expired manifest, so a lapsed one
+             * exists only inside a LONG-RUNNING daemon. Refusing here sends the operator to the one remedy
+             * `signal-submission`'s own guidance warns against — *"a restart without a REPLACEMENT does not
+             * reload anything: the daemon refuses to come back and every agent goes offline."* So refusing
+             * would brick a running operator to close a window that needs a roster CHANGE to be
+             * exploitable at all: the risk is dealing a share to a validator removed since the manifest
+             * lapsed, not expiry itself.
+             *
+             * **Why `signal-submission` is different, and why "make them consistent" would be wrong.** It
+             * uses the manifest's PORTAL INTAKE KEY, and a rotated key means a message the portal cannot
+             * open and cannot attribute — unattributable poison, its own word, with no error anywhere.
+             * Different field, different failure, different answer.
+             *
+             * **What was actually missing was not the gate — it was the RECORD.** `cello_status` already
+             * reports an expired manifest, so the STATE was visible; nothing said a FROST share had been
+             * dealt against one. That is what this event is.
+             */
+            const manifestValidity = classifyManifestValidity(currentManifest ?? null, Date.now());
+            /**
+             * ⚠️ NOT ONLY `expired` — review F7. `unreadable_window` (a window field that does not parse)
+             * and `not_yet_valid` (a wrong clock, or a manifest rotated in early) both reached the DKG
+             * with no event at all. `unreadable_window` matters more than it looks: since the startup gate
+             * was hardened it cannot start a daemon, but a manifest POLLED IN after startup can still put
+             * a running daemon into it.
+             */
+            const lapsed = manifestValidity.state === "expired"
+                || manifestValidity.state === "unreadable_window"
+                || manifestValidity.state === "not_yet_valid";
+            if (lapsed) {
+                logger.warn("registration.manifest.lapsed", {
+                    agent: name,
+                    state: manifestValidity.state,
+                    window: manifestValidity.state === "expired" ? manifestValidity.expires : manifestValidity.notBefore,
+                    validators: currentManifest ? validatorNodes(currentManifest.nodes).length : 0,
+                    /**
+                     * ⚠️ THIS USED TO SAY "a share MAY BE DEALT to a node that is no longer authorized", and
+                     * that over-claimed in the very case it named. Review traced the path: a validator removed
+                     * since the lapse is either unreachable — dropped at the dial layer by the peerId
+                     * cross-check against the signed manifest — or reachable but absent from the DIRECTORY's
+                     * current manifest, in which case the roster/participants counts disagree and registration
+                     * REFUSES with `dkg_below_threshold`. **Dealing a share to a de-authorized node is not
+                     * reachable through this path.** The event was about to be emitted alongside a FAILED
+                     * registration while telling the operator a share may have gone somewhere.
+                     *
+                     * What it says now is what is actually true, and it is still worth saying: this event is
+                     * emitted immediately before that refusal, so it is the line that explains an otherwise
+                     * bare `dkg_below_threshold` — which names an exit point and not a cause.
+                     */
+                    /**
+                     * ⚠️ ONE CAUSE OF A MULTI-CAUSE EXIT — pass 2, and the previous wording inverted the
+                     * redundancy invariant in prose. `dkg_below_threshold` comes from a single comparison
+                     * (`roster.length !== participants`) whose own comment names TWO causes: a node we reported
+                     * is now unreachable, OR a manifest version skew. **An unreachable node is the routine
+                     * one** — under the sovereign-node design a node being down is the expected steady state,
+                     * not the exception. Saying "THIS is the cause" and "replace the trust anchor rather than
+                     * retrying" told the operator to replace a threshold-signed anchor in the case where the
+                     * correct move is to retry.
+                     */
+                    impact: "the consortium roster this registration works from came from a manifest whose validity " +
+                        "window is not currently open. This is ONE possible cause of a subsequent " +
+                        "dkg_below_threshold — a directory node being momentarily unreachable is the more common " +
+                        "one, and is expected rather than exceptional.",
+                    guidance: "Registration was NOT blocked here — blocking it would strand a running daemon, since a " +
+                        "restart without a replacement manifest does not come back. If it then fails with " +
+                        "dkg_below_threshold: RETRY FIRST, because an unreachable node is the usual cause. " +
+                        "Replace the trust anchor only if cello_status shows the manifest window is the " +
+                        "discrepancy.",
+                });
+            }
+            const consortiumRoster = currentManifest
+                ? await manifestNodesToEndpoints(validatorNodes(currentManifest.nodes), { logger })
+                : null;
+            const ctx = new DaemonRegistrationContext({
+                signaling: agentSignaling,
+                getDirectoryNode: agentGetNode,
+                getDirectoryEndpoint: () => directoryEndpoint,
+                getConsortiumEndpoints: () => consortiumRoster,
+                keyProvider,
+                persistence,
+                logger,
+            });
+            try {
+                const result = await new RegistrationManager(ctx).register(phoneStub, preAuthToken, channelOpts);
+                if ("error" in result) {
+                    logger.warn("registration.failed", { agentName: name, reason: result.error });
+                    // Terminal failure for THIS agent — drop its dedicated signaling manager so it
+                    // does not reconnect forever for an unregistered agent (re-created on retry).
+                    await dropAgentSignaling(name);
+                    // `detail` is the underlying cause when the manager captured one — the wire `reason` stays
+                    // the closed union, the guidance gets to be accurate.
+                    return {
+                        ok: false,
+                        reason: result.error,
+                        guidance: registrationGuidance(result.error, result.detail),
+                    };
+                }
+                // PERSIST-002 (AC-013): the identity row (K_local + share + ML-DSA + registration) is durably
+                // committed at this point (RegistrationManager awaits the persist before returning success).
+                // SI-001: never log a secret — only the agent name + PUBLIC key.
+                logger.info("persist.identity.persisted", { agentName: name, agentPubkey: agentPubkeyHex });
+                // CC-2 (2026-07-07): registration succeeded — arm this agent's standing receiver NOW so a
+                // brand-new agent can receive inbound immediately. Without this the agent reports
+                // standing_receiver_ready:false and cannot receive until the operator restarts (logout/login),
+                // so a fresh registration looks broken. Uses the SAME idempotent path login and cello_use_agent
+                // arm through (startAgentInternal → onlineAgents + directory signaling + ensureStandingReceiver +
+                // agent_state_changed). A start failure must NOT fail the (already durably persisted)
+                // registration — surface it as a warning and let the operator recover via login.
+                const armResult = startAgentInternal(name);
+                if (!armResult.ok) {
+                    logger.warn("registration.standing_receiver.arm_failed", { agentName: name, reason: armResult.reason });
+                }
+                else {
+                    // arm_INITIATED, not armed: startAgentInternal returns ok once the agent is online + signaling
+                    // is up, but ensureStandingReceiverForAgent runs fire-and-forget (its own failure emits
+                    // session.standing_receiver.ensure.failed) — so this event marks the start, not readiness.
+                    logger.info("registration.standing_receiver.arm_initiated", { agentName: name });
+                }
+                // Capture-now-or-lose-it: persist the agent→user link (using it is future
+                // trust-layer work). L1: the agent is already registered at this point —
+                // a link-write failure must NOT be reported as a registration failure.
+                // Surface it as a non-fatal warning so the operator knows the link wasn't
+                // captured (re-registering with the same token re-attempts it).
+                try {
+                    await persistence.persistAgentUserLink({ agentId: result.agent_id, preAuthToken, linkedAt: Date.now() });
+                    logger.info("registration.succeeded", { agentName: name, agentId: result.agent_id, primaryPubkey: result.primary_pubkey });
+                    return { ok: true, agent_id: result.agent_id, primary_pubkey: result.primary_pubkey };
+                }
+                catch (linkErr) {
+                    logger.warn("registration.user_link.capture_failed", {
+                        agentName: name,
+                        agentId: result.agent_id,
+                        error: extractErrorMessage(linkErr),
+                    });
+                    logger.info("registration.succeeded", { agentName: name, agentId: result.agent_id, primaryPubkey: result.primary_pubkey });
+                    return {
+                        ok: true,
+                        agent_id: result.agent_id,
+                        primary_pubkey: result.primary_pubkey,
+                        warning: "agent_user_link_not_captured",
+                    };
+                }
+            }
+            finally {
+                ctx.dispose();
+            }
+        }
+        finally {
+            registrationInProgress = false;
+        }
+    });
+}
+//# sourceMappingURL=register-handler.js.map

package/dist/register-handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-handler.js","sourceRoot":"","sources":["../src/register-handler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAQrC,OAAO,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AACpE,OAAO,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AACtE,OAAO,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAChE,OAAO,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAClE,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAuBzD,MAAM,UAAU,uBAAuB,CAAC,IAAyB;IAC/D,MAAM,EACJ,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,cAAc,EAC9C,iBAAiB,EAAE,yBAAyB,EAAE,kBAAkB,EAAE,kBAAkB,EACpF,yBAAyB,EAAE,YAAY,EAAE,oBAAoB,EAAE,gBAAgB,GAChF,GAAG,IAAI,CAAC;IAET,mFAAmF;IACnF,gGAAgG;IAChG,gGAAgG;IAChG,8FAA8F;IAC9F,uFAAuF;IACvF,6FAA6F;IAC7F,2FAA2F;IAC3F,IAAI,sBAAsB,GAAG,KAAK,CAAC;IAEnC,QAAQ,CAAC,GAAG,CAAC,gBAAgB,EAAE,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,EAAE;QAC7D,MAAM,IAAI,GAAG,MAAM,EAAE,KAA2B,CAAC;QACjD,MAAM,YAAY,GAAG,MAAM,EAAE,YAAkC,CAAC;QAChE,MAAM,SAAS,GAAI,MAAM,EAAE,SAAgC,IAAI,EAAE,CAAC;QAClE,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,gBAAgB,EAAE,QAAQ,EAAE,iIAAiI,EAAE,CAAC;QAC9L,CAAC;QACD,IAAI,CAAC,YAAY,EAAE,CAAC;YAClB,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,uBAAuB,EAAE,QAAQ,EAAE,wIAAwI,EAAE,CAAC;QAC5M,CAAC;QACD,4FAA4F;QAC5F,wFAAwF;QACxF,MAAM,YAAY,GAAG,MAAM,EAAE,OAAO,CAAC;QACrC,MAAM,gBAAgB,GAAG,MAAM,EAAE,cAAc,CAAC;QAChD,IAAI,YAAY,KAAK,SAAS,IAAI,YAAY,KAAK,IAAI,EAAE,CAAC;YACxD,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,8BAA8B,EAAE,QAAQ,EAAE,2FAA2F,EAAE,CAAC;QACtK,CAAC;QACD,IAAI,YAAY,KAAK,IAAI,IAAI,OAAO,gBAAgB,KAAK,QAAQ,EAAE,CAAC;YAClE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,8BAA8B,EAAE,QAAQ,EAAE,uGAAuG,EAAE,CAAC;QAClL,CAAC;QACD,IAAI,YAAY,KAAK,SAAS,IAAI,gBAAgB,KAAK,SAAS,EAAE,CAAC;YACjE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,8BAA8B,EAAE,QAAQ,EAAE,4HAA4H,EAAE,CAAC;QACvM,CAAC;QACD,MAAM,WAAW,GAAG,YAAY,KAAK,IAAI;YACvC,CAAC,CAAC,EAAE,OAAO,EAAE,IAAa,EAAE,cAAc,EAAE,gBAA0B,EAAE;YACxE,CAAC,CAAC,SAAS,CAAC;QACd,MAAM,WAAW,GAAG,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC3C,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,iBAAiB,EAAE,QAAQ,EAAE,UAAU,IAAI,8DAA8D,IAAI,uCAAuC,EAAE,CAAC;QACrL,CAAC;QACD,IAAI,CAAC,yBAAyB,EAAE,CAAC;YAC/B,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,uBAAuB,EAAE,QAAQ,EAAE,yGAAyG,EAAE,CAAC;QAC7K,CAAC;QACD,6EAA6E;QAC7E,4DAA4D;QAC5D,IAAI,sBAAsB,EAAE,CAAC;YAC3B,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,kCAAkC,EAAE,QAAQ,EAAE,2PAA2P,EAAE,CAAC;QAC1U,CAAC;QACD,sBAAsB,GAAG,IAAI,CAAC;QAC9B,IAAI,CAAC;YACH,2EAA2E;YAC3E,wEAAwE;YACxE,sFAAsF;YACtF,mFAAmF;YACnF,uFAAuF;YACvF,2FAA2F;YAC3F,yFAAyF;YACzF,4FAA4F;YAC5F,4FAA4F;YAC5F,0FAA0F;YAC1F,kCAAkC;YAClC,MAAM,EAAE,GAAG,MAAM,yBAAyB,EAAE,CAAC;YAC7C,IAAI,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC,SAAS,EAAE,CAAC;gBACzB,sEAAsE;gBACtE,yEAAyE;gBACzE,6EAA6E;gBAC7E,6FAA6F;gBAC7F,6FAA6F;gBAC7F,iGAAiG;gBACjG,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,uBAAuB,EAAE,QAAQ,EAAE,gLAAgL,EAAE,CAAC;YACpP,CAAC;YACD,MAAM,iBAAiB,GAAG,EAAE,OAAO,EAAE,EAAE,CAAC,MAAM,EAAE,UAAU,EAAE,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC;YAE7E,iFAAiF;YACjF,iFAAiF;YACjF,sFAAsF;YACtF,2DAA2D;YAC3D,MAAM,WAAW,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;YAC9D,MAAM,cAAc,GAAG,WAAW,EAAE,MAAM,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,WAAW,CAAC,YAAY,EAAE,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;YAC5G,MAAM,EAAE,SAAS,EAAE,cAAc,EAAE,OAAO,EAAE,YAAY,EAAE,GAAG,iBAAiB,CAAC,IAAI,EAAE,WAAW,EAAE,cAAc,CAAC,CAAC;YAElH,4EAA4E;YAC5E,oFAAoF;YACpF,MAAM,kBAAkB,GAAG,MAAM,yBAAyB,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC;YACnF,IAAI,CAAC,kBAAkB,EAAE,CAAC;gBACxB,iFAAiF;gBACjF,oFAAoF;gBACpF,8EAA8E;gBAC9E,oEAAoE;gBACpE,MAAM,kBAAkB,CAAC,IAAI,CAAC,CAAC;gBAC/B,OAAO;oBACL,EAAE,EAAE,KAAK;oBACT,MAAM,EAAE,6BAA6B;oBACrC,QAAQ,EAAE,UAAU,IAAI,oKAAoK;iBAC7L,CAAC;YACJ,CAAC;YAED,MAAM,WAAW,GAAG,cAAc,CAAC,IAAI,CAAC,CAAC;YACzC,mFAAmF;YACnF,0FAA0F;YAC1F,yFAAyF;YACzF,0FAA0F;YAC1F,0FAA0F;YAC1F,2FAA2F;YAC3F,2FAA2F;YAC3F,uFAAuF;YACvF,2FAA2F;YAC3F,MAAM,eAAe,GAAG,gBAAgB,EAAE,kBAAkB,EAAE,CAAC;YAC/D;;;;;;;;;;;;;;;;;;;;;;eAsBG;YACH,MAAM,gBAAgB,GAAG,wBAAwB,CAAC,eAAe,IAAI,IAAI,EAAE,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;YACvF;;;;;;eAMG;YACH,MAAM,MAAM,GAAG,gBAAgB,CAAC,KAAK,KAAK,SAAS;mBAC9C,gBAAgB,CAAC,KAAK,KAAK,mBAAmB;mBAC9C,gBAAgB,CAAC,KAAK,KAAK,eAAe,CAAC;YAChD,IAAI,MAAM,EAAE,CAAC;gBACX,MAAM,CAAC,IAAI,CAAC,8BAA8B,EAAE;oBAC1C,KAAK,EAAE,IAAI;oBACX,KAAK,EAAE,gBAAgB,CAAC,KAAK;oBAC7B,MAAM,EAAE,gBAAgB,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC,gBAAgB,CAAC,SAAS;oBACpG,UAAU,EAAE,eAAe,CAAC,CAAC,CAAC,cAAc,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;oBAC9E;;;;;;;;;;;;;uBAaG;oBACH;;;;;;;;;uBASG;oBACH,MAAM,EACJ,yFAAyF;wBACzF,2EAA2E;wBAC3E,0FAA0F;wBAC1F,+CAA+C;oBACjD,QAAQ,EACN,yFAAyF;wBACzF,mFAAmF;wBACnF,oFAAoF;wBACpF,iFAAiF;wBACjF,cAAc;iBACjB,CAAC,CAAC;YACL,CAAC;YACD,MAAM,gBAAgB,GAAG,eAAe;gBACtC,CAAC,CAAC,MAAM,wBAAwB,CAAC,cAAc,CAAC,eAAe,CAAC,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC;gBACnF,CAAC,CAAC,IAAI,CAAC;YACT,MAAM,GAAG,GAAG,IAAI,yBAAyB,CAAC;gBACxC,SAAS,EAAE,cAAc;gBACzB,gBAAgB,EAAE,YAAY;gBAC9B,oBAAoB,EAAE,GAAG,EAAE,CAAC,iBAAiB;gBAC7C,sBAAsB,EAAE,GAAG,EAAE,CAAC,gBAAgB;gBAC9C,WAAW;gBACX,WAAW;gBACX,MAAM;aACP,CAAC,CAAC;YACH,IAAI,CAAC;gBACH,MAAM,MAAM,GAAG,MAAM,IAAI,mBAAmB,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,SAAS,EAAE,YAAY,EAAE,WAAW,CAAC,CAAC;gBACjG,IAAI,OAAO,IAAI,MAAM,EAAE,CAAC;oBACtB,MAAM,CAAC,IAAI,CAAC,qBAAqB,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC;oBAC9E,+EAA+E;oBAC/E,8EAA8E;oBAC9E,MAAM,kBAAkB,CAAC,IAAI,CAAC,CAAC;oBAC/B,2FAA2F;oBAC3F,sDAAsD;oBACtD,OAAO;wBACL,EAAE,EAAE,KAAK;wBACT,MAAM,EAAE,MAAM,CAAC,KAAK;wBACpB,QAAQ,EAAE,oBAAoB,CAAC,MAAM,CAAC,KAAK,EAAG,MAA8B,CAAC,MAAM,CAAC;qBACrF,CAAC;gBACJ,CAAC;gBACD,8FAA8F;gBAC9F,6FAA6F;gBAC7F,iEAAiE;gBACjE,MAAM,CAAC,IAAI,CAAC,4BAA4B,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,WAAW,EAAE,cAAc,EAAE,CAAC,CAAC;gBAC5F,0FAA0F;gBAC1F,kFAAkF;gBAClF,+FAA+F;gBAC/F,gGAAgG;gBAChG,kGAAkG;gBAClG,sFAAsF;gBACtF,iFAAiF;gBACjF,MAAM,SAAS,GAAG,kBAAkB,CAAC,IAAI,CAAC,CAAC;gBAC3C,IAAI,CAAC,SAAS,CAAC,EAAE,EAAE,CAAC;oBAClB,MAAM,CAAC,IAAI,CAAC,2CAA2C,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,CAAC,CAAC;gBAC1G,CAAC;qBAAM,CAAC;oBACN,+FAA+F;oBAC/F,wFAAwF;oBACxF,2FAA2F;oBAC3F,MAAM,CAAC,IAAI,CAAC,8CAA8C,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;gBACnF,CAAC;gBACD,0EAA0E;gBAC1E,yEAAyE;gBACzE,uEAAuE;gBACvE,0EAA0E;gBAC1E,gEAAgE;gBAChE,IAAI,CAAC;oBACH,MAAM,WAAW,CAAC,oBAAoB,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,QAAQ,EAAE,YAAY,EAAE,QAAQ,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;oBACzG,MAAM,CAAC,IAAI,CAAC,wBAAwB,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,QAAQ,EAAE,aAAa,EAAE,MAAM,CAAC,cAAc,EAAE,CAAC,CAAC;oBAC3H,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAE,cAAc,EAAE,MAAM,CAAC,cAAc,EAAE,CAAC;gBACxF,CAAC;gBAAC,OAAO,OAAgB,EAAE,CAAC;oBAC1B,MAAM,CAAC,IAAI,CAAC,uCAAuC,EAAE;wBACnD,SAAS,EAAE,IAAI;wBACf,OAAO,EAAE,MAAM,CAAC,QAAQ;wBACxB,KAAK,EAAE,mBAAmB,CAAC,OAAO,CAAC;qBACpC,CAAC,CAAC;oBACH,MAAM,CAAC,IAAI,CAAC,wBAAwB,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,QAAQ,EAAE,aAAa,EAAE,MAAM,CAAC,cAAc,EAAE,CAAC,CAAC;oBAC3H,OAAO;wBACL,EAAE,EAAE,IAAI;wBACR,QAAQ,EAAE,MAAM,CAAC,QAAQ;wBACzB,cAAc,EAAE,MAAM,CAAC,cAAc;wBACrC,OAAO,EAAE,8BAA8B;qBACxC,CAAC;gBACJ,CAAC;YACH,CAAC;oBAAS,CAAC;gBACT,GAAG,CAAC,OAAO,EAAE,CAAC;YAChB,CAAC;QACH,CAAC;gBAAS,CAAC;YACT,sBAAsB,GAAG,KAAK,CAAC;QACjC,CAAC;IACH,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/registration-context.d.ts

@@ -0,0 +1,72 @@
+/**
+ * DaemonRegistrationContext — CELLO-M7-REGISTRATION (Action 2, step c part 2).
+ *
+ * Implements the RegistrationManager's RegistrationContext seam against daemon
+ * internals. The one non-trivial piece is the signaling bridge: the client wrote
+ * directly to a raw persistent libp2p Stream and ran its own read loop; the
+ * daemon's directory signaling lives behind SignalingManager. So this context:
+ *   - sends frames via SignalingManager.sendRaw (which CBOR/length-prefix-encodes),
+ *   - registers ONE inbound handler that routes the registration reply frames
+ *     (dkg_ready / register_success / register_error) to whichever pending
+ *     resolver RegistrationManager.register() has currently armed.
+ *
+ * register() drives the two stages strictly sequentially (await dkg_ready, then
+ * await register_success), so at most one resolver is armed at any moment — which
+ * is why a bare register_error can be routed to "whichever stage is waiting".
+ */
+import type { CelloNode } from "@cello-protocol/transport";
+import type { IThresholdSigner, KeyProvider } from "@cello-protocol/crypto";
+import type { Logger } from "./types.js";
+import type { DaemonRegistrationPersistence } from "./registration-persistence.js";
+import type { RegistrationContext, SignalingSendResult } from "./registration-manager.js";
+import type { ConsortiumEndpoint } from "./directory-bootstrap.js";
+/**
+ * Structural slice of SignalingManager this context needs. The real
+ * SignalingManager satisfies this (status getter; sendRaw → OperationResult,
+ * assignable to SignalingSendResult; registerInboundHandler → unregister fn),
+ * and a fake satisfies it in tests.
+ */
+export interface SignalingSeam {
+    readonly status: string;
+    sendRaw(frame: unknown): Promise<SignalingSendResult>;
+    registerInboundHandler(handler: (frame: Record<string, unknown>) => void): () => void;
+}
+export declare class DaemonRegistrationContext implements RegistrationContext {
+    #private;
+    readonly keyProvider: KeyProvider;
+    readonly logger: Logger;
+    readonly persistence: DaemonRegistrationPersistence | null;
+    readonly mlDsaKeyFile: string | undefined;
+    constructor(opts: {
+        signaling: SignalingSeam;
+        getDirectoryNode: () => CelloNode | null;
+        getDirectoryEndpoint: () => {
+            peer_id: string;
+            multiaddrs: string[];
+        } | null;
+        getConsortiumEndpoints?: () => ConsortiumEndpoint[] | null;
+        keyProvider: KeyProvider;
+        persistence: DaemonRegistrationPersistence | null;
+        logger: Logger;
+        mlDsaKeyFile?: string | undefined;
+    });
+    getNode(): CelloNode | null;
+    getMyPubkeyHex(): string | null;
+    setMyPubkeyHex(hex: string): void;
+    getDirectoryEndpoint(): {
+        peer_id: string;
+        multiaddrs: string[];
+    } | null;
+    getConsortiumEndpoints(): ConsortiumEndpoint[] | null;
+    getThresholdSigner(): IThresholdSigner | undefined;
+    setThresholdSigner(signer: IThresholdSigner): void;
+    getMyPrimaryPubkey(): Uint8Array | null;
+    setMyPrimaryPubkey(pubkey: Uint8Array): void;
+    isSignalingConnected(): boolean;
+    sendSignalingFrame(frame: Record<string, unknown>): Promise<SignalingSendResult>;
+    setPendingDkgReadyResolve(resolve: ((frame: Record<string, unknown>) => void) | null): void;
+    setPendingRegisterResolve(resolve: ((frame: Record<string, unknown>) => void) | null): void;
+    /** Stop routing inbound frames (call when the owning agent is torn down). */
+    dispose(): void;
+}
+//# sourceMappingURL=registration-context.d.ts.map

package/dist/registration-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registration-context.d.ts","sourceRoot":"","sources":["../src/registration-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAC5E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,+BAA+B,CAAC;AACnF,OAAO,KAAK,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAC1F,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAEnE;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC;IACtD,sBAAsB,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;CACvF;AAID,qBAAa,yBAA0B,YAAW,mBAAmB;;IACnE,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,6BAA6B,GAAG,IAAI,CAAC;IAC3D,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;gBAc9B,IAAI,EAAE;QAChB,SAAS,EAAE,aAAa,CAAC;QACzB,gBAAgB,EAAE,MAAM,SAAS,GAAG,IAAI,CAAC;QACzC,oBAAoB,EAAE,MAAM;YAAE,OAAO,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,EAAE,CAAA;SAAE,GAAG,IAAI,CAAC;QAC7E,sBAAsB,CAAC,EAAE,MAAM,kBAAkB,EAAE,GAAG,IAAI,CAAC;QAC3D,WAAW,EAAE,WAAW,CAAC;QACzB,WAAW,EAAE,6BAA6B,GAAG,IAAI,CAAC;QAClD,MAAM,EAAE,MAAM,CAAC;QACf,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;KACnC;IAiBD,OAAO,IAAI,SAAS,GAAG,IAAI;IAI3B,cAAc,IAAI,MAAM,GAAG,IAAI;IAI/B,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAIjC,oBAAoB,IAAI;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,EAAE,CAAA;KAAE,GAAG,IAAI;IAIxE,sBAAsB,IAAI,kBAAkB,EAAE,GAAG,IAAI;IAIrD,kBAAkB,IAAI,gBAAgB,GAAG,SAAS;IAIlD,kBAAkB,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI;IAIlD,kBAAkB,IAAI,UAAU,GAAG,IAAI;IAIvC,kBAAkB,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAM5C,oBAAoB,IAAI,OAAO;IAIzB,kBAAkB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAItF,yBAAyB,CAAC,OAAO,EAAE,CAAC,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC,GAAG,IAAI,GAAG,IAAI;IAI3F,yBAAyB,CAAC,OAAO,EAAE,CAAC,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC,GAAG,IAAI,GAAG,IAAI;IAI3F,6EAA6E;IAC7E,OAAO,IAAI,IAAI;CAuChB"}

package/dist/registration-context.js

@@ -0,0 +1,126 @@
+/**
+ * DaemonRegistrationContext — CELLO-M7-REGISTRATION (Action 2, step c part 2).
+ *
+ * Implements the RegistrationManager's RegistrationContext seam against daemon
+ * internals. The one non-trivial piece is the signaling bridge: the client wrote
+ * directly to a raw persistent libp2p Stream and ran its own read loop; the
+ * daemon's directory signaling lives behind SignalingManager. So this context:
+ *   - sends frames via SignalingManager.sendRaw (which CBOR/length-prefix-encodes),
+ *   - registers ONE inbound handler that routes the registration reply frames
+ *     (dkg_ready / register_success / register_error) to whichever pending
+ *     resolver RegistrationManager.register() has currently armed.
+ *
+ * register() drives the two stages strictly sequentially (await dkg_ready, then
+ * await register_success), so at most one resolver is armed at any moment — which
+ * is why a bare register_error can be routed to "whichever stage is waiting".
+ */
+const REGISTRATION_REPLY_TYPES = new Set(["dkg_ready", "register_success", "register_error"]);
+export class DaemonRegistrationContext {
+    keyProvider;
+    logger;
+    persistence;
+    mlDsaKeyFile;
+    #signaling;
+    #getDirectoryNode;
+    #getDirectoryEndpoint;
+    #getConsortiumEndpoints;
+    #unregisterInbound;
+    #myPubkeyHex = null;
+    #thresholdSigner = undefined;
+    #myPrimaryPubkey = null;
+    #pendingDkgReady = null;
+    #pendingRegister = null;
+    constructor(opts) {
+        this.#signaling = opts.signaling;
+        this.#getDirectoryNode = opts.getDirectoryNode;
+        this.#getDirectoryEndpoint = opts.getDirectoryEndpoint;
+        // Default to null → "no consortium manifest configured" → single-node DKG (back-compat for
+        // callers/tests that don't supply a roster). null (no manifest) is distinct from [] (manifest
+        // configured but unresolved → refuse) — see RegistrationContext.getConsortiumEndpoints.
+        this.#getConsortiumEndpoints = opts.getConsortiumEndpoints ?? (() => null);
+        this.keyProvider = opts.keyProvider;
+        this.persistence = opts.persistence;
+        this.logger = opts.logger;
+        this.mlDsaKeyFile = opts.mlDsaKeyFile;
+        this.#unregisterInbound = this.#signaling.registerInboundHandler((frame) => this.#onInbound(frame));
+    }
+    // ─── Node + identity ────────────────────────────────────────────────────────
+    getNode() {
+        return this.#getDirectoryNode();
+    }
+    getMyPubkeyHex() {
+        return this.#myPubkeyHex;
+    }
+    setMyPubkeyHex(hex) {
+        this.#myPubkeyHex = hex;
+    }
+    getDirectoryEndpoint() {
+        return this.#getDirectoryEndpoint();
+    }
+    getConsortiumEndpoints() {
+        return this.#getConsortiumEndpoints();
+    }
+    getThresholdSigner() {
+        return this.#thresholdSigner;
+    }
+    setThresholdSigner(signer) {
+        this.#thresholdSigner = signer;
+    }
+    getMyPrimaryPubkey() {
+        return this.#myPrimaryPubkey;
+    }
+    setMyPrimaryPubkey(pubkey) {
+        this.#myPrimaryPubkey = pubkey;
+    }
+    // ─── Signaling seam ──────────────────────────────────────────────────────────
+    isSignalingConnected() {
+        return this.#signaling.status === "connected";
+    }
+    async sendSignalingFrame(frame) {
+        return this.#signaling.sendRaw(frame);
+    }
+    setPendingDkgReadyResolve(resolve) {
+        this.#pendingDkgReady = resolve;
+    }
+    setPendingRegisterResolve(resolve) {
+        this.#pendingRegister = resolve;
+    }
+    /** Stop routing inbound frames (call when the owning agent is torn down). */
+    dispose() {
+        this.#unregisterInbound();
+        this.#pendingDkgReady = null;
+        this.#pendingRegister = null;
+    }
+    // ─── Inbound routing ──────────────────────────────────────────────────────────
+    #onInbound(frame) {
+        const type = frame["type"];
+        if (typeof type !== "string" || !REGISTRATION_REPLY_TYPES.has(type)) {
+            return; // not a registration reply — leave it for other inbound handlers
+        }
+        if (type === "dkg_ready") {
+            const resolve = this.#pendingDkgReady;
+            this.#pendingDkgReady = null;
+            resolve?.(frame);
+            return;
+        }
+        if (type === "register_success") {
+            const resolve = this.#pendingRegister;
+            this.#pendingRegister = null;
+            resolve?.(frame);
+            return;
+        }
+        // register_error → deliver to whichever stage is currently waiting.
+        // Stages are sequential, so at most one resolver is armed.
+        if (this.#pendingDkgReady) {
+            const resolve = this.#pendingDkgReady;
+            this.#pendingDkgReady = null;
+            resolve(frame);
+        }
+        else if (this.#pendingRegister) {
+            const resolve = this.#pendingRegister;
+            this.#pendingRegister = null;
+            resolve(frame);
+        }
+    }
+}
+//# sourceMappingURL=registration-context.js.map

package/dist/registration-context.js.map

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