@ouro.bot/cli 0.1.0-alpha.85 → 0.1.0-alpha.851

package/dist/a2a/config.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.A2A_DEFAULT_PATH = exports.A2A_DEFAULT_HOST = exports.A2A_DEFAULT_PROTOCOL_VERSION = void 0;
+exports.defaultA2APort = defaultA2APort;
+exports.normalizeA2APath = normalizeA2APath;
+exports.a2aEndpointFromBaseUrl = a2aEndpointFromBaseUrl;
+const node_crypto_1 = require("node:crypto");
+const runtime_1 = require("../nerves/runtime");
+exports.A2A_DEFAULT_PROTOCOL_VERSION = "1.0";
+exports.A2A_DEFAULT_HOST = "127.0.0.1";
+exports.A2A_DEFAULT_PATH = "/a2a";
+function defaultA2APort(agentName) {
+    const digest = (0, node_crypto_1.createHash)("sha256").update(agentName).digest();
+    const port = 18920 + (digest[0] % 60);
+    (0, runtime_1.emitNervesEvent)({
+        component: "channels",
+        event: "channel.a2a_default_port",
+        message: "computed default A2A port",
+        meta: { agentName, port },
+    });
+    return port;
+}
+function normalizeA2APath(value) {
+    const trimmed = value?.trim();
+    const normalized = !trimmed
+        ? exports.A2A_DEFAULT_PATH
+        : trimmed.startsWith("/")
+            ? trimmed
+            : `/${trimmed}`;
+    (0, runtime_1.emitNervesEvent)({
+        component: "channels",
+        event: "channel.a2a_path_normalized",
+        message: "normalized A2A path",
+        meta: { normalized },
+    });
+    return normalized;
+}
+function a2aEndpointFromBaseUrl(baseUrl, a2aPath = exports.A2A_DEFAULT_PATH) {
+    const url = new URL(baseUrl);
+    url.pathname = normalizeA2APath(a2aPath);
+    url.search = "";
+    url.hash = "";
+    (0, runtime_1.emitNervesEvent)({
+        component: "channels",
+        event: "channel.a2a_endpoint_built",
+        message: "built A2A endpoint URL",
+        meta: { endpoint: url.toString() },
+    });
+    return url.toString();
+}

