@ouro.bot/cli 0.1.0-alpha.877 → 0.1.0-alpha.879

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");

package/dist/heart/daemon/sanctuary-authority-root-lifecycle.js

@@ -986,6 +986,7 @@ class SanctuaryAuthorityRootLifecycle {
         });
         (0, node_child_process_1.execFileSync)("/bin/chown", ["-R", "10001:10001", this.#p(BUNDLE)], { stdio: "ignore" });
         this.#restoreReplayRoot();
+        this.#restoreEscalationGrantRoot();
     }
     /**
      * The recursive restore above hands the whole bundle to the resident, including state/replay. That directory is the
@@ -1009,6 +1010,38 @@ class SanctuaryAuthorityRootLifecycle {
         fs.chmodSync(directory, 0o755);
         fs.rmSync(path.join(directory, "window.json"), { force: true, recursive: true });
     }
+    /**
+     * The same recursive restore hands state/a2a and the escalation grant file to the resident. The Butler honours a grant
+     * only while the file and its directory are root-owned and closed to everyone else (src/a2a/trusted-files.ts), so
+     * after every restore they go back under root, and a prompt-injected model running as the resident cannot mint one.
+     * The subdirectories the resident writes (tasks, pins, seen) are created first and stay with it, so it never needs to
+     * create anything inside the root-owned directory. Missing this is what made every report_failure and outbox case of
+     * the alpha.878 replay gate fail: no peer held the grant, so no peer was an escalation holder.
+     */
+    #restoreEscalationGrantRoot() {
+        const directory = this.#p(`${BUNDLE}/state/a2a`);
+        let stat;
+        try {
+            stat = fs.lstatSync(directory);
+        }
+        catch {
+            return;
+        }
+        if (!stat.isDirectory())
+            return;
+        for (const sub of ["tasks", "pins", "seen"]) {
+            fs.mkdirSync(path.join(directory, sub), { recursive: true });
+            (0, node_child_process_1.execFileSync)("/bin/chown", ["-R", "10001:10001", path.join(directory, sub)], { stdio: "ignore" });
+        }
+        // Ownership first, before anything else can fail: nothing the Butler left in the directory may stop it going back under root.
+        (0, node_child_process_1.execFileSync)("/bin/chown", ["-h", "0:0", directory], { stdio: "ignore" });
+        fs.chmodSync(directory, 0o755);
+        const grants = path.join(directory, "escalation-grants.json");
+        if (fs.existsSync(grants)) {
+            (0, node_child_process_1.execFileSync)("/bin/chown", ["-h", "0:0", grants], { stdio: "ignore" });
+            fs.chmodSync(grants, 0o644);
+        }
+    }
     /** Start the gateway, then the resident, and prove both. */
     async #startUpgraded() {
         this.#runtimeDirectories();

package/dist/heart/failure-reports.js

