@ouro.bot/cli 0.1.0-alpha.99 → 0.1.0-alpha.990

package/dist/a2a/inbound-share.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.receiveInboundShare = receiveInboundShare;
+const a2a_client_1 = require("@ouro.bot/friends/a2a-client");
+const friends_1 = require("@ouro.bot/friends");
+const runtime_1 = require("../nerves/runtime");
+const seen_ledger_1 = require("./seen-ledger");
+/** Whether the inbound message carries a friends data part (kind:"data"). */
+function hasDataPart(message) {
+    return Array.isArray(message.parts) && message.parts.some((p) => p && p.kind === "data");
+}
+/**
+ * Bridge an inbound A2A message through friends' `receiveShare`, keying the result
+ * on the VERIFIED sender DID.
+ *
+ * Ordering (the security-critical trap — `trustOfSource` is read from the store BY
+ * the just-verified DID, never defaulted, never from the envelope):
+ *   1. `unwrapDataPart` — no friends part ⇒ `not-a-share` (caller does text path).
+ *   2. `openSealedEnvelope` (pre-unseal) — extract the SIGNED sender DID. Unseal /
+ *      recipient-mismatch failures ⇒ `rejected` (no turn). (This open does NOT
+ *      verify the signature; the real auth gate is the `DidVerifier` inside
+ *      `receiveShare`, so a forged-high-trust claim here is harmless — the forge is
+ *      rejected by the verifier regardless of the trust we read.)
+ *   3. `settleSender(verifiedDid)` — apply a signed rotation to that DID, or finish
+ *      one whose record did not follow, BEFORE trust is read, so the first message
+ *      after a rotation is judged against the moved record. A rejected rotation, or
+ *      a record that still cannot follow ⇒ `resolve_failed`, nothing consumed. (A
+ *      successor statement carries its own two signatures, so applying it before
+ *      this message's signature is checked gives a forger nothing.)
+ *   4. `findFriendByDid(store, verifiedDid)` — read trust off that record; an
+ *      unknown DID ⇒ `stranger` (never a default-up).
+ *   5. `receiveShare({ ..., trustOfSource })` — re-unseal (deterministic) + resolve
+ *      & pin + run `DidVerifier` (forge fails HERE) + replay-dedup + import.
+ *   6. Map the result. `completed` ⇒ run the turn at `verifiedDid`/`trust`.
+ */
+async function receiveInboundShare(message, deps) {
+    const friendsMessage = message;
+    const payload = (0, a2a_client_1.unwrapDataPart)(friendsMessage);
+    if (!payload) {
+        // No (valid) friends part. If there was a data part at all, it was a malformed
+        // friends attempt → reject; otherwise it's a legacy text message → not-a-share.
+        if (hasDataPart(message)) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "channels",
+                event: "channel.a2a_inbound_rejected",
+                message: "rejected malformed inbound A2A data part",
+                meta: { reason: "malformed_message" },
+            });
+            return { outcome: "rejected", reason: "malformed_message" };
+        }
+        return { outcome: "not-a-share" };
+    }
+    const recipientIdentity = {
+        x25519Priv: deps.identity.x25519Priv,
+        x25519Pub: deps.identity.x25519Pub,
+    };
+    // Pre-unseal to learn the SIGNED sender DID before we can read its trust.
+    const opened = (0, a2a_client_1.openSealedEnvelope)({
+        sodium: deps.sodium,
+        sealedEnvelope: { v: payload.v, sealed: payload.sealed },
+        recipientDid: deps.identity.did,
+        recipientIdentity,
+    });
+    if (!opened.ok) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "channels",
+            event: "channel.a2a_inbound_rejected",
+            message: "rejected inbound A2A envelope (unseal/recipient)",
+            meta: { reason: opened.error },
+        });
+        return { outcome: "rejected", reason: opened.error };
+    }
+    const verifiedDid = opened.fromAgentId;
+    if (!(await deps.didResolution.settleSender({ did: verifiedDid, pinStore: deps.pinStore }))) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "channels",
+            event: "channel.a2a_inbound_rejected",
+            message: "rejected inbound A2A share (the sender's key rotation could not be applied)",
+            meta: { reason: "resolve_failed", verifiedDid },
+        });
+        return { outcome: "rejected", reason: "resolve_failed" };
+    }
+    // Read trust from the friend store BY the verified DID — never defaulted, never
+    // from the envelope. Unknown (or empty) DID ⇒ stranger. `findFriendByDid` itself
+    // refuses a falsy did (never matches a did-less record), so this is safe to call
+    // unconditionally.
+    const record = await (0, friends_1.findFriendByDid)(deps.store, verifiedDid);
+    const trust = record?.trustLevel ?? "stranger";
+    const result = await (0, a2a_client_1.receiveShare)({
+        sodium: deps.sodium,
+        store: deps.store,
+        missionStore: deps.missionStore,
+        pinStore: deps.pinStore,
+        didResolution: deps.didResolution,
+        seen: deps.seen,
+        a2aMessage: friendsMessage,
+        recipientDid: deps.identity.did,
+        recipientIdentity,
+        trustOfSource: trust,
+        // Every sender on friends alpha.15 or later binds its envelopes to recipient, kind, id and time; an unbound
+        // envelope can be replayed or re-sealed to another recipient, so it is refused.
+        options: { ...(0, seen_ledger_1.bindingWindowsWithinRetention)(deps.bindingOptions), rejectUnboundEnvelopes: true },
+    });
+    if (result.state === "completed") {
+        (0, runtime_1.emitNervesEvent)({
+            component: "channels",
+            event: "channel.a2a_inbound_verified",
+            message: "verified inbound A2A share; keying turn on sender DID",
+            meta: { verifiedDid, trust, friendsKind: result.friendsKind, status: result.status },
+        });
+        return {
+            outcome: "completed",
+            verifiedDid,
+            trust,
+            friendsKind: result.friendsKind,
+            status: result.status,
+            ...(result.message ? { message: result.message } : {}),
+            // Unbound envelopes are refused above, so a completed receipt always carries its signed binding id.
+            bindingId: result.bindingId,
+            /* v8 ignore next -- a completed receipt implies a trusted friend record: an unknown DID reads as stranger and is refused @preserve */
+            ...(record ? { friend: record } : {}),
+        };
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "channels",
+        event: "channel.a2a_inbound_rejected",
+        message: "rejected inbound A2A share",
+        meta: { reason: result.reason, verifiedDid, trust },
+    });
+    return { outcome: "rejected", reason: result.reason };
+}