package/dist/a2a/delegated-command.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DELEGATED_BANNER = void 0;
+exports.delegatedCommandNotice = delegatedCommandNotice;
+exports.admitDelegatedCommand = admitDelegatedCommand;
+const runtime_1 = require("../nerves/runtime");
+const relationship_authorization_1 = require("../repertoire/relationship-authorization");
+const NOTICE_EXCERPT_CHARS = 200;
+/** Matches the banner only the server may put in front of an admitted command. */
+exports.DELEGATED_BANNER = /^\s*\[\s*delegated command/iu;
+function delegatedCommandNotice(input) {
+    const flat = input.text.replace(/\s+/gu, " ").trim();
+    const excerpt = flat.length > NOTICE_EXCERPT_CHARS ? `${flat.slice(0, NOTICE_EXCERPT_CHARS)}…` : flat;
+    return `Delegated command from you via ${input.delegateName}: "${excerpt}". If this wasn't you, say so here: it is on record, and the grant can be revoked.`;
+}
+function hasPrincipalGrant(friend) {
+    return friend.delegationGrant?.scope === "principal_commands";
+}
+async function resolvePrincipal(store, profileId) {
+    const friends = await store.listAll?.() ?? [];
+    const matches = friends.filter((friend) => friend.capabilityProfileId === profileId
+        && friend.trustLevel === "family" && friend.admissionState === "active");
+    return matches.length === 1 ? matches[0] : null;
+}
+async function admitDelegatedCommand(input) {
+    const refuse = (reason) => {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.a2a_delegated_command_refused",
+            message: "refused a delegated A2A command",
+            meta: { reason, delegateFriendId: input.friend.id, commandId: input.commandId },
+        });
+        return { ok: false, reason };
+    };
+    if (!input.options)
+        return refuse("not_enabled");
+    if (!hasPrincipalGrant(input.friend))
+        return refuse("no_grant");
+    if (input.friend.trustLevel !== "family" || input.friend.admissionState === "revoked")
+        return refuse("not_family");
+    const registry = input.registry;
+    if (!registry)
+        return refuse("principal_unresolved");
+    const principal = await resolvePrincipal(input.store, input.options.principalProfileId);
+    if (!principal || principal.id === input.friend.id)
+        return refuse("principal_unresolved");
+    const noticeId = `delegated:${input.commandId}`;
+    try {
+        await input.options.notifyPrincipal({ noticeId, text: delegatedCommandNotice({ delegateName: input.friend.name, text: input.text }) });
+    }
+    catch {
+        return refuse("notice_failed");
+    }
+    // Owner-gated tools (steward policy) bind the mutation to `requestId` on the tool
+    // context's relationship, as the Telegram owner turn does; the evaluator alone
+    // only scopes its receipts by it, so carry it on the relationship itself.
+    const relationship = {
+        ...(0, relationship_authorization_1.createRelationshipAuthorizationEvaluator)({
+            friend: principal,
+            registry,
+            requestId: input.commandId,
+            requestPhase: "inbound",
+            sessionEventId: `a2a-delegated:${input.commandId}`,
+        }),
+        requestId: input.commandId,
+    };
+    const context = {
+        principalFriendId: principal.id,
+        principalName: principal.name,
+        delegateFriendId: input.friend.id,
+        delegateName: input.friend.name,
+        delegateDid: input.did,
+        commandId: input.commandId,
+        noticeId,
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.a2a_delegated_command_admitted",
+        message: "admitted a delegated A2A command after notifying the principal",
+        meta: { delegateFriendId: context.delegateFriendId, principalFriendId: context.principalFriendId, commandId: context.commandId },
+    });
+    const turnText = `[delegated command from ${principal.name} via ${input.friend.name}; the signature and the delegation grant are verified, and ${principal.name} has been notified; act on it as ${principal.name}'s own request]\n\n${input.text}`;
+    return { ok: true, relationship, context, turnText };
+}

package/dist/a2a/delegation-stores.js

@@ -0,0 +1,56 @@
+"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.delegationStoresFor = delegationStoresFor;
+const path = __importStar(require("node:path"));
+const friends_1 = require("@ouro.bot/friends");
+const runtime_1 = require("../nerves/runtime");
+function delegationStoresFor(agentRoot) {
+    const friendsDir = path.join(agentRoot, "friends");
+    const missionsDir = (0, friends_1.missionsDirFor)(friendsDir);
+    const grantsDir = (0, friends_1.grantsDirFor)(friendsDir);
+    (0, runtime_1.emitNervesEvent)({
+        component: "channels",
+        event: "channel.a2a_delegation_stores_init",
+        message: "initialized A2A delegation stores (mission + grant)",
+        meta: { missionsDir, grantsDir },
+    });
+    return {
+        missionStore: new friends_1.FileMissionStore(missionsDir),
+        grantStore: new friends_1.FileGrantStore(grantsDir),
+        missionsDir,
+        grantsDir,
+    };
+}