@@ -0,0 +1,335 @@
+"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.CLOSED_REPORT_RETENTION_MS = exports.REPORTS_PER_ORIGIN_DAY = exports.REPORTS_PER_ORIGIN_HOUR = exports.REPORTS_PER_DAY = exports.REPORTS_PER_HOUR = void 0;
+exports.reportsDir = reportsDir;
+exports.errorClass = errorClass;
+exports.failureFingerprint = failureFingerprint;
+exports.readFailureReport = readFailureReport;
+exports.listFailureReports = listFailureReports;
+exports.reportBody = reportBody;
+exports.pruneClosedReports = pruneClosedReports;
+exports.fileFailureReport = fileFailureReport;
+exports.resolveFailureReport = resolveFailureReport;
+exports.fixLiveNoticeText = fixLiveNoticeText;
+exports.confirmResolvedReports = confirmResolvedReports;
+const node_crypto_1 = require("node:crypto");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const semver = __importStar(require("semver"));
+const a2a_client_1 = require("@ouro.bot/friends/a2a-client");
+const escalation_grants_1 = require("../a2a/escalation-grants");
+const outbox_store_1 = require("../a2a/outbox-store");
+const resolution_proof_1 = require("../a2a/resolution-proof");
+const replay_harness_1 = require("../a2a/replay-harness");
+const runtime_1 = require("../nerves/runtime");
+const file_lock_1 = require("./file-lock");
+exports.REPORTS_PER_HOUR = 5;
+exports.REPORTS_PER_DAY = 20;
+exports.REPORTS_PER_ORIGIN_HOUR = 3;
+exports.REPORTS_PER_ORIGIN_DAY = 10;
+exports.CLOSED_REPORT_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
+const FIELD_MAX_CHARS = 2_000;
+const HOUR_MS = 60 * 60 * 1000;
+const DAY_MS = 24 * HOUR_MS;
+const REPORT_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/u;
+function reportsDir(agentRoot) {
+    return path.join(agentRoot, "state", "reports");
+}
+function reportFile(agentRoot, id) {
+    return path.join(reportsDir(agentRoot), `${id}.json`);
+}
+function cap(value) {
+    return value.trim().slice(0, FIELD_MAX_CHARS);
+}
+/** The same failure reads the same: numbers, ids and paths are blanked so a retry with a new request id folds in. */
+function errorClass(error) {
+    return error.toLowerCase()
+        .replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gu, "<id>")
+        .replace(/(?:\/[\w.@-]+){2,}/gu, "<path>")
+        .replace(/\d+/gu, "<n>")
+        .replace(/\s+/gu, " ").trim().slice(0, 80);
+}
+function failureFingerprint(failedTool, error) {
+    return (0, node_crypto_1.createHash)("sha256").update(`${(failedTool ?? "").trim().toLowerCase()}\0${errorClass(error)}`).digest("hex").slice(0, 16);
+}
+function readFailureReport(agentRoot, id) {
+    if (!REPORT_ID.test(id))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(reportFile(agentRoot, id), "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function writeReport(agentRoot, record) {
+    fs.mkdirSync(reportsDir(agentRoot), { recursive: true });
+    const file = reportFile(agentRoot, record.id);
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, `${JSON.stringify(record, null, 2)}\n`, { mode: 0o600 });
+    fs.renameSync(tmp, file);
+}
+function listFailureReports(agentRoot) {
+    let names;
+    try {
+        names = fs.readdirSync(reportsDir(agentRoot));
+    }
+    catch {
+        return [];
+    }
+    return names.filter((name) => name.endsWith(".json")).flatMap((name) => {
+        const record = readFailureReport(agentRoot, name.slice(0, -5));
+        return record ? [record] : [];
+    });
+}
+function reportBody(record) {
+    const { origin } = record;
+    return [
+        `Failure report ${record.shortId} (${record.severity})${origin.ownerOrigin ? "" : " - UNTRUSTED ORIGIN: not the owner's session"}`,
+        origin.ownerOrigin ? `Ari asked: ${record.ariWords}` : `A session with ${origin.friendName ?? "an unknown friend"} (${origin.trustLevel ?? "unknown trust"}) reported: ${record.ariWords}`,
+        `I tried: ${record.tried}`,
+        `${record.failedTool ? `${record.failedTool} failed` : "I gave up"}: ${record.error}`,
+        `Conversation: ${origin.channel ?? "unknown"}/${origin.key ?? "unknown"}`,
+        `Origin: friend ${origin.friendId ?? "unknown"}, trust ${origin.trustLevel ?? "unknown"}, owner ${origin.ownerOrigin ? "yes" : "no"}`,
+    ].join("\n");
+}
+/** The origin friend, read from the friend store: only an active family friend on the owner profile is the owner. */
+async function resolveOrigin(store, origin) {
+    const friend = origin.friendId ? await store.get(origin.friendId) : null;
+    const ownerOrigin = Boolean(friend && friend.admissionState === "active" && friend.trustLevel === "family" && friend.capabilityProfileId === "sanctuary-owner");
+    return { ...origin, friendName: friend ? friend.name : null, trustLevel: friend ? String(friend.trustLevel) : null, ownerOrigin };
+}
+/** Closed reports are history; they go after a month so the directory does not grow without bound. */
+function pruneClosedReports(agentRoot, now = Date.now()) {
+    let pruned = 0;
+    for (const record of listFailureReports(agentRoot)) {
+        if (record.status === "closed" && record.closedAt && now - Date.parse(record.closedAt) > exports.CLOSED_REPORT_RETENTION_MS) {
+            fs.rmSync(reportFile(agentRoot, record.id), { force: true });
+            pruned += 1;
+        }
+    }
+    return pruned;
+}
+function lockDir(agentRoot) {
+    return path.join(reportsDir(agentRoot), ".locks");
+}
+function overBudget(created, now, perHour, perDay) {
+    return created.filter((at) => now - at < HOUR_MS).length >= perHour || created.filter((at) => now - at < DAY_MS).length >= perDay;
+}
+async function fileFailureReport(agentRoot, store, input, now = Date.now()) {
+    const ariWords = cap(input.ariWords);
+    const tried = cap(input.tried);
+    const error = cap(input.error);
+    if (!ariWords || !tried || !error)
+        return { ok: false, reason: "invalid", detail: "ari_words, tried and error are all required" };
+    const failedTool = input.failedTool?.trim() ? input.failedTool.trim().slice(0, 120) : null;
+    const fingerprint = failureFingerprint(failedTool ?? undefined, error);
+    const origin = await resolveOrigin(store, input.origin);
+    const replay = origin.friendId !== null && (0, replay_harness_1.isReplayWindowOpen)(agentRoot, origin.friendId, now);
+    // A replay identity speaks only inside its window; once the window closes it must not reach a real outbox.
+    if (!replay && origin.friendId !== null && (0, replay_harness_1.isReplayIdentity)(agentRoot, origin.friendId))
+        return { ok: false, reason: "invalid", detail: "a replay identity can file only while its replay window is open" };
+    // One lock around read, rate check and write, so two processes cannot both pass the budget or file the same failure twice.
+    return (0, file_lock_1.withFileLock)(lockDir(agentRoot), "file", async () => {
+        pruneClosedReports(agentRoot, now);
+        const existing = listFailureReports(agentRoot);
+        // A replay conversation never folds: each gate run must leave a fresh report to read back.
+        const open = replay ? undefined : existing.find((record) => !record.replay && record.fingerprint === fingerprint && record.status !== "closed");
+        if (open) {
+            const folded = await foldRepeat(agentRoot, open.id, { error, failedTool, origin }, now);
+            if (folded)
+                return folded;
+        }
+        const holders = (await (0, escalation_grants_1.escalationHolders)(agentRoot, store)).filter((holder) => replay ? (0, replay_harness_1.isReplayWindowOpen)(agentRoot, holder.id, now) : !(0, replay_harness_1.isReplayIdentity)(agentRoot, holder.id));
+        if (holders.length === 0)
+            return { ok: false, reason: "no_escalation_peer", detail: replay ? "no replay escalation peer" : "no friend holds the escalation grant" };
+        const sameKind = existing.filter((record) => record.replay === replay);
+        if (overBudget(sameKind.map((record) => Date.parse(record.createdAt)), now, exports.REPORTS_PER_HOUR, exports.REPORTS_PER_DAY)) {
+            return { ok: false, reason: "rate_limited", detail: `at most ${exports.REPORTS_PER_HOUR} new reports an hour and ${exports.REPORTS_PER_DAY} a day` };
+        }
+        if (overBudget(sameKind.filter((record) => record.origin.friendId === origin.friendId).map((record) => Date.parse(record.createdAt)), now, exports.REPORTS_PER_ORIGIN_HOUR, exports.REPORTS_PER_ORIGIN_DAY)) {
+            return { ok: false, reason: "rate_limited", detail: `at most ${exports.REPORTS_PER_ORIGIN_HOUR} new reports an hour and ${exports.REPORTS_PER_ORIGIN_DAY} a day from one origin` };
+        }
+        const id = (0, node_crypto_1.randomUUID)();
+        const record = {
+            id, shortId: id.slice(0, 8), fingerprint, createdAt: new Date(now).toISOString(), lastSeenAt: new Date(now).toISOString(), occurrences: 1,
+            severity: input.severity, ariWords, tried, error, failedTool, origin, replay,
+            recipients: holders.map((holder) => holder.id), outboxEntries: {}, status: "open",
+        };
+        const outbox = new outbox_store_1.FileOutboxStore(agentRoot);
+        for (const holder of holders) {
+            record.outboxEntries[holder.id] = outbox.append(holder.id, {
+                kind: "failure_report",
+                body: reportBody(record),
+                meta: {
+                    reportId: id, shortId: record.shortId, severity: record.severity, failedTool, fingerprint, ariWords: record.ariWords, conversation: { channel: origin.channel, key: origin.key },
+                    origin: { friendId: origin.friendId, friendName: origin.friendName, trustLevel: origin.trustLevel, ownerOrigin: origin.ownerOrigin },
+                },
+            }, now).id;
+        }
+        writeReport(agentRoot, record);
+        (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.failure_report_filed", message: "filed a failure report", meta: { reportId: id, severity: record.severity, recipients: holders.length, replay, ownerOrigin: origin.ownerOrigin } });
+        return { ok: true, id, shortId: record.shortId, duplicate: false, recipients: holders.length };
+    });
+}
+/** Counts a repeat on the open report (re-read under the report's own lock) and tells the recipients, at most once a day per report. */
+async function foldRepeat(agentRoot, id, repeat, now) {
+    return (0, file_lock_1.withFileLock)(lockDir(agentRoot), `report-${id}`, () => {
+        const fresh = readFailureReport(agentRoot, id);
+        if (!fresh || fresh.status === "closed")
+            return null;
+        const occurrences = fresh.occurrences + 1;
+        const notify = fresh.lastRepeatNoticeAt === undefined || now - Date.parse(fresh.lastRepeatNoticeAt) >= DAY_MS;
+        if (notify) {
+            const outbox = new outbox_store_1.FileOutboxStore(agentRoot);
+            for (const recipient of fresh.recipients) {
+                outbox.append(recipient, {
+                    kind: "report_repeat",
+                    body: `Failure report ${fresh.shortId} happened again (${occurrences} times so far)${repeat.origin.ownerOrigin ? "" : " - UNTRUSTED ORIGIN: not the owner's session"}. ${repeat.failedTool ? `${repeat.failedTool} failed` : "I gave up"}: ${repeat.error}`,
+                    meta: { reportId: fresh.id, shortId: fresh.shortId, occurrences, status: fresh.status, origin: { friendId: repeat.origin.friendId, friendName: repeat.origin.friendName, trustLevel: repeat.origin.trustLevel, ownerOrigin: repeat.origin.ownerOrigin } },
+                }, now);
+            }
+        }
+        writeReport(agentRoot, { ...fresh, occurrences, lastSeenAt: new Date(now).toISOString(), ...(notify ? { lastRepeatNoticeAt: new Date(now).toISOString() } : {}) });
+        (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.failure_report_folded", message: "folded a repeat failure into an open report", meta: { reportId: fresh.id, occurrences, notified: notify } });
+        return { ok: true, id: fresh.id, shortId: fresh.shortId, duplicate: true, recipients: fresh.recipients.length };
+    });
+}
+/** Records the fix a recipient says is live from `version`; the owner is told only once the running version reaches it. */
+async function resolveFailureReport(agentRoot, input, now = Date.now()) {
+    if (!readFailureReport(agentRoot, input.id))
+        return { ok: false, reason: "unknown_report" };
+    return (0, file_lock_1.withFileLock)(lockDir(agentRoot), `report-${input.id}`, () => resolveLocked(agentRoot, input, now));
+}
+function resolveLocked(agentRoot, input, now) {
+    const record = readFailureReport(agentRoot, input.id);
+    /* v8 ignore next -- only a report pruned between the check above and taking its lock can be missing here @preserve */
+    if (!record)
+        return { ok: false, reason: "unknown_report" };
+    if (!record.recipients.includes(input.byFriendId))
+        return { ok: false, reason: "not_recipient" };
+    if (record.status === "closed")
+        return { ok: false, reason: "already_closed" };
+    const version = semver.valid(input.version);
+    if (!version || version !== input.version)
+        return { ok: false, reason: "bad_version" };
+    const note = cap(input.note);
+    if (!note)
+        return { ok: false, reason: "bad_note" };
+    writeReport(agentRoot, { ...record, status: "resolved", resolution: { version, note, by: input.byFriendId, at: new Date(now).toISOString(), resolvedAt: input.resolvedAt, signedNote: input.note, proof: input.proof } });
+    (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.failure_report_resolved", message: "an escalation peer resolved a failure report", meta: { reportId: record.id, version } });
+    return { ok: true, id: record.id, status: "resolved" };
+}
+function fixLiveNoticeText(record) {
+    const resolution = record.resolution;
+    if (!record.origin.ownerOrigin) {
+        return `The fix for something I couldn't do earlier for ${record.origin.friendName ?? "a connected friend"} (report ${record.shortId}) is live now, in version ${resolution.version}. ${resolution.note}`;
+    }
+    return `The fix for what I couldn't do for you earlier (report ${record.shortId}) is live now, in version ${resolution.version}. ${resolution.note}\n\nYou asked: ${record.ariWords}`;
+}
+// Reports are rate limited and pruned, so this set stays small.
+const warnedSkips = new Set();
+/** The owner hears "fixed" only if the escalation holder signed it and still holds escalation; a file the Butler's own uid can write proves nothing. */
+async function resolutionIsSigned(agentRoot, deps, record) {
+    const resolution = record.resolution;
+    const skip = (reason) => {
+        // The confirm tick runs every few minutes, so each report warns once per process, not once per tick.
+        const key = `${record.id}:${reason}`;
+        if (warnedSkips.has(key))
+            return false;
+        warnedSkips.add(key);
+        (0, runtime_1.emitNervesEvent)({ level: "warn", component: "senses", event: "senses.failure_report_resolution_unverified", message: "skipped a resolved report that the holder's signature does not vouch for", meta: { reportId: record.id, by: resolution.by, reason } });
+        return false;
+    };
+    // A report that was ever closed already told the owner; a resolved status on it is a forgery or a replay.
+    if (record.closedAt !== undefined)
+        return skip("report was closed before");
+    // The owner is told exactly what was signed: the stored note must be the signed note, and the version its canonical form.
+    if (typeof resolution.signedNote !== "string" || resolution.note !== cap(resolution.signedNote))
+        return skip("note is not the signed note");
+    if (semver.valid(resolution.version) !== resolution.version)
+        return skip("version is not canonical");
+    const friend = deps.friends ? await deps.friends.get(resolution.by) : null;
+    if (!friend || !(0, escalation_grants_1.holdsEscalation)(agentRoot, friend))
+        return skip("holder no longer holds escalation");
+    // The key comes from the root-owned grant. The friend record is writable by the Butler's own uid and is never consulted for it.
+    const checked = (0, resolution_proof_1.verifyResolution)({
+        sodium: await (0, a2a_client_1.ready)(),
+        claim: { reportId: record.id, version: resolution.version, note: resolution.signedNote, resolvedAt: resolution.resolvedAt ?? "" },
+        proof: resolution.proof,
+        holderDid: (0, escalation_grants_1.pinnedHolderDid)(agentRoot, resolution.by),
+    });
+    return checked.ok;
+}
+/** Tells the owner about each resolved report whose fix has reached the running version, then closes it. */
+async function confirmResolvedReports(agentRoot, deps, now = Date.now()) {
+    const result = { closed: [], waiting: [], failed: [] };
+    for (const listed of listFailureReports(agentRoot)) {
+        if (listed.status !== "resolved" || !listed.resolution)
+            continue;
+        if (!semver.valid(deps.runningVersion) || !semver.gte(deps.runningVersion, listed.resolution.version)) {
+            result.waiting.push(listed.id);
+            continue;
+        }
+        try {
+            // The report is read again under its lock: a resolution or repeat may have landed since the listing.
+            const outcome = await (0, file_lock_1.withFileLock)(lockDir(agentRoot), `report-${listed.id}`, async () => {
+                const record = readFailureReport(agentRoot, listed.id);
+                if (!record || record.status !== "resolved" || !record.resolution)
+                    return "skipped";
+                if (!semver.gte(deps.runningVersion, record.resolution.version))
+                    return "waiting";
+                if (!(await resolutionIsSigned(agentRoot, deps, record)))
+                    return "skipped";
+                if (!record.replay)
+                    await deps.notifyOwner({ noticeId: `failure-fixed:${record.id}`, text: fixLiveNoticeText(record) });
+                writeReport(agentRoot, { ...record, status: "closed", closedAt: new Date(now).toISOString() });
+                (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.failure_report_closed", message: "closed a failure report after its fix went live", meta: { reportId: record.id, version: record.resolution.version } });
+                return "closed";
+            });
+            if (outcome === "closed")
+                result.closed.push(listed.id);
+            else if (outcome === "waiting")
+                result.waiting.push(listed.id);
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({ level: "warn", component: "senses", event: "senses.failure_report_notice_failed", message: "could not tell the owner a fix is live; will retry", meta: { reportId: listed.id, error: error instanceof Error ? error.message : String(error) } });
+            result.failed.push(listed.id);
+        }
+    }
+    pruneClosedReports(agentRoot, now);
+    return result;
+}