package/dist/a2a/mission-result-wire.js

@@ -0,0 +1,265 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapMissionResultDataPart = wrapMissionResultDataPart;
+exports.isMissionResultDataPart = isMissionResultDataPart;
+exports.sealedBlobKey = sealedBlobKey;
+exports.receiveInboundMissionResult = receiveInboundMissionResult;
+const a2a_client_1 = require("@ouro.bot/friends/a2a-client");
+const friends_1 = require("@ouro.bot/friends");
+const runtime_1 = require("../nerves/runtime");
+const seen_ledger_1 = require("./seen-ledger");
+/**
+ * THE HARNESS-OWNED RESULT WIRE.
+ *
+ * A mission RESULT is NOT a `FriendsKind` (`FriendsKind` = profile_share |
+ * mission_share | coordination) — `prepareMissionResult`/`importMissionResult` are
+ * transport-agnostic + store-only, and the result does NOT ride `sendShare`/
+ * `receiveShare`. So the HARNESS owns the wire: the result envelope is sealed (reusing
+ * the sign-then-seal crypto) and wrapped in a DataPart carrying a distinct `ouroKind:
+ * "mission_result"` discriminator. The inbound bridge recognizes that tag and routes
+ * it to `importMissionResult` — NEVER to `receiveShare`, which would mis-route a
+ * non-`FriendsKind` envelope. This is "a DataPart variant + an inbound route branch"
+ * (the carrier is the friends `unwrapDataPart` shape + one extra tag field — no
+ * structural change beyond that).
+ *
+ * SECURITY — the wire AUTHENTICATES the sender exactly like the share path
+ * (`receiveShare` in friends' `adapter.ts`). `openSealedEnvelope` does AEAD
+ * decryption ONLY — it does NOT verify the signature (its docstring names the
+ * adapter's `DidVerifier` as "the single authentication gate"). The decrypted
+ * `envelope.fromAgentId` is therefore attacker-controlled plaintext: the recipient's
+ * X25519 pubkey is public (derived from the published DID), so any party can SEAL a
+ * forged result to us. Authentication is the ONLY barrier. Before trusting the
+ * claimed sender we therefore replicate `receiveShare`'s gate:
+ *   1. binding check — `opened.signerDid === opened.fromAgentId` (and non-empty),
+ *   2. resolve + pin the sender DID (TOFU pin + signed-rotation evaluation),
+ *   3. hand `importMissionResult` a REAL `DidVerifier` bound to the pinned key, so
+ *      `verifier.verify(fromAgentId, proof)` runs the Ed25519 signature check against
+ *      the pinned key — NOT the no-op `tofuVerifier` the importer defaults to.
+ * Replay is deduped on a hash of the whole sealed blob (durable `SeenLedger`), matching the share path.
+ */
+const OURO_RESULT_KIND = "mission_result";
+/** Wrap a sealed result envelope into the harness-owned `mission_result` DataPart. */
+function wrapMissionResultDataPart(input) {
+    return {
+        messageId: `result-${Math.random().toString(36).slice(2)}`,
+        role: "agent",
+        parts: [{
+                kind: "data",
+                data: {
+                    v: input.sealedEnvelope.v,
+                    sealed: input.sealedEnvelope.sealed,
+                    recipientDid: input.recipientDid,
+                    ouroKind: OURO_RESULT_KIND,
+                },
+            }],
+    };
+}
+/** Whether an inbound message carries the harness-owned `mission_result` DataPart. */
+function isMissionResultDataPart(message) {
+    if (!Array.isArray(message.parts))
+        return false;
+    return message.parts.some((p) => p && p.kind === "data" && typeof p.data === "object" && p.data !== null
+        && p.data.ouroKind === OURO_RESULT_KIND);
+}
+/** Extract the sealed envelope from a `mission_result` DataPart, or null. */
+function unwrapMissionResultDataPart(message) {
+    if (!Array.isArray(message.parts) || message.parts.length !== 1)
+        return null;
+    const part = message.parts[0];
+    if (!part || part.kind !== "data" || !part.data)
+        return null;
+    const data = part.data;
+    if (data.ouroKind !== OURO_RESULT_KIND)
+        return null;
+    if (typeof data.v !== "number" || typeof data.recipientDid !== "string" || !data.sealed)
+        return null;
+    return { sealed: { v: data.v, sealed: data.sealed }, recipientDid: data.recipientDid };
+}
+/** The ledger key for one sealed blob: a hash over its ephemeral key, nonce and ciphertext. Same form as friends'
+ * `receiveShare` key, so a blob accepted on either path is a replay on the other. */
+function sealedBlobKey(sodium, blob) {
+    const digest = sodium.crypto_generichash(24, `${blob.ePk}|${blob.n}|${blob.ct}`, null);
+    return `blob:${sodium.to_base64(digest, sodium.base64_variants.URLSAFE_NO_PADDING)}`;
+}
+/** Results being processed, per seen ledger: a parallel duplicate is refused as `in_flight` (retryable) without
+ * touching the durable ledger, matching friends' `receiveShare`. */
+const IN_FLIGHT = new WeakMap();
+function inFlightFor(seen) {
+    let set = IN_FLIGHT.get(seen);
+    if (!set) {
+        set = new Set();
+        IN_FLIGHT.set(seen, set);
+    }
+    return set;
+}
+function rejectResult(reason, message, meta = {}) {
+    (0, runtime_1.emitNervesEvent)({ component: "channels", event: "channel.a2a_result_rejected", message, meta: { reason, ...meta } });
+    return { outcome: "rejected", reason };
+}
+/**
+ * Route an inbound `mission_result` DataPart to `importMissionResult`, AUTHENTICATING
+ * the sender exactly like `receiveShare` does for every other inbound kind.
+ *
+ * Ordering (mirrors the share bridge's trust trap + authentication gate):
+ *   1. recognize + unwrap the harness `mission_result` carrier (else `not-a-result`).
+ *   2. replay dedup on a hash of the whole sealed blob, then the in-flight claim on
+ *      that hash. The bare seal nonce is never consulted.
+ *   3. `openSealedEnvelope` → AEAD-decrypt only (unseal/recipient failures → reject).
+ *   4. sender binding — reject unless `opened.signerDid === opened.fromAgentId` (and
+ *      non-empty): the advisory `signerDid` (outer, unsigned) must match the claimed
+ *      sender. A divergence is a forged/spoofed bundle (`sender_binding_mismatch`).
+ *   5. a retired sender pin → `retired_pin`.
+ *   6. the signed envelope binding (`checkEnvelopeBinding`: this recipient, this kind,
+ *      a fresh issue time, an unseen `mid:` message id), then claim the blob hash and
+ *      the `mid:` key in flight (released on every exit).
+ *   7. `settleSender` — apply a signed rotation to the sender DID, or finish one whose
+ *      record did not follow, BEFORE trust is read (refused → `resolve_failed`).
+ *   8. read trust by the sender DID, then `resolveAndPin` it (TOFU pin) → the pinned
+ *      key (unresolvable → `resolve_failed`).
+ *   9. build a `DidVerifier` bound to THIS envelope + the pinned key and call
+ *      `importMissionResult({ envelope, fromAgentId: <signed DID>, trustOfSource },
+ *      { verifier })`. The verifier runs the REAL signature check against the pinned
+ *      key and marks the claimed keys seen only when it passes; a result signed with
+ *      any other key is rejected (`untrusted_source`). Every authorization gate
+ *      (no_mission / no_delegation / assignee_mismatch, fail-closed on a legacy
+ *      assignee-less delegation) is still enforced by the importer.
+ */
+async function receiveInboundMissionResult(message, deps) {
+    const payload = unwrapMissionResultDataPart(message);
+    if (!payload)
+        return { outcome: "not-a-result" };
+    // Replay dedup BEFORE any state change, keyed only on a hash of the whole sealed blob. The sender picks the seal
+    // nonce, and friends' share path marks a bare nonce for any share whose signature verifies, so reading the bare nonce
+    // here would let a stranger's share or result burn a real result. A re-sealed copy of the same signed result is still
+    // refused by its `mid:` key, and re-importing a result changes nothing (the first result per request wins).
+    const blobKey = sealedBlobKey(deps.sodium, payload.sealed.sealed);
+    if (deps.seen.isSeen(blobKey)) {
+        return rejectResult("replayed", "rejected inbound mission_result (already received)");
+    }
+    const inFlight = inFlightFor(deps.seen);
+    if (inFlight.has(blobKey))
+        return rejectResult("in_flight", "rejected inbound mission_result (the same result is being processed)");
+    const recipientIdentity = { x25519Priv: deps.identity.x25519Priv, x25519Pub: deps.identity.x25519Pub };
+    const opened = (0, a2a_client_1.openSealedEnvelope)({
+        sodium: deps.sodium,
+        sealedEnvelope: payload.sealed,
+        recipientDid: deps.identity.did,
+        recipientIdentity,
+    });
+    if (!opened.ok) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "channels",
+            event: "channel.a2a_result_rejected",
+            message: "rejected inbound mission_result (unseal/recipient)",
+            meta: { reason: opened.error },
+        });
+        return { outcome: "rejected", reason: opened.error };
+    }
+    // SECURITY (binding): the trustworthy sender identity is the SIGNED `fromAgentId`.
+    // `openSealedEnvelope` does NOT verify the signature, so `fromAgentId` is untrusted
+    // until the DidVerifier confirms the pinned key signed THIS envelope. The advisory
+    // `signerDid` (from the outer, unsigned sealed plaintext) must match the claimed
+    // sender; a divergence is a forged/spoofed bundle (e.g. an attacker signing with its
+    // OWN key while claiming a victim's DID). Reject before resolving or importing.
+    const senderDid = opened.fromAgentId;
+    if (senderDid.length === 0 || opened.signerDid !== senderDid) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "channels",
+            event: "channel.a2a_result_rejected",
+            message: "rejected inbound mission_result (sender binding mismatch — forged sender)",
+            meta: { reason: "sender_binding_mismatch", claimedDid: senderDid, signerDid: opened.signerDid },
+        });
+        return { outcome: "rejected", reason: "sender_binding_mismatch" };
+    }
+    // A retired pin is a tombstone: the old DID's key verifies nothing (matches receiveShare).
+    if (deps.pinStore.get(senderDid)?.retiredBy !== undefined) {
+        return rejectResult("retired_pin", "rejected inbound mission_result (the sender's DID was rotated away)", { verifiedDid: senderDid });
+    }
+    // The signed binding: this recipient, this kind, a fresh issue time and an unseen message id.
+    const binding = (0, a2a_client_1.checkEnvelopeBinding)(opened, { ...(0, seen_ledger_1.bindingWindowsWithinRetention)(deps.bindingOptions), rejectUnboundEnvelopes: true, recipientDid: deps.identity.did, seen: deps.seen });
+    if (!binding.ok)
+        return rejectResult(binding.reason, "rejected inbound mission_result (signed binding)", { verifiedDid: senderDid });
+    /* v8 ignore next -- an unbound envelope is refused above, so a passing binding always carries its seen key @preserve */
+    const claimed = binding.seenKey ? [blobKey, binding.seenKey] : [blobKey];
+    /* v8 ignore next -- the same binding id under a different seal nonce needs a hand-built seal (sealEnvelope mints a fresh id) @preserve */
+    if (claimed.some((key) => inFlight.has(key)))
+        return rejectResult("in_flight", "rejected inbound mission_result (the same result is being processed)");
+    for (const key of claimed)
+        inFlight.add(key);
+    try {
+        return await processClaimedResult(opened, senderDid, claimed, deps);
+    }
+    finally {
+        for (const key of claimed)
+            inFlight.delete(key);
+    }
+}
+async function processClaimedResult(opened, senderDid, claimed, deps) {
+    // Settle a rotation to this DID first, so the first result after it is judged against the moved record.
+    if (!(await deps.didResolution.settleSender({ did: senderDid, pinStore: deps.pinStore }))) {
+        return rejectResult("resolve_failed", "rejected inbound mission_result (the sender's key rotation could not be applied)", { verifiedDid: senderDid });
+    }
+    // Read trust from the friend store BY the verified DID — never defaulted, never from
+    // the envelope. Unknown (or empty) DID ⇒ stranger.
+    const record = await (0, friends_1.findFriendByDid)(deps.store, senderDid);
+    const trust = record?.trustLevel ?? "stranger";
+    // Resolve + pin the SENDER's DID (async — BEFORE the sync verifier/importer).
+    const resolved = await deps.didResolution.resolveAndPin({
+        fromAgentId: senderDid,
+        did: senderDid,
+        pinStore: deps.pinStore,
+        trustOfSource: trust,
+    });
+    if (!resolved) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "channels",
+            event: "channel.a2a_result_rejected",
+            message: "rejected inbound mission_result (sender DID resolve/pin failed)",
+            meta: { reason: "resolve_failed", verifiedDid: senderDid, trust },
+        });
+        return { outcome: "rejected", reason: "resolve_failed" };
+    }
+    // Build the sync verifier bound to THIS envelope + the pinned sender key. This is the
+    // single authentication gate (the importer would otherwise default to the no-op TOFU
+    // verifier). `verify` confirms the agentId===did binding AND the Ed25519 signature
+    // over the envelope against the pinned key.
+    const didVerifier = new a2a_client_1.DidVerifier({
+        sodium: deps.sodium,
+        pinnedEd25519Pub: resolved.ed25519Pub,
+        pinnedDid: senderDid,
+        envelope: opened.envelope,
+    });
+    // The result is consumed the moment its signature verifies (and not before), so a failure before that leaves it
+    // redeliverable. The keys are the whole-blob hash and the sender-scoped `mid:` id, so no other sender's message,
+    // share or result, can burn this one by reusing its seal nonce.
+    const verifier = {
+        verify(fromAgentId, proof) {
+            const ok = didVerifier.verify(fromAgentId, proof);
+            if (ok)
+                for (const key of claimed)
+                    deps.seen.markSeen(key);
+            return ok;
+        },
+    };
+    const result = await (0, friends_1.importMissionResult)(deps.missionStore, {
+        envelope: opened.envelope,
+        fromAgentId: senderDid,
+        trustOfSource: trust,
+    }, { verifier });
+    if (result.ok) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "channels",
+            event: "channel.a2a_result_imported",
+            message: "imported inbound mission_result (authenticated, quarantined, attributed)",
+            meta: { verifiedDid: senderDid, trust, status: result.status },
+        });
+        return { outcome: "imported", verifiedDid: senderDid };
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "channels",
+        event: "channel.a2a_result_rejected",
+        message: "rejected inbound mission_result (import gate)",
+        meta: { reason: result.status, verifiedDid: senderDid, trust },
+    });
+    return { outcome: "rejected", reason: result.status };
+}