package/dist/a2a/did-resolution.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDidResolution = makeDidResolution;
+const a2a_client_1 = require("@ouro.bot/friends/a2a-client");
+const runtime_1 = require("../nerves/runtime");
+/**
+ * Build the friends `DidResolution` for did:key peers. `resolveAndPin` is the
+ * verify-and-pin core the inbound bridge consumes:
+ *   parse the did:key → derive the presented Ed25519 key →
+ *     first contact (no pin under `fromAgentId`) → TOFU `pinOnFirstContact`
+ *     already pinned → `evaluateRotation` against the pin:
+ *       unchanged  → pin-hit, return the pinned key
+ *       accepted   → (re-pinned by evaluateRotation) return the NEW key
+ *       rejected   → loud security event, return null
+ *
+ * The pin is keyed by the STABLE `fromAgentId` (NOT the did:key string), so a
+ * rotation is "same `fromAgentId`, new (did, key)". An unparseable or empty DID is
+ * refused (null) and never matchable. The crypto is the friends primitives' — this
+ * only sequences them.
+ */
+function makeDidResolution(input) {
+    const { sodium, rotationProofFor } = input;
+    return {
+        async resolveAndPin(args) {
+            const { fromAgentId, did, pinStore, trustOfSource } = args;
+            // Empty DID is never a matchable key.
+            if (!did) {
+                (0, runtime_1.emitNervesEvent)({
+                    component: "channels",
+                    event: "channel.a2a_did_resolve_refused",
+                    message: "A2A DID resolve refused (empty DID)",
+                    meta: { fromAgentId, reason: "empty_did" },
+                });
+                return null;
+            }
+            const parsed = (0, a2a_client_1.parseDidKey)(did);
+            if (!parsed) {
+                (0, runtime_1.emitNervesEvent)({
+                    component: "channels",
+                    event: "channel.a2a_did_resolve_refused",
+                    message: "A2A DID resolve refused (unparseable did:key)",
+                    meta: { fromAgentId, reason: "parse_failed" },
+                });
+                return null;
+            }
+            const pinned = pinStore.get(fromAgentId);
+            if (!pinned) {
+                // First contact (TOFU): accept + pin the (did, key) under fromAgentId.
+                (0, a2a_client_1.pinOnFirstContact)({ pinStore, fromAgentId, did, ed25519Pub: parsed.ed25519Pub });
+                (0, runtime_1.emitNervesEvent)({
+                    component: "channels",
+                    event: "channel.a2a_pin_first_contact",
+                    message: "A2A DID pinned on first contact",
+                    meta: { fromAgentId, did },
+                });
+                return { ed25519Pub: parsed.ed25519Pub };
+            }
+            // Already pinned: evaluate the presented key against the pin.
+            const rotationProof = rotationProofFor?.(fromAgentId, did, parsed.ed25519Pub);
+            const decision = (0, a2a_client_1.evaluateRotation)({
+                sodium,
+                pinStore,
+                fromAgentId,
+                trustOfSource,
+                newDid: did,
+                newEd25519Pub: parsed.ed25519Pub,
+                rotationProof,
+            });
+            if (decision.decision === "unchanged") {
+                // Same key — pin-hit. (FileA2APinStore.get already emitted a2a_pin_hit.)
+                return { ed25519Pub: parsed.ed25519Pub };
+            }
+            if (decision.decision === "accepted") {
+                // evaluateRotation already re-pinned to the new key under fromAgentId.
+                (0, runtime_1.emitNervesEvent)({
+                    component: "channels",
+                    event: "channel.a2a_rotation_accepted",
+                    message: "A2A signed key rotation accepted",
+                    meta: { fromAgentId, newDid: did, trustOfSource },
+                });
+                return { ed25519Pub: parsed.ed25519Pub };
+            }
+            // Rejected — loud security signal (carries the reason).
+            (0, runtime_1.emitNervesEvent)({
+                component: "channels",
+                event: "channel.a2a_rotation_rejected",
+                message: "A2A key rotation rejected",
+                meta: { fromAgentId, newDid: did, trustOfSource, reason: decision.reason },
+            });
+            return null;
+        },
+    };
+}

package/dist/a2a/identity.js

