@ouro.bot/cli 0.1.0-alpha.88 → 0.1.0-alpha.880

package/dist/a2a/escalation-grants.js

@@ -0,0 +1,122 @@
+"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.escalationGrantsPath = escalationGrantsPath;
+exports.readEscalationGrants = readEscalationGrants;
+exports.setEscalationGrant = setEscalationGrant;
+exports.pinnedHolderDid = pinnedHolderDid;
+exports.holdsEscalation = holdsEscalation;
+exports.escalationHolders = escalationHolders;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const runtime_1 = require("../nerves/runtime");
+const trusted_files_1 = require("./trusted-files");
+function escalationGrantsPath(agentRoot) {
+    return path.join(agentRoot, "state", "a2a", "escalation-grants.json");
+}
+function validGrant(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const grant = value;
+    return Object.keys(grant).sort().join(",") === "did,grantedAt,scope,source"
+        && typeof grant.did === "string" && grant.did.startsWith("did:") && grant.did.length <= 512
+        && grant.scope === "escalation"
+        && typeof grant.grantedAt === "string" && !Number.isNaN(Date.parse(grant.grantedAt))
+        && typeof grant.source === "string" && grant.source.trim().length > 0;
+}
+/** Every well-formed grant in the file, keyed by friend id. Anything else in the file is ignored. */
+function readEscalationGrants(agentRoot) {
+    const file = escalationGrantsPath(agentRoot);
+    if (!(0, trusted_files_1.isTrustedDirectory)(path.dirname(file)))
+        return {};
+    const parsed = (0, trusted_files_1.readTrustedJson)(file);
+    const grants = parsed?.grants;
+    if (!grants || typeof grants !== "object" || Array.isArray(grants))
+        return {};
+    return Object.fromEntries(Object.entries(grants).filter((entry) => validGrant(entry[1])));
+}
+/** Run as root, the operator's grant leaves the file and its directory root-owned and closed to everyone else, even if an earlier recursive chown had handed them to the resident. */
+function ownAsRoot(target, mode) {
+    fs.chownSync(target, 0, 0);
+    fs.chmodSync(target, mode);
+}
+/** Writes or removes one grant. The previous file is kept beside it as a timestamped backup before the change. */
+function setEscalationGrant(agentRoot, friendId, change, now = new Date()) {
+    const file = escalationGrantsPath(agentRoot);
+    // Root repairs the directory first; a grants file the resident owns stays untrusted and is replaced, never blessed.
+    fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o755 });
+    if (process.geteuid?.() === 0)
+        ownAsRoot(path.dirname(file), 0o755);
+    const current = readEscalationGrants(agentRoot);
+    const had = current[friendId];
+    if (change.grant ? had?.did === change.did : had === undefined)
+        return { changed: false, backup: null };
+    let backup = null;
+    if (fs.existsSync(file)) {
+        backup = `${file}.bak-${now.toISOString().replace(/[:.]/gu, "-")}`;
+        fs.copyFileSync(file, backup);
+    }
+    const next = { ...current };
+    if (change.grant)
+        next[friendId] = { scope: "escalation", grantedAt: now.toISOString(), source: change.source, did: change.did };
+    else
+        delete next[friendId];
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, `${JSON.stringify({ schemaVersion: 1, grants: next }, null, 2)}\n`, { mode: 0o644 });
+    fs.renameSync(tmp, file);
+    if (process.geteuid?.() === 0)
+        ownAsRoot(file, 0o644);
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.a2a_escalation_grant_changed",
+        message: change.grant ? "granted escalation to an A2A peer" : "revoked an A2A peer's escalation grant",
+        meta: { friendId, granted: change.grant },
+    });
+    return { changed: true, backup };
+}
+/** The DID the operator pinned for this holder, or null when it holds no (complete) grant. */
+function pinnedHolderDid(agentRoot, friendId) {
+    return readEscalationGrants(agentRoot)[friendId]?.did ?? null;
+}
+/** True only for an active family friend that the operator listed in the grants file, with a pinned DID. */
+function holdsEscalation(agentRoot, friend) {
+    return readEscalationGrants(agentRoot)[friend.id] !== undefined
+        && friend.trustLevel === "family"
+        && friend.admissionState === "active";
+}
+async function escalationHolders(agentRoot, store) {
+    const friends = await store.listAll?.() ?? [];
+    return friends.filter((friend) => holdsEscalation(agentRoot, friend));
+}

package/dist/a2a/escalation-wiring.js

@@ -0,0 +1,60 @@
+"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.RUNNING_HARNESS_VERSION = void 0;
+exports.escalationOptionsFor = escalationOptionsFor;
+exports.sendOwnerNoticeViaTelegram = sendOwnerNoticeViaTelegram;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const runtime_1 = require("../nerves/runtime");
+/**
+ * The version of the harness that is running, read from its own package.json once when this module loads. A fix is
+ * "live" only when this process carries it, so the value must not follow whatever an upgrade later writes to disk.
+ */
+exports.RUNNING_HARNESS_VERSION = JSON.parse(fs.readFileSync(path.resolve(__dirname, "../../package.json"), "utf8")).version;
+/**
+ * What every A2A server entry point passes as `escalation`: confirm-when-live notices go to the owner through the same
+ * owner-notice path as delegated commands. Only the Butler files and confirms failure reports.
+ */
+function escalationOptionsFor(agentName, sendOwnerNotice) {
+    if (agentName !== "sanctuary")
+        return {};
+    (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.a2a_escalation_wired", message: "A2A server will confirm resolved failure reports to the owner", meta: { agentName, runningVersion: exports.RUNNING_HARNESS_VERSION } });
+    return { escalation: { runningVersion: exports.RUNNING_HARNESS_VERSION, notifyOwner: sendOwnerNotice } };
+}
+async function sendOwnerNoticeViaTelegram(agentName, notice) {
+    const { sendTelegramOwnerNotice } = await Promise.resolve().then(() => __importStar(require("../senses/telegram")));
+    await sendTelegramOwnerNotice(agentName, { ...notice, signal: AbortSignal.timeout(30_000) });
+}

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 };
+}