@ouro.bot/cli 0.1.0-alpha.876 → 0.1.0-alpha.878

package/dist/a2a/server.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ESCALATION_CONFIRM_INTERVAL_MS = void 0;
 exports.a2aChatRelationship = a2aChatRelationship;
 exports.startA2AServer = startA2AServer;
 const http = __importStar(require("node:http"));
@@ -55,8 +56,11 @@ const mission_result_wire_1 = require("./mission-result-wire");
 const delegation_stores_1 = require("./delegation-stores");
 const task_store_1 = require("./task-store");
 const delegated_command_1 = require("./delegated-command");
+const outbox_wire_1 = require("./outbox-wire");
+const failure_reports_1 = require("../heart/failure-reports");
 const MAX_A2A_REQUEST_BYTES = 128 * 1024;
 const MAX_A2A_MESSAGE_TEXT_CHARS = 16_000;
+exports.ESCALATION_CONFIRM_INTERVAL_MS = 5 * 60 * 1000;
 class A2ARequestError extends Error {
     status;
     code;
@@ -394,6 +398,19 @@ async function startA2AServer(options) {
             identity: options.identity,
         };
     }
+    // Resolved failure reports are confirmed to the owner once the running version reaches the fix: now, after each
+    // resolution, and on a timer, so a fix that lands with a restart is announced without anyone calling again.
+    const confirmReports = async () => {
+        if (!options.escalation)
+            return;
+        try {
+            await (0, failure_reports_1.confirmResolvedReports)(agentRoot, { ...options.escalation, ...(inboundShareDeps ? { friends: inboundShareDeps.store } : {}) });
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({ level: "warn", component: "channels", event: "channel.a2a_escalation_confirm_error", message: "confirming resolved failure reports failed", meta: { agentName: options.agentName, error: error instanceof Error ? error.message : String(error) } });
+        }
+    };
+    let confirmTimer;
     let publicBaseUrl = options.baseUrl;
     const server = http.createServer(async (req, res) => {
         /* v8 ignore next -- Node always supplies url/host for accepted HTTP requests; fallback keeps malformed local calls safe @preserve */
@@ -427,6 +444,48 @@ async function startA2AServer(options) {
             return;
         }
         try {
+            if ((0, outbox_wire_1.isOutboxMethod)(rpc.method)) {
+                // Peer outbox methods: signed and sealed like a chat, access decided here from the verified friend record.
+                const outboxInbound = messageFromParams(rpc.params);
+                if (!outboxInbound || !inboundShareDeps) {
+                    writeJson(res, 200, errorResponse(rpc.id, outbox_wire_1.OUTBOX_ERROR_REFUSED, "outbox calls need a signed message and an A2A identity"));
+                    return;
+                }
+                const bridged = await (0, inbound_share_1.receiveInboundShare)({ ...outboxInbound, kind: outboxInbound.kind ?? "message" }, inboundShareDeps);
+                if (bridged.outcome === "rejected") {
+                    writeJson(res, 200, errorResponse(rpc.id, rejectionErrorCode(bridged.reason), `A2A outbox call rejected: ${bridged.reason}`));
+                    return;
+                }
+                if (bridged.outcome !== "completed" || !bridged.message) {
+                    writeJson(res, 200, errorResponse(rpc.id, outbox_wire_1.OUTBOX_ERROR_REFUSED, "outbox calls must be a signed chat message"));
+                    return;
+                }
+                const command = (0, outbox_wire_1.parseOutboxCommand)(bridged.message.text);
+                if (!command || command.method !== rpc.method) {
+                    writeJson(res, 200, errorResponse(rpc.id, outbox_wire_1.OUTBOX_ERROR_INVALID, "the signed method does not match the requested method"));
+                    return;
+                }
+                const outcome = await (0, outbox_wire_1.handleOutboxCommand)({ agentRoot, friend: bridged.friend, method: command.method, params: command.params, verifiedDid: bridged.verifiedDid });
+                if (!outcome.ok) {
+                    writeJson(res, 200, errorResponse(rpc.id, outcome.code, outcome.message));
+                    return;
+                }
+                if (command.method === "report/resolve")
+                    await confirmReports();
+                /* v8 ignore next -- receiveShare pins the verified sender before it reports a completed message @preserve */
+                const outboxPinned = inboundShareDeps.pinStore.get(bridged.verifiedDid);
+                const contextId = outboxInbound.contextId ?? "default";
+                const reply = (0, sealed_chat_1.sealChatMessage)({
+                    sodium: inboundShareDeps.sodium,
+                    from: options.identity,
+                    recipientDid: bridged.verifiedDid,
+                    recipientEd25519Pub: outboxPinned.ed25519Pub,
+                    text: JSON.stringify(outcome.result),
+                    conversationId: contextId,
+                });
+                writeJson(res, 200, jsonResponse(rpc.id, { kind: "message", role: "ROLE_AGENT", messageId: (0, node_crypto_1.randomUUID)(), contextId, parts: reply.parts }));
+                return;
+            }
             if (rpc.method === "SendMessage" || rpc.method === "message/send") {
                 const responseStyle = rpc.method === "message/send" ? "legacy" : "latest";
                 const parsedInbound = messageFromParams(rpc.params);
@@ -671,6 +730,11 @@ async function startA2AServer(options) {
     endpointUrl.pathname = a2aPath;
     endpointUrl.search = "";
     endpointUrl.hash = "";
+    if (options.escalation) {
+        await confirmReports();
+        confirmTimer = setInterval(() => { void confirmReports(); }, options.escalation.confirmIntervalMs ?? exports.ESCALATION_CONFIRM_INTERVAL_MS);
+        confirmTimer.unref();
+    }
     (0, runtime_1.emitNervesEvent)({
         component: "channels",
         event: "channel.a2a_server_started",
@@ -682,6 +746,8 @@ async function startA2AServer(options) {
         url: publicBaseUrl,
         endpointUrl: endpointUrl.toString(),
         close: () => new Promise((resolve, reject) => {
+            if (confirmTimer)
+                clearInterval(confirmTimer);
             server.close((error) => {
                 if (error) {
                     reject(error);

package/dist/a2a/trusted-files.js

@@ -0,0 +1,98 @@
+"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.TRUSTED_UID = void 0;
+exports.overrideTrustedUidForTests = overrideTrustedUidForTests;
+exports.isTrustedDirectory = isTrustedDirectory;
+exports.readTrustedJson = readTrustedJson;
+const fs = __importStar(require("node:fs"));
+const runtime_1 = require("../nerves/runtime");
+/**
+ * Operator-set state lives in the agent bundle, which the agent's own process (and anything a prompt-injected model can
+ * run through its shell) can write. Such state only counts when root owns it and nobody else can write it, the same
+ * rule the replay window follows. Anything else reads as "not there", so every consumer fails closed.
+ */
+exports.TRUSTED_UID = 0;
+let uidOverride;
+/** Only a test runner sets VITEST; the running Butler (and its prompt-injected shell) cannot reach this process's environment. */
+const underTestRunner = () => process.env.VITEST !== undefined;
+/** Tests run as an ordinary user, so they declare that user trusted. Refused outside a test runner, and ignored there too. */
+function overrideTrustedUidForTests(uid) {
+    if (!underTestRunner())
+        throw new Error("overrideTrustedUidForTests is for tests only");
+    uidOverride = uid;
+}
+const effectiveTrustedUid = () => (underTestRunner() ? uidOverride : undefined) ?? exports.TRUSTED_UID;
+/** A real directory (no symlink), owned by the trusted uid, writable by neither group nor other. */
+function isTrustedDirectory(target, trustedUid = effectiveTrustedUid()) {
+    let stat;
+    try {
+        stat = fs.lstatSync(target);
+    }
+    catch {
+        return false;
+    }
+    const trusted = stat.isDirectory() && !stat.isSymbolicLink() && stat.uid === trustedUid && (stat.mode & 0o022) === 0;
+    if (!trusted)
+        rejected(target, "directory is not a real directory owned by the trusted uid and closed to group and other writes");
+    return trusted;
+}
+function rejected(target, reason) {
+    (0, runtime_1.emitNervesEvent)({ level: "warn", component: "senses", event: "senses.a2a_trusted_file_rejected", message: "ignored operator-set state the agent could have written", meta: { target, reason } });
+}
+/**
+ * Parses a JSON file only if the file actually opened is trusted. The path is opened once with O_NOFOLLOW, then the
+ * descriptor itself is checked (regular file, trusted owner, not group- or other-writable) and read, so a rename loop
+ * cannot swap a different file in between the check and the read. Any error is `undefined`.
+ */
+function readTrustedJson(file, trustedUid = effectiveTrustedUid()) {
+    let fd;
+    try {
+        fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+        const stat = fs.fstatSync(fd);
+        if (!stat.isFile() || stat.uid !== trustedUid || (stat.mode & 0o022) !== 0) {
+            rejected(file, "file is not a regular file owned by the trusted uid and closed to group and other writes");
+            return undefined;
+        }
+        return JSON.parse(fs.readFileSync(fd, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        if (fd !== undefined)
+            fs.closeSync(fd);
+    }
+}

package/dist/heart/awaiting/a2a-await-delivery.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PEER_ASKED_OWNER_TEXT = void 0;
 exports.askedOwnerText = askedOwnerText;
 exports.createA2AAwaitOwnerDeliverer = createA2AAwaitOwnerDeliverer;
 exports.defaultNotifyOwner = defaultNotifyOwner;
@@ -40,14 +41,22 @@ const path = __importStar(require("path"));
 const friends_1 = require("@ouro.bot/friends");
 const identity_1 = require("../identity");
 const replay_harness_1 = require("../../a2a/replay-harness");
+const outbox_store_1 = require("../../a2a/outbox-store");
 const runtime_1 = require("../../nerves/runtime");
 /**
  * An A2A peer is a client that calls this agent's server; there is no channel back to it. When an await filed from
  * an A2A conversation resolves or expires, the outcome goes to the agent's owner in the owner's own Telegram chat,
  * written by the agent as itself (an owner notice, the same path that announces delegated commands). Nothing is
  * sent as the owner or to the peer, and the notice id is the await's delivery id, so a retry cannot double-send.
+ *
+ * An await filed in a plain A2A conversation (no request id) was not delegated by the owner, so the owner hears nothing
+ * and the outcome goes to the peer instead: into its own outbox, which it reads with `outbox/list`. A question that needs
+ * the owner's decision is the exception, because only the owner can answer it: the peer is told, in one fixed
+ * sentence that never repeats the question, that the owner was asked, and the owner is asked as before.
  */
 const NOTICE_ID_MAX_BYTES = 512;
+/** The owner's question can carry anything the Butler read or wrote, so a plain peer is told only that the owner was asked. */
+exports.PEER_ASKED_OWNER_TEXT = "I've asked my owner and will let you know.";
 /** A question for the owner reads as the owner's own question, with a pointer to the request it is about; every other outcome is a follow-up report. */
 function askedOwnerText(question, about) {
     return `${question}\n\n(about the request from ${about})`;
@@ -64,6 +73,15 @@ function createA2AAwaitOwnerDeliverer(agentName, notifyOwner = defaultNotifyOwne
             const peer = await new friends_1.FileFriendStore(path.join((0, identity_1.getAgentRoot)(agentName), "friends")).get(request.friendId);
             const agentRoot = (0, identity_1.getAgentRoot)(agentName);
             const from = peer?.name ?? "a connected agent";
+            const peerAwait = !request.requestId;
+            if (peerAwait) {
+                const body = request.noticeKind === "asked_owner"
+                    ? exports.PEER_ASKED_OWNER_TEXT
+                    : request.content;
+                await new outbox_store_1.FileOutboxStore(agentRoot).appendOnce(request.friendId, request.deliveryId, { kind: "await_outcome", body, meta: { outcome: request.noticeKind ?? "follow_up" } });
+                if (request.noticeKind !== "asked_owner")
+                    return { status: "delivered_now", detail: "posted to the peer's outbox" };
+            }
             if ((0, replay_harness_1.isReplayWindowOpen)(agentRoot, request.friendId)) {
                 (0, replay_harness_1.appendReplayNotice)(agentRoot, { noticeId: request.deliveryId, text: request.noticeKind === "asked_owner" ? ownerNoticeText(request, from) : request.content, friendId: request.friendId });
                 return { status: "delivered_now", detail: "written to the replay sink (replay window open for this peer)" };

package/dist/heart/daemon/cli-exec.js

@@ -525,6 +525,7 @@ function agentResolutionFailureMode(command) {
         case "a2a.card":
         case "a2a.onboard":
         case "a2a.serve":
+        case "a2a.escalation":
             return "throw";
         case "provider.use":
         case "provider.check":
@@ -6098,6 +6099,26 @@ async function executeA2AClientCommand(command, deps) {
         deps.writeStdout(message);
         return message;
     }
+    if (command.kind === "a2a.outbox") {
+        const { callOutboxMethod } = await Promise.resolve().then(() => __importStar(require("../../a2a/outbox-client")));
+        const call = command.action === "list" ? { method: "outbox/list", params: { ...(command.since ? { since: command.since } : {}) } }
+            : command.action === "ack" ? { method: "outbox/ack", params: { ids: command.ids } }
+                : await (async () => {
+                    // The resolution is signed with this machine's key: the Butler tells its owner "fixed" only for a holder's signature.
+                    const { signResolution } = await Promise.resolve().then(() => __importStar(require("../../a2a/resolution-proof")));
+                    const { ready } = await Promise.resolve().then(() => __importStar(require("@ouro.bot/friends/a2a-client")));
+                    const claim = { reportId: command.reportId, version: command.version, note: command.note, resolvedAt: new Date().toISOString() };
+                    return { method: "report/resolve", params: { id: claim.reportId, version: claim.version, note: claim.note, resolvedAt: claim.resolvedAt, proof: signResolution({ sodium: await ready(), identity, claim }) } };
+                })();
+        const result = await callOutboxMethod({
+            cardUrl: command.to, ...call, identity,
+            /* v8 ignore next -- production CLI uses global fetch; tests inject fetch for a hermetic peer @preserve */
+            ...(deps.fetchImpl ? { fetchImpl: deps.fetchImpl } : {}),
+        });
+        const message = command.json ? JSON.stringify(result) : JSON.stringify(result, null, 2);
+        deps.writeStdout(message);
+        return message;
+    }
     const { sendSealedA2AChat } = await Promise.resolve().then(() => __importStar(require("../../a2a/client")));
     const reply = await sendSealedA2AChat({
         cardUrl: command.to,
@@ -6132,6 +6153,37 @@ async function executeA2ACommand(command, deps) {
         deps.writeStdout(message);
         return message;
     }
+    if (command.kind === "a2a.escalation") {
+        const { readEscalationGrants, setEscalationGrant } = await Promise.resolve().then(() => __importStar(require("../../a2a/escalation-grants")));
+        /* v8 ignore next -- production default bundles root; tests inject bundlesRoot @preserve */
+        const agentRoot = path.join(deps.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)(), `${command.agent}.ouro`);
+        if (command.action === "list") {
+            const grants = Object.entries(readEscalationGrants(agentRoot));
+            const message = grants.length === 0 ? "no escalation grants" : grants.map(([id, grant]) => `${id}  granted ${grant.grantedAt}  ${grant.did}  ${grant.source}`).join("\n");
+            deps.writeStdout(message);
+            return message;
+        }
+        const friend = await new friends_1.FileFriendStore(path.join(agentRoot, "friends")).get(command.friendId);
+        if (!friend)
+            throw new Error(`friend not found: ${command.friendId}`);
+        const at = new Date(deps.now?.() ?? Date.now());
+        const { friendDid } = await Promise.resolve().then(() => __importStar(require("../../a2a/resolution-proof")));
+        const holderDid = command.action === "grant" ? friendDid(friend) : null;
+        if (command.action === "grant" && !holderDid)
+            throw new Error(`${friend.name} has no pinned DID yet; onboard it with a DID before granting escalation`);
+        const change = command.action === "grant"
+            ? setEscalationGrant(agentRoot, friend.id, { grant: true, source: command.source ?? `ouro a2a escalation grant, ${at.toISOString()}`, did: holderDid }, at)
+            : setEscalationGrant(agentRoot, friend.id, { grant: false }, at);
+        const message = [
+            `${command.action === "grant" ? "granted" : "revoked"} escalation: ${friend.name} (${friend.id})${change.changed ? "" : " (no change)"}`,
+            ...(holderDid ? [`pinned DID: ${holderDid} (compare it with the holder's real DID)`] : []),
+            ...(change.backup ? [`backup: ${change.backup}`] : []),
+            ...(command.action === "grant" && readEscalationGrants(agentRoot)[friend.id] === undefined ? [`WARNING: the grant is written but will not be honoured: ${path.join(agentRoot, "state", "a2a")} and escalation-grants.json must be owned by root and writable by no one else. Run this command as root (docker exec as root) or chown root:root and chmod 755/644 them.`] : []),
+            ...(command.action === "grant" && (friend.trustLevel !== "family" || friend.admissionState !== "active") ? [`note: ${friend.name} only holds the grant while it is active family (now ${friend.trustLevel}, ${friend.admissionState})`] : []),
+        ].join("\n");
+        deps.writeStdout(message);
+        return message;
+    }
     /* v8 ignore next -- false branch is foreground serve, intentionally ignored below because it waits for signals @preserve */
     if (command.kind === "a2a.onboard") {
         if (command.did) {
@@ -6179,8 +6231,10 @@ async function executeA2ACommand(command, deps) {
     }
     /* v8 ignore start -- foreground serve intentionally waits for process signals; a2a/server has route-level coverage @preserve */
     const { startA2AServer } = await Promise.resolve().then(() => __importStar(require("../../a2a/server")));
+    const { escalationOptionsFor, sendOwnerNoticeViaTelegram } = await Promise.resolve().then(() => __importStar(require("../../a2a/escalation-wiring")));
     const handle = await startA2AServer({
         agentName: command.agent,
+        ...escalationOptionsFor(command.agent, (notice) => sendOwnerNoticeViaTelegram(command.agent, notice)),
         ...(command.host ? { host: command.host } : {}),
         ...(command.port ? { port: command.port } : {}),
         ...(command.baseUrl ? { baseUrl: command.baseUrl } : {}),
@@ -7204,7 +7258,7 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
         return message;
     }
     // ── a2a client commands (this machine talks to an agent as a verified friend; no agent, no daemon) ──
-    if (command.kind === "a2a.identity" || command.kind === "a2a.message") {
+    if (command.kind === "a2a.identity" || command.kind === "a2a.message" || command.kind === "a2a.outbox") {
         return executeA2AClientCommand(command, deps);
     }
     // ── versions command (local install list + published update truth, no daemon socket needed) ──
@@ -7908,7 +7962,7 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
         deps.writeStdout(message);
         return message;
     }
-    if (command.kind === "a2a.card" || command.kind === "a2a.onboard" || command.kind === "a2a.serve") {
+    if (command.kind === "a2a.card" || command.kind === "a2a.onboard" || command.kind === "a2a.serve" || command.kind === "a2a.escalation") {
         return executeA2ACommand(command, deps);
     }
     // ── provider commands (local, no daemon socket needed) ──

package/dist/heart/daemon/cli-parse.js

@@ -154,6 +154,11 @@ function usage() {
         "  ouro a2a serve [--agent <name>] [--host <host>] [--port <port>] [--base-url <url>] [--path <path>]",
         "  ouro a2a identity [--identity-file <path>] [--json]",
         "  ouro a2a message --to <card-url> --text <text> [--context <id>] [--delegated] [--identity-file <path>] [--json]",
+        "  ouro a2a outbox list --to <card-url> [--since <cursor>] [--identity-file <path>] [--json]",
+        "  ouro a2a outbox ack --to <card-url> --ids <id,id,...> [--identity-file <path>] [--json]",
+        "  ouro a2a outbox resolve --to <card-url> --report <id> --version <version> --note <text> [--identity-file <path>] [--json]",
+        "  ouro a2a escalation <grant|revoke> --friend <id> [--source <text>] [--agent <name>]",
+        "  ouro a2a escalation list [--agent <name>]",
         "  ouro whoami [--agent <name>]",
         "  ouro session list [--agent <name>]",
         "  ouro mcp list",
@@ -1550,6 +1555,65 @@ function parseA2ACommand(args) {
             throw new Error(usageText);
         return { kind: "a2a.message", to, text, ...(conversationId ? { conversationId } : {}), ...(delegated ? { delegated: true } : {}), ...(identityFile ? { identityFile } : {}), ...(json ? { json: true } : {}) };
     }
+    if (sub === "outbox") {
+        const usageText = "Usage: ouro a2a outbox <list|ack|resolve> --to <card-url> [--since <cursor>] [--ids <id,id,...>] [--report <id> --version <version> --note <text>] [--identity-file <path>] [--json]";
+        const action = rest[0];
+        if (action !== "list" && action !== "ack" && action !== "resolve")
+            throw new Error(usageText);
+        const values = {};
+        let json = false;
+        for (let i = 1; i < rest.length; i += 1) {
+            if (rest[i] === "--json") {
+                json = true;
+                continue;
+            }
+            const flag = rest[i];
+            if (["--to", "--since", "--ids", "--report", "--version", "--note", "--identity-file"].includes(flag) && rest[i + 1]) {
+                values[flag] = rest[++i];
+                continue;
+            }
+            throw new Error(usageText);
+        }
+        const allowed = { list: ["--to", "--since", "--identity-file"], ack: ["--to", "--ids", "--identity-file"], resolve: ["--to", "--report", "--version", "--note", "--identity-file"] };
+        const required = { list: ["--to"], ack: ["--to", "--ids"], resolve: ["--to", "--report", "--version", "--note"] };
+        if (Object.keys(values).some((flag) => !allowed[action].includes(flag)) || required[action].some((flag) => !values[flag]))
+            throw new Error(usageText);
+        const ids = values["--ids"]?.split(",").map((id) => id.trim()).filter(Boolean);
+        if (action === "ack" && (!ids || ids.length === 0))
+            throw new Error(usageText);
+        return {
+            kind: "a2a.outbox", action, to: values["--to"],
+            ...(values["--since"] ? { since: values["--since"] } : {}),
+            ...(action === "ack" ? { ids: ids } : {}),
+            ...(values["--report"] ? { reportId: values["--report"] } : {}),
+            ...(values["--version"] ? { version: values["--version"] } : {}),
+            ...(values["--note"] ? { note: values["--note"] } : {}),
+            ...(values["--identity-file"] ? { identityFile: values["--identity-file"] } : {}),
+            ...(json ? { json: true } : {}),
+        };
+    }
+    if (sub === "escalation") {
+        const usageText = "Usage: ouro a2a escalation <grant|revoke> --friend <id> [--source <text>] [--agent <name>] | ouro a2a escalation list [--agent <name>]";
+        const action = rest[0];
+        if (action !== "grant" && action !== "revoke" && action !== "list")
+            throw new Error(usageText);
+        let friendId;
+        let source;
+        for (let i = 1; i < rest.length; i += 1) {
+            if (rest[i] === "--friend" && rest[i + 1]) {
+                friendId = rest[++i];
+                continue;
+            }
+            if (rest[i] === "--source" && rest[i + 1]) {
+                source = rest[++i];
+                continue;
+            }
+            throw new Error(usageText);
+        }
+        if ((action === "list") === Boolean(friendId) || (source && action !== "grant"))
+            throw new Error(usageText);
+        return { kind: "a2a.escalation", action, ...(agent ? { agent } : {}), ...(friendId ? { friendId } : {}), ...(source ? { source } : {}) };
+    }
     if (sub === "onboard") {
         let cardUrl;
         let did;
@@ -1612,7 +1676,7 @@ function parseA2ACommand(args) {
         }
         return { kind: "a2a.serve", ...(agent ? { agent } : {}), ...(host ? { host } : {}), ...(port ? { port } : {}), ...(baseUrl ? { baseUrl } : {}), ...(path ? { path } : {}) };
     }
-    throw new Error("Usage: ouro a2a card|onboard|serve ...");
+    throw new Error("Usage: ouro a2a card|onboard|serve|message|identity|outbox|escalation ...");
 }
 function parseConfigCommand(args) {
     const { agent, rest: afterAgent } = extractAgentFlag(args);

package/dist/heart/daemon/sanctuary-acceptance-harness.js

@@ -60,7 +60,7 @@ function exactSanctuaryContainmentProfileBoundaries(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return false;
     const boundaries = value;
-    const versions = { "sanctuary-owner": 15, "sanctuary-household": 5, "sanctuary-event": 4 };
+    const versions = { "sanctuary-owner": 16, "sanctuary-household": 5, "sanctuary-event": 4 };
     if (!(0, node_util_1.isDeepStrictEqual)(Object.keys(boundaries).sort(), Object.keys(versions).sort()))
         return false;
     const packageRoot = path.resolve(__dirname, "../../../deploy/unraid/sanctuary.ouro");