@ouro.bot/cli 0.1.0-alpha.696 → 0.1.0-alpha.698

package/dist/rsvp/snapshot.js

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RSVP_SNAPSHOT_POLICY_VERSION = void 0;
+exports.rsvpHash = rsvpHash;
+exports.rsvpSnapshotContentHash = rsvpSnapshotContentHash;
+exports.buildRsvpSnapshot = buildRsvpSnapshot;
+exports.parseRsvpSnapshot = parseRsvpSnapshot;
+exports.serializeRsvpSnapshotMetadata = serializeRsvpSnapshotMetadata;
+const node_crypto_1 = require("node:crypto");
+const runtime_1 = require("../nerves/runtime");
+exports.RSVP_SNAPSHOT_POLICY_VERSION = "rsvp-snapshot/v1";
+function sha256Hex(input) {
+    return (0, node_crypto_1.createHash)("sha256").update(input).digest("hex");
+}
+function rsvpHash(input) {
+    return `sha256:${sha256Hex(canonicalJson(input))}`;
+}
+function canonicalJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map((entry) => canonicalJson(entry)).join(",")}]`;
+    if (value && typeof value === "object") {
+        const record = value;
+        return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+function assertIsoTimestamp(value, label) {
+    if (!Number.isFinite(Date.parse(value))) {
+        throw new Error(`${label} must be an ISO timestamp`);
+    }
+}
+function stringValue(value) {
+    return typeof value === "string" ? value : "";
+}
+function groupIdValue(value) {
+    if (typeof value === "string" || typeof value === "number")
+        return value;
+    return null;
+}
+function normalizeStatus(value) {
+    if (value === null || value === undefined)
+        return { status: "pending", sourceStatus: null };
+    const raw = String(value);
+    if (raw === "attending")
+        return { status: "attending", sourceStatus: raw };
+    if (raw === "declined")
+        return { status: "declined", sourceStatus: raw };
+    return { status: "unknown", sourceStatus: raw };
+}
+function displayName(firstName, lastName) {
+    const name = `${firstName} ${lastName}`.trim();
+    return name || "Unnamed guest";
+}
+function normalizeGuest(id, row) {
+    const firstName = stringValue(row.first_name).trim();
+    const lastName = stringValue(row.last_name).trim();
+    const normalizedStatus = normalizeStatus(row.attending_status);
+    return {
+        id,
+        firstName,
+        lastName,
+        displayName: displayName(firstName, lastName),
+        groupId: groupIdValue(row.group_id),
+        status: normalizedStatus.status,
+        sourceStatus: normalizedStatus.sourceStatus,
+    };
+}
+function summaryFor(guests) {
+    const summary = {
+        attending: 0,
+        declined: 0,
+        pending: 0,
+        unknown: 0,
+        total: guests.length,
+    };
+    for (const guest of guests) {
+        summary[guest.status] += 1;
+    }
+    return summary;
+}
+function hashBasis(snapshot) {
+    return {
+        schemaVersion: snapshot.schemaVersion,
+        policyVersion: snapshot.policyVersion,
+        agent: snapshot.agent,
+        fetchedAt: snapshot.fetchedAt,
+        source: snapshot.source,
+        provenance: snapshot.provenance,
+        guests: snapshot.guests,
+        allGuestIdsHash: snapshot.allGuestIdsHash,
+        summary: snapshot.summary,
+        privacy: snapshot.privacy,
+    };
+}
+function rsvpSnapshotContentHash(snapshot) {
+    return rsvpHash(hashBasis(snapshot));
+}
+function snapshotIdFor(contentHash) {
+    return `rsvp_${contentHash.slice("sha256:".length, "sha256:".length + 32)}`;
+}
+function allGuestIdsHash(allGuests) {
+    return rsvpHash(Object.keys(allGuests).sort());
+}
+function buildRsvpSnapshot(input) {
+    assertIsoTimestamp(input.fetchedAt, "fetchedAt");
+    if (input.provenance.kind === "legacy-import")
+        assertIsoTimestamp(input.provenance.importedAt, "importedAt");
+    const guests = Object.entries(input.guests)
+        .map(([id, row]) => normalizeGuest(id, row))
+        .sort((left, right) => left.id.localeCompare(right.id));
+    const base = {
+        schemaVersion: 1,
+        policyVersion: exports.RSVP_SNAPSHOT_POLICY_VERSION,
+        agent: input.agent,
+        fetchedAt: input.fetchedAt,
+        source: input.source,
+        provenance: input.provenance,
+        guests,
+        allGuestIdsHash: allGuestIdsHash(input.allGuests),
+        summary: summaryFor(guests),
+        privacy: {
+            rawCredentialsStored: false,
+            indexPolicy: { search: false, vector: false },
+        },
+    };
+    const contentHash = rsvpHash(hashBasis(base));
+    const snapshot = {
+        ...base,
+        snapshotId: snapshotIdFor(contentHash),
+        contentHash,
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.snapshot_built",
+        message: "built RSVP snapshot",
+        meta: {
+            agent: snapshot.agent,
+            snapshotId: snapshot.snapshotId,
+            total: snapshot.summary.total,
+        },
+    });
+    return snapshot;
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function parseGuest(value) {
+    if (!isRecord(value))
+        return null;
+    if (typeof value.id !== "string")
+        return null;
+    if (typeof value.firstName !== "string")
+        return null;
+    if (typeof value.lastName !== "string")
+        return null;
+    if (typeof value.displayName !== "string")
+        return null;
+    if (!(typeof value.groupId === "string" || typeof value.groupId === "number" || value.groupId === null))
+        return null;
+    if (value.status !== "attending" && value.status !== "declined" && value.status !== "pending" && value.status !== "unknown")
+        return null;
+    if (!(typeof value.sourceStatus === "string" || value.sourceStatus === null))
+        return null;
+    return value;
+}
+function parseSummary(value) {
+    if (!isRecord(value))
+        return null;
+    const summary = value;
+    return typeof summary.attending === "number"
+        && typeof summary.declined === "number"
+        && typeof summary.pending === "number"
+        && typeof summary.unknown === "number"
+        && typeof summary.total === "number"
+        ? summary
+        : null;
+}
+function parseRsvpSnapshot(value) {
+    if (!isRecord(value))
+        return { ok: false, reason: "snapshot must be an object" };
+    if (value.schemaVersion !== 1)
+        return { ok: false, reason: "unsupported schemaVersion" };
+    if (value.policyVersion !== exports.RSVP_SNAPSHOT_POLICY_VERSION)
+        return { ok: false, reason: "unsupported policyVersion" };
+    if (typeof value.snapshotId !== "string")
+        return { ok: false, reason: "missing snapshotId" };
+    if (typeof value.agent !== "string")
+        return { ok: false, reason: "missing agent" };
+    if (typeof value.fetchedAt !== "string" || !Number.isFinite(Date.parse(value.fetchedAt)))
+        return { ok: false, reason: "invalid fetchedAt" };
+    if (!isRecord(value.source))
+        return { ok: false, reason: "invalid source" };
+    if (!isRecord(value.provenance))
+        return { ok: false, reason: "invalid provenance" };
+    if (!Array.isArray(value.guests))
+        return { ok: false, reason: "guests must be an array" };
+    const guests = value.guests.map(parseGuest);
+    if (guests.some((guest) => guest === null))
+        return { ok: false, reason: "invalid guest row" };
+    const ids = guests.map((guest) => guest.id);
+    if (new Set(ids).size !== ids.length)
+        return { ok: false, reason: "duplicate guest id" };
+    if (typeof value.allGuestIdsHash !== "string")
+        return { ok: false, reason: "missing allGuestIdsHash" };
+    const summary = parseSummary(value.summary);
+    if (!summary)
+        return { ok: false, reason: "invalid summary" };
+    if (!isRecord(value.privacy) || value.privacy.rawCredentialsStored !== false)
+        return { ok: false, reason: "invalid privacy" };
+    const snapshot = value;
+    if (typeof value.contentHash !== "string" || rsvpSnapshotContentHash(snapshot) !== value.contentHash) {
+        return { ok: false, reason: "contentHash mismatch" };
+    }
+    if (snapshotIdFor(value.contentHash) !== value.snapshotId)
+        return { ok: false, reason: "snapshotId mismatch" };
+    return { ok: true, snapshot };
+}
+function serializeRsvpSnapshotMetadata(snapshot) {
+    return {
+        schemaVersion: 1,
+        policyVersion: exports.RSVP_SNAPSHOT_POLICY_VERSION,
+        snapshotId: snapshot.snapshotId,
+        contentHash: snapshot.contentHash,
+        agent: snapshot.agent,
+        fetchedAt: snapshot.fetchedAt,
+        source: snapshot.source,
+        summary: snapshot.summary,
+        guestIdsHash: rsvpHash(snapshot.guests.map((guest) => guest.id).sort()),
+        rawGuestNamesStored: false,
+        indexPolicy: { search: false, vector: false },
+    };
+}

package/dist/senses/bluebubbles/client.js

@@ -273,7 +273,7 @@ function createBlueBubblesClient(config = (0, config_1.getBlueBubblesConfig)(),
             const url = buildBlueBubblesApiUrl(config.serverUrl, "/api/v1/message/text", config.password);
             const body = {
                 chatGuid: resolvedChatGuid,
-                tempGuid: (0, node_crypto_1.randomUUID)(),
+                tempGuid: params.tempGuid?.trim() || (0, node_crypto_1.randomUUID)(),
                 message: trimmedText,
             };
             if (params.replyToMessageGuid?.trim()) {
@@ -425,15 +425,21 @@ function createBlueBubblesClient(config = (0, config_1.getBlueBubblesConfig)(),
                 message: "querying recent bluebubbles messages",
                 meta: { limit, offset },
             });
+            const body = {
+                limit,
+                offset,
+                sort: "DESC",
+                ...(params.chatGuid?.trim() ? { chatGuid: params.chatGuid.trim() } : {}),
+                ...(params.chatIdentifier?.trim() ? { chatIdentifier: params.chatIdentifier.trim() } : {}),
+                ...(typeof params.beforeTimestamp === "number" && Number.isFinite(params.beforeTimestamp)
+                    ? { beforeTimestamp: params.beforeTimestamp }
+                    : {}),
+                with: ["chats", "attachments", "payloadData", "messageSummaryInfo"],
+            };
             const response = await fetch(url, {
                 method: "POST",
                 headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({
-                    limit,
-                    offset,
-                    sort: "DESC",
-                    with: ["chats", "attachments", "payloadData", "messageSummaryInfo"],
-                }),
+                body: JSON.stringify(body),
                 signal: AbortSignal.timeout(channelConfig.requestTimeoutMs),
             });
             if (!response.ok) {

package/dist/senses/bluebubbles/index.js

@@ -59,6 +59,7 @@ exports.startBlueBubblesApp = startBlueBubblesApp;
 const fs = __importStar(require("node:fs"));
 const http = __importStar(require("node:http"));
 const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
 const core_1 = require("../../heart/core");
 const config_1 = require("../../heart/config");
 const identity_1 = require("../../heart/identity");
@@ -83,6 +84,9 @@ const session_cleanup_1 = require("./session-cleanup");
 const active_turns_1 = require("./active-turns");
 const trust_gate_1 = require("../trust-gate");
 const pipeline_1 = require("../pipeline");
+const context_packets_1 = require("../context-packets");
+const context_packet_ledger_1 = require("../context-packet-ledger");
+const autonomy_budget_1 = require("../../heart/autonomy-budget");
 const bbFailoverStates = new Map();
 /**
  * In-flight message tracker.
@@ -259,6 +263,8 @@ const BLUEBUBBLES_LIVE_TURN_STALLED_MS = 90_000;
 const BLUEBUBBLES_SILENCE_WATCHDOG_MS = 75_000;
 const BLUEBUBBLES_CALLBACK_CLEANUP_TIMEOUT_MS = 2_000;
 const BLUEBUBBLES_ACTIVITY_OPERATION_TIMEOUT_MS = 20_000;
+const BLUEBUBBLES_CONTEXT_PACKET_LIMIT = 40;
+const BLUEBUBBLES_CONTEXT_PACKET_MAX_AGE_MS = 48 * 60 * 60 * 1000;
 const BLUEBUBBLES_CATCHUP_PAGE_SIZE = 50;
 const BLUEBUBBLES_CATCHUP_MAX_PAGES = 20;
 const BLUEBUBBLES_HEALTHY_CATCHUP_OVERLAP_MS = 90_000;
@@ -558,6 +564,174 @@ function getBlueBubblesContinuityIngressTexts(event) {
         .join("\n");
     return fallbackText ? [fallbackText] : [];
 }
+function sha256Hex(input) {
+    return (0, node_crypto_1.createHash)("sha256").update(input).digest("hex");
+}
+function timestampIsoForAutonomy(event) {
+    return Number.isFinite(event.timestamp)
+        ? new Date(event.timestamp).toISOString()
+        : new Date().toISOString();
+}
+function blueBubblesAutonomyTarget(event) {
+    return {
+        messageGuid: event.messageGuid,
+        sessionKeyHash: sha256Hex(event.chat.sessionKey),
+        chatGuidHash: event.chat.chatGuid ? sha256Hex(event.chat.chatGuid) : undefined,
+        chatIdentifierHash: event.chat.chatIdentifier ? sha256Hex(event.chat.chatIdentifier) : undefined,
+    };
+}
+function blueBubblesRecoveryStormInput(agentName, event, source) {
+    return {
+        agent: agentName,
+        triggerType: "recovery",
+        sourceKind: "sense",
+        senseOrHabit: "bluebubbles",
+        provider: "bluebubbles-recovery",
+        target: blueBubblesAutonomyTarget(event),
+        normalizedErrorName: "BlueBubblesRecoveryError",
+        normalizedErrorCode: "RECOVERY_FAILED",
+        codeLocation: `senses/bluebubbles/${source}`,
+        idempotencyBucket: `bluebubbles-recovery:${source}`,
+    };
+}
+function shouldUseBlueBubblesRecoveryBudget(source, options) {
+    return options.autonomyBudgetTrigger === "recovery"
+        || source === "mutation-recovery"
+        || source === "upstream-catchup"
+        || source === "recovery-bootstrap";
+}
+function shouldCountBlueBubblesRecoveryResultAsSkipped(reason) {
+    return reason === "already_processed" || reason === "autonomy_budget_blocked";
+}
+function recordBlueBubblesRecoveryFailureForBudget(agentName, event, source) {
+    try {
+        (0, autonomy_budget_1.recordAutonomyFailure)((0, identity_1.getAgentRoot)(agentName), {
+            ...blueBubblesRecoveryStormInput(agentName, event, source),
+            occurredAt: timestampIsoForAutonomy(event),
+        });
+    }
+    catch {
+        // Autonomy failure accounting must not turn a recovery error into a broader sense outage.
+    }
+}
+function chatKeyForContext(event) {
+    return event.chat.chatGuid ?? event.chat.chatIdentifier ?? event.chat.sessionKey;
+}
+function isSameBlueBubblesChat(candidate, anchor) {
+    return candidate.chat.sessionKey === anchor.chat.sessionKey
+        || (!!candidate.chat.chatGuid && candidate.chat.chatGuid === anchor.chat.chatGuid)
+        || (!!candidate.chat.chatIdentifier && candidate.chat.chatIdentifier === anchor.chat.chatIdentifier);
+}
+function contextAuthorLabel(event) {
+    if (event.fromMe)
+        return "Slugger";
+    return event.sender.displayName || event.sender.externalId || "Unknown";
+}
+function messageToContextInput(event, chatGuidHash) {
+    return {
+        timestamp: new Date(event.timestamp).toISOString(),
+        authorLabel: contextAuthorLabel(event),
+        body: event.textForAgent || event.text,
+        sourceRef: {
+            sense: "bluebubbles",
+            adapter: "bluebubbles-api-v1",
+            service: "imessage",
+            chatGuid: event.chat.chatGuid,
+            chatGuidHash,
+            messageGuid: event.messageGuid,
+            senderExternalIdHash: sha256Hex(event.sender.externalId || event.sender.rawId || "unknown"),
+            observedAt: new Date(event.timestamp).toISOString(),
+        },
+    };
+}
+function insertEphemeralContextMessages(messages, contextMessages) {
+    if (contextMessages.length === 0)
+        return messages;
+    const insertionIndex = Math.max(0, messages.length - 1);
+    return [
+        ...messages.slice(0, insertionIndex),
+        ...contextMessages,
+        ...messages.slice(insertionIndex),
+    ];
+}
+async function buildBlueBubblesContextMessages(input) {
+    if (input.event.kind !== "message")
+        return [];
+    const event = input.event;
+    if (!Number.isFinite(event.timestamp))
+        return [];
+    const chatKey = chatKeyForContext(event);
+    const chatGuidHash = sha256Hex(chatKey);
+    const anchorTimestamp = new Date(event.timestamp).toISOString();
+    try {
+        const query = {
+            beforeTimestamp: event.timestamp,
+            limit: BLUEBUBBLES_CONTEXT_PACKET_LIMIT,
+            offset: 0,
+            ...(event.chat.chatGuid ? { chatGuid: event.chat.chatGuid } : {}),
+            ...(!event.chat.chatGuid && event.chat.chatIdentifier ? { chatIdentifier: event.chat.chatIdentifier } : {}),
+        };
+        const candidates = input.client.listRecentMessages
+            ? await input.client.listRecentMessages(query)
+            : [];
+        const history = candidates
+            .filter((candidate) => candidate.kind === "message")
+            .filter((candidate) => isSameBlueBubblesChat(candidate, event))
+            .filter((candidate) => candidate.messageGuid !== event.messageGuid)
+            .filter((candidate) => candidate.timestamp <= event.timestamp)
+            .filter((candidate) => event.timestamp - candidate.timestamp <= BLUEBUBBLES_CONTEXT_PACKET_MAX_AGE_MS);
+        if (history.length === 0)
+            return [];
+        const packet = (0, context_packets_1.buildSenseContextPacket)({
+            agent: input.agentName,
+            sense: "bluebubbles",
+            sessionKey: event.chat.sessionKey,
+            chatKeyHash: chatGuidHash,
+            anchorMessageGuid: event.messageGuid,
+            anchorTimestamp,
+            windowBeforeMessages: BLUEBUBBLES_CONTEXT_PACKET_LIMIT,
+            windowBeforeMs: BLUEBUBBLES_CONTEXT_PACKET_MAX_AGE_MS,
+            messages: history.map((candidate) => messageToContextInput(candidate, chatGuidHash)),
+        });
+        (0, context_packet_ledger_1.writeSenseContextPacket)(input.agentRoot, packet);
+        const rendered = (0, context_packets_1.renderSenseContextPacketForPrompt)(packet, {
+            redactionPatterns: [/password=[^\s]+/gi],
+        });
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.bluebubbles_context_packet_injected",
+            message: "injected bluebubbles same-chat context packet",
+            meta: {
+                packetId: packet.packetId,
+                messageGuid: event.messageGuid,
+                contextMessages: history.length,
+            },
+        });
+        return [{ role: "system", content: rendered.text }];
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.bluebubbles_context_packet_error",
+            message: "failed to build live bluebubbles context packet",
+            meta: {
+                messageGuid: event.messageGuid,
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+        const fallback = (0, context_packet_ledger_1.readLatestVisibleSenseContextPacket)(input.agentRoot, {
+            sense: "bluebubbles",
+            chatKeyHash: chatGuidHash,
+            beforeAnchorTimestamp: anchorTimestamp,
+            maxAgeMs: 24 * 60 * 60 * 1000,
+        });
+        if (!fallback)
+            return [];
+        const rendered = (0, context_packets_1.renderSenseContextPacketForPrompt)(fallback);
+        return [{ role: "system", content: rendered.text }];
+    }
+}
 function createReplyTargetController(event) {
     const defaultTargetLabel = event.kind === "message" && event.threadOriginatorGuid?.trim() ? "current_lane" : "top_level";
     let selection = event.kind === "message" && event.threadOriginatorGuid?.trim()
@@ -1164,6 +1338,23 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source, opt
         }
         ownsInFlightMessage = true;
     }
+    if (event.kind === "message" && shouldUseBlueBubblesRecoveryBudget(source, options)) {
+        const decision = (0, autonomy_budget_1.reserveAutonomyBudget)((0, identity_1.getAgentRoot)(agentName), {
+            agent: agentName,
+            triggerType: "recovery",
+            sourceKind: "sense",
+            senseOrHabit: "bluebubbles",
+            target: blueBubblesAutonomyTarget(event),
+            idempotencyKey: `bluebubbles-recovery:${source}:${event.messageGuid}`,
+            now: timestampIsoForAutonomy(event),
+            storm: blueBubblesRecoveryStormInput(agentName, event, source),
+        });
+        if (!decision.allowed) {
+            endBlueBubblesMessageInFlight(inFlightKey.sessionKey, inFlightKey.messageGuid);
+            ownsInFlightMessage = false;
+            return { handled: true, notifiedAgent: false, kind: event.kind, reason: "autonomy_budget_blocked" };
+        }
+    }
     try {
         // ── Adapter setup: friend, session, content, callbacks ──────────
         const store = resolvedDeps.createFriendStore();
@@ -1359,27 +1550,35 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source, opt
                     enforceTrustGate: trust_gate_1.enforceTrustGate,
                     drainPending: pending_1.drainPending,
                     drainDeferredReturns: (deferredFriendId) => (0, pending_1.drainDeferredReturns)(resolvedDeps.getAgentName(), deferredFriendId),
-                    runAgent: (msgs, cb, channel, sig, opts) => resolvedDeps.runAgent(msgs, cb, channel, sig, {
-                        ...opts,
-                        toolContext: {
-                            /* v8 ignore next -- default no-op signin; pipeline provides the real one @preserve */
-                            signin: async () => undefined,
-                            ...opts?.toolContext,
-                            summarize,
-                            bluebubblesReplyTarget: {
-                                setSelection: (selection) => replyTarget.setSelection(selection),
-                            },
-                            codingFeedback: {
-                                send: async (message) => {
-                                    await client.sendText({
-                                        chat: event.chat,
-                                        text: message,
-                                        replyToMessageGuid: replyTarget.getReplyToMessageGuid(),
-                                    });
+                    runAgent: async (msgs, cb, channel, sig, opts) => {
+                        const contextMessages = await buildBlueBubblesContextMessages({
+                            agentName,
+                            agentRoot: (0, identity_1.getAgentRoot)(),
+                            client,
+                            event,
+                        });
+                        return resolvedDeps.runAgent(insertEphemeralContextMessages(msgs, contextMessages), cb, channel, sig, {
+                            ...opts,
+                            toolContext: {
+                                /* v8 ignore next -- default no-op signin; pipeline provides the real one @preserve */
+                                signin: async () => undefined,
+                                ...opts?.toolContext,
+                                summarize,
+                                bluebubblesReplyTarget: {
+                                    setSelection: (selection) => replyTarget.setSelection(selection),
+                                },
+                                codingFeedback: {
+                                    send: async (message) => {
+                                        await client.sendText({
+                                            chat: event.chat,
+                                            text: message,
+                                            replyToMessageGuid: replyTarget.getReplyToMessageGuid(),
+                                        });
+                                    },
                                 },
                             },
-                        },
-                    }),
+                        });
+                    },
                     postTurn: (turnMessages, sessionPathArg, usage, hooks, state) => {
                         const prepared = resolvedDeps.postTurnTrim(turnMessages, usage, hooks);
                         resolvedDeps.deferPostTurnPersist(sessionPathArg, prepared, usage, state);
@@ -1970,8 +2169,9 @@ async function catchUpMissedBlueBubblesMessages(deps = {}, previousState, option
             }
             const handled = await handleBlueBubblesNormalizedEvent(repaired, resolvedDeps, "upstream-catchup", {
                 timeoutMs: BLUEBUBBLES_RECOVERY_TURN_TIMEOUT_MS,
+                autonomyBudgetTrigger: "recovery",
             });
-            if (handled.reason === "already_processed") {
+            if (shouldCountBlueBubblesRecoveryResultAsSkipped(handled.reason)) {
                 result.skipped++;
             }
             else {
@@ -1980,6 +2180,7 @@ async function catchUpMissedBlueBubblesMessages(deps = {}, previousState, option
             }
         }
         catch (error) {
+            recordBlueBubblesRecoveryFailureForBudget(agentName, event, "upstream-catchup");
             result.failed++;
             (0, runtime_1.emitNervesEvent)({
                 level: "warn",
@@ -2066,8 +2267,9 @@ async function recoverCapturedBlueBubblesInboundMessages(deps = {}) {
             }
             const handled = await handleBlueBubblesNormalizedEvent(repaired, resolvedDeps, entry.source, {
                 timeoutMs: BLUEBUBBLES_RECOVERY_TURN_TIMEOUT_MS,
+                autonomyBudgetTrigger: "recovery",
             });
-            if (handled.reason === "already_processed") {
+            if (shouldCountBlueBubblesRecoveryResultAsSkipped(handled.reason)) {
                 result.skipped++;
             }
             else {
@@ -2075,6 +2277,7 @@ async function recoverCapturedBlueBubblesInboundMessages(deps = {}) {
             }
         }
         catch (error) {
+            recordBlueBubblesRecoveryFailureForBudget(agentName, inboundEntryToRecoveryEvent(entry), entry.source);
             result.failed++;
             (0, runtime_1.emitNervesEvent)({
                 level: "warn",
@@ -2111,8 +2314,9 @@ async function recoverMissedBlueBubblesMessages(deps = {}) {
             }
             const handled = await handleBlueBubblesNormalizedEvent(repaired, resolvedDeps, "mutation-recovery", {
                 timeoutMs: BLUEBUBBLES_RECOVERY_TURN_TIMEOUT_MS,
+                autonomyBudgetTrigger: "recovery",
             });
-            if (handled.reason === "already_processed") {
+            if (shouldCountBlueBubblesRecoveryResultAsSkipped(handled.reason)) {
                 result.skipped++;
             }
             else {
@@ -2120,6 +2324,7 @@ async function recoverMissedBlueBubblesMessages(deps = {}) {
             }
         }
         catch (error) {
+            recordBlueBubblesRecoveryFailureForBudget(agentName, mutationEntryToEvent(candidate), "mutation-recovery");
             result.failed++;
             (0, runtime_1.emitNervesEvent)({
                 level: "warn",