@@ -0,0 +1,204 @@
+"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.readStoredA2ASeed = readStoredA2ASeed;
+exports.loadOrMintA2AIdentity = loadOrMintA2AIdentity;
+exports.loadSelfA2AIdentity = loadSelfA2AIdentity;
+exports.loadOrMintA2AIdentityFile = loadOrMintA2AIdentityFile;
+const crypto = __importStar(require("node:crypto"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+const a2a_client_1 = require("@ouro.bot/friends/a2a-client");
+const runtime_1 = require("../nerves/runtime");
+const runtime_credentials_1 = require("../heart/runtime-credentials");
+const machine_identity_1 = require("../heart/machine-identity");
+/** The number of raw bytes in an Ed25519 seed. */
+const ED25519_SEED_BYTES = 32;
+/** The machine-config key path for the persisted seed: `a2a.identity.ed25519Seed`. */
+function a2aIdentityConfig(config) {
+    const a2a = config.a2a;
+    if (!a2a || typeof a2a !== "object" || Array.isArray(a2a))
+        return undefined;
+    const identity = a2a.identity;
+    if (!identity || typeof identity !== "object" || Array.isArray(identity))
+        return undefined;
+    return identity;
+}
+/** Read the stored Ed25519 seed string from a machine-config object, or undefined. */
+function readStoredA2ASeed(config) {
+    const identity = a2aIdentityConfig(config);
+    const seed = identity?.ed25519Seed;
+    return typeof seed === "string" && seed.length > 0 ? seed : undefined;
+}
+/** Decode + validate a stored seed string into 32 raw bytes. Throws on malformed. */
+function decodeSeed(seedString) {
+    let decoded;
+    try {
+        decoded = Buffer.from(seedString, "base64url");
+    }
+    catch {
+        /* v8 ignore next -- Buffer.from(base64url) does not throw on bad chars; this guards future decoders @preserve */
+        throw new Error("malformed A2A identity seed: not decodable");
+    }
+    // base64url is lenient (it silently drops invalid chars), so the length check is
+    // the real gate: a real Ed25519 seed is exactly 32 bytes.
+    if (decoded.length !== ED25519_SEED_BYTES) {
+        throw new Error(`malformed A2A identity seed: expected ${ED25519_SEED_BYTES}-byte seed, got ${decoded.length}`);
+    }
+    return new Uint8Array(decoded);
+}
+/** Mint a fresh 32-byte Ed25519 seed (Node keygen → JWK `d`, the raw seed). */
+function mintSeed() {
+    const { privateKey } = crypto.generateKeyPairSync("ed25519");
+    const jwk = privateKey.export({ format: "jwk" });
+    /* v8 ignore next -- Node always emits the `d` field for an Ed25519 private JWK; guard protects future runtimes @preserve */
+    if (typeof jwk.d !== "string")
+        throw new Error("failed to mint A2A identity seed: missing JWK d");
+    return decodeSeed(jwk.d);
+}
+/** Derive the full did:key identity from a 32-byte seed (deterministic). */
+function deriveIdentity(sodium, seed) {
+    const keypair = sodium.crypto_sign_seed_keypair(seed);
+    const didIdentity = (0, a2a_client_1.didKeyIdentityFromEd25519)({
+        sodium,
+        ed25519Pub: keypair.publicKey,
+        ed25519Priv: keypair.privateKey,
+    });
+    return { ...didIdentity, seed: Buffer.from(seed).toString("base64url") };
+}
+/**
+ * Load the agent's A2A identity from the machine-local config, or mint + persist
+ * one on first use. A malformed stored seed FAILS FAST (it never silently
+ * re-mints, which would change the agent's DID). The mint path persists the new
+ * seed via `upsert` before deriving; the load path performs no writes.
+ */
+async function loadOrMintA2AIdentity(input) {
+    const stored = readStoredA2ASeed(input.config);
+    if (stored) {
+        // Load path: a malformed seed throws (no re-mint).
+        const seed = decodeSeed(stored);
+        const identity = deriveIdentity(input.sodium, seed);
+        (0, runtime_1.emitNervesEvent)({
+            component: "channels",
+            event: "channel.a2a_identity_loaded",
+            message: "loaded A2A identity from machine config",
+            meta: { agentName: input.agentName, did: identity.did },
+        });
+        return identity;
+    }
+    // Mint path: generate a seed, persist it under a2a.identity.*, then derive.
+    const seed = mintSeed();
+    const seedString = Buffer.from(seed).toString("base64url");
+    const a2a = (input.config.a2a && typeof input.config.a2a === "object" && !Array.isArray(input.config.a2a)
+        ? input.config.a2a
+        : {});
+    const identityBlock = (a2a.identity && typeof a2a.identity === "object" && !Array.isArray(a2a.identity)
+        ? a2a.identity
+        : {});
+    const nextConfig = {
+        ...input.config,
+        a2a: { ...a2a, identity: { ...identityBlock, ed25519Seed: seedString } },
+    };
+    await input.upsert(nextConfig);
+    const identity = deriveIdentity(input.sodium, seed);
+    (0, runtime_1.emitNervesEvent)({
+        component: "channels",
+        event: "channel.a2a_identity_minted",
+        message: "minted new A2A identity and persisted seed to machine config",
+        meta: { agentName: input.agentName, did: identity.did },
+    });
+    return identity;
+}
+/**
+ * Load (or mint-on-first-use) THIS agent's own A2A identity from the machine-local
+ * runtime config — the convenience entry the main-process tools use to obtain the
+ * self identity that signs outbound sealed envelopes. Mirrors the a2a sense
+ * entrypoint's load (use a cached seed when present, otherwise refresh machine
+ * config → `loadOrMintA2AIdentity` → merge a fresh seed under the right machine
+ * id). `sodium` is optional (defaults to `ready()`).
+ */
+async function loadSelfA2AIdentity(input) {
+    const sodium = input.sodium ?? await (0, a2a_client_1.ready)();
+    const machineId = (0, machine_identity_1.loadOrCreateMachineIdentity)({ homeDir: os.homedir() }).machineId;
+    const cached = (0, runtime_credentials_1.readMachineRuntimeCredentialConfig)(input.agentName);
+    const read = cached.ok && readStoredA2ASeed(cached.config)
+        ? cached
+        : await (0, runtime_credentials_1.refreshMachineRuntimeCredentialConfig)(input.agentName, machineId);
+    if (!read.ok && read.reason !== "missing") {
+        throw new Error(`A2A identity requires readable machine runtime config at ${read.itemPath}: ${read.error}`);
+    }
+    const config = read.ok ? read.config : {};
+    return loadOrMintA2AIdentity({
+        agentName: input.agentName,
+        sodium,
+        config,
+        upsert: async (next) => {
+            const seed = readStoredA2ASeed(next);
+            await (0, runtime_credentials_1.mergeMachineRuntimeCredentialConfig)(input.agentName, machineId, { a2a: { identity: { ed25519Seed: seed } } });
+        },
+    });
+}
+/**
+ * A file-backed A2A identity for a client that is not an ouro agent (for example a
+ * coding harness talking to an agent over A2A). The file holds the Ed25519 seed, so
+ * it is treated like an SSH private key: created 0600 inside a 0700 directory, and
+ * REFUSED if group or other can read it.
+ */
+async function loadOrMintA2AIdentityFile(input) {
+    const sodium = input.sodium ?? await (0, a2a_client_1.ready)();
+    return fs.existsSync(input.filePath) ? readA2AIdentityFile(sodium, input.filePath) : mintA2AIdentityFile(sodium, input.filePath);
+}
+function readA2AIdentityFile(sodium, filePath) {
+    const mode = fs.statSync(filePath).mode & 0o077;
+    if (mode !== 0)
+        throw new Error(`A2A identity file ${filePath} is readable by group or other; chmod 600 it`);
+    const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    if (typeof parsed.seed !== "string")
+        throw new Error(`A2A identity file ${filePath} has no seed`);
+    return deriveIdentity(sodium, decodeSeed(parsed.seed));
+}
+function mintA2AIdentityFile(sodium, filePath) {
+    const identity = deriveIdentity(sodium, mintSeed());
+    fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
+    fs.writeFileSync(filePath, `${JSON.stringify({ version: 1, did: identity.did, seed: identity.seed }, null, 2)}\n`, { mode: 0o600 });
+    (0, runtime_1.emitNervesEvent)({
+        component: "channels",
+        event: "channel.a2a_client_identity_minted",
+        message: "minted file-backed A2A client identity",
+        meta: { did: identity.did },
+    });
+    return identity;
+}

package/dist/a2a/inbound-share.js

@@ -0,0 +1,110 @@
+"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");
+/** 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. `findFriendByDid(store, verifiedDid)` — read trust off that record; an
+ *      unknown DID ⇒ `stranger` (never a default-up).
+ *   4. `receiveShare({ ..., trustOfSource })` — re-unseal (deterministic) + resolve
+ *      & pin + run `DidVerifier` (forge fails HERE) + replay-dedup + import.
+ *   5. 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;
+    // 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,
+    });
+    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 } : {}),
+            /* 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 };
+}