package/dist/a2a/onboarding.js

@@ -0,0 +1,133 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onboardA2APeer = onboardA2APeer;
+exports.onboardA2AClientByDid = onboardA2AClientByDid;
+const path = __importStar(require("node:path"));
+const identity_1 = require("../heart/identity");
+const runtime_1 = require("../nerves/runtime");
+const friends_1 = require("@ouro.bot/friends");
+const a2a_client_1 = require("@ouro.bot/friends/a2a-client");
+const client_1 = require("./client");
+function storeFor(options) {
+    if (options.store)
+        return options.store;
+    /* v8 ignore next -- default bundle root fallback is owned by identity path tests; CLI and onboarding tests inject explicit roots @preserve */
+    return new friends_1.FileFriendStore(path.join(options.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)(), `${options.agentName}.ouro`, "friends"));
+}
+/** The normalized card URL (legacy URL-keyed identity for did-less cards). */
+function urlAgentId(cardUrl) {
+    const parsed = new URL(cardUrl);
+    parsed.hash = "";
+    return parsed.toString();
+}
+async function onboardA2APeer(options) {
+    // HTTP/URL glue stays harness-side: fetch the agent card, resolve its JSON-RPC
+    // endpoint, and derive the stable agentId. The record-shaping (mint/update the
+    // agent-peer friend) is delegated to @ouro.bot/friends' upsertAgentPeer.
+    const card = await (0, client_1.fetchA2AAgentCard)(options.cardUrl, options.fetchImpl);
+    const store = storeFor(options);
+    /* v8 ignore next -- fetchA2AAgentCard validates a usable endpoint or legacy url before returning a card @preserve */
+    const endpointUrl = (0, client_1.endpointForCard)(card) ?? options.cardUrl;
+    const protocolVersion = card.supportedInterfaces?.find((entry) => entry.url === endpointUrl)?.protocolVersion
+        ?? card.protocolVersion;
+    const name = options.name ?? card.name;
+    // THE FOOTGUN FIX: a DID-bearing card keys the record on its VERIFIED did:key
+    // (so an inbound sealed envelope — keyed on the signed DID — resolves to THIS
+    // record, not a stranger). A did-less (legacy) card keeps the URL-keyed identity
+    // unchanged (backward compatible). For did:key the binding is self-contained
+    // (`card.did === did`, `didDoc: null`); we ALSO require the served did:key to be a
+    // well-formed, parseable Ed25519 key (a malformed did:key could never key/verify
+    // an inbound envelope, so onboarding it would silently break the resolve later). A
+    // card whose DID is unparseable or fails the binding is REFUSED (no record
+    // written) — never TOFU-trust a mis-bound or malformed card.
+    const did = (0, client_1.cardDid)(card);
+    if (did) {
+        const parsed = (0, a2a_client_1.parseDidKey)(did);
+        const bound = parsed !== null && (0, a2a_client_1.verifyCardDidBinding)({ card: { did, url: options.cardUrl }, did, didDoc: null });
+        if (!bound) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "friends",
+                event: "friends.a2a_card_binding_rejected",
+                message: "refused A2A onboarding: card↔DID binding failed",
+                meta: { agentName: options.agentName, cardUrl: options.cardUrl, did, parseable: parsed !== null },
+            });
+            throw new Error(`A2A card↔DID binding failed for ${did}`);
+        }
+    }
+    // DID-keyed when present (externalId === did, a2a.did === did), else URL-keyed.
+    const externalId = did ?? urlAgentId(options.cardUrl);
+    const record = await (0, friends_1.upsertAgentPeer)(store, {
+        name,
+        agentId: externalId,
+        ...(options.trustLevel ? { trustLevel: options.trustLevel } : {}),
+        a2a: {
+            cardUrl: options.cardUrl,
+            endpointUrl,
+            agentId: externalId,
+            protocolVersion,
+            ...(did ? { did } : {}),
+        },
+    });
+    (0, runtime_1.emitNervesEvent)({
+        component: "friends",
+        event: "friends.a2a_peer_onboarded",
+        message: "onboarded A2A peer into friend model",
+        meta: { agentName: options.agentName, friendId: record.id, peerName: record.name, trustLevel: record.trustLevel, ...(did ? { did } : {}) },
+    });
+    return record;
+}
+/**
+ * Onboard a client that serves no agent card (for example a coding harness with a
+ * file-backed identity) by its did:key alone. The record is keyed on the DID, so its
+ * signed, sealed messages resolve to this friend; the key must parse, or nothing is written.
+ */
+async function onboardA2AClientByDid(options) {
+    if ((0, a2a_client_1.parseDidKey)(options.did) === null)
+        throw new Error(`not a valid did:key: ${options.did}`);
+    const record = await (0, friends_1.upsertAgentPeer)(storeFor(options), {
+        name: options.name,
+        agentId: options.did,
+        ...(options.trustLevel ? { trustLevel: options.trustLevel } : {}),
+        a2a: { did: options.did, agentId: options.did },
+    });
+    (0, runtime_1.emitNervesEvent)({
+        component: "friends",
+        event: "friends.a2a_client_onboarded",
+        message: "onboarded card-less A2A client into friend model",
+        meta: { agentName: options.agentName, friendId: record.id, peerName: record.name, trustLevel: record.trustLevel, did: options.did },
+    });
+    return record;
+}