@ouro.bot/cli 0.1.0-alpha.954 → 0.1.0-alpha.955

package/changelog.json

@@ -1,6 +1,12 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.955",
+      "changes": [
+        "iMessage no longer loses a reply that fails to send. When Slugger's reply times out or otherwise fails at BlueBubbles, your message stays pending; about ten minutes later a recovery pass checks the chat, and if the reply did not arrive after all, Slugger answers again. The message is marked handled only once a reply goes through. After three failed sends it is given up on with an error in the logs, so one stuck message cannot use up the day's recovery budget. If Slugger had already said something partway through that turn, the message is not retried, so you never see that part twice."
+      ]
+    },
     {
       "version": "0.1.0-alpha.954",
       "changes": [

package/deploy/unraid/sanctuary.ouro/bundle-meta.json

@@ -1,5 +1,5 @@
 {
-  "runtimeVersion": "0.1.0-alpha.954",
+  "runtimeVersion": "0.1.0-alpha.955",
   "bundleSchemaVersion": 3,
   "lastUpdated": "2026-09-03T00:00:00.000Z"
 }

package/deploy/unraid/sanctuary.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0"?>
 <Container version="2">
   <Name>ouro-butler</Name>
-  <Repository>ghcr.io/ourostack/ouroboros-butler:0.1.0-alpha.954</Repository>
+  <Repository>ghcr.io/ourostack/ouroboros-butler:0.1.0-alpha.955</Repository>
   <Registry>https://github.com/ourostack/ouroboros/pkgs/container/ouroboros-butler</Registry>
   <Network>host</Network>
   <Shell>sh</Shell>

package/dist/senses/bluebubbles/index.js

@@ -106,6 +106,11 @@ const BLUEBUBBLES_VISIBLE_OUTBOUND_STATUSES = new Set([
     "local-visible",
     "delivered",
 ]);
+// A reply whose final send keeps failing stays pending for recovery this many
+// times, then gets a terminal receipt so one message cannot drain the budget.
+const BLUEBUBBLES_REPLY_DELIVERY_MAX_ATTEMPTS = 3;
+// A timed-out send may still land, so wait before checking the chat and retrying.
+const BLUEBUBBLES_REPLY_RETRY_DELAY_MS = 10 * 60_000;
 exports.BLUEBUBBLES_SEMANTIC_GENERATION_RETENTION_MS = 15 * 60_000;
 function pruneBlueBubblesSemanticObservationGenerations(nowMs = Date.now()) {
     let pruned = 0;
@@ -1622,8 +1627,12 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source, opt
                 const turnStage = createBlueBubblesTurnStage(event.chat.sessionKey);
                 let finalTransportInvoked = false;
                 let finalTransportAccepted = false;
+                let spokeBeforeFinalTransport = false;
                 const outboundRuntimeConfig = (0, config_1.getBlueBubblesConfig)();
-                const callbacks = createBlueBubblesCallbacks(client, event.chat, replyTarget, event.chat.isGroup, () => (0, active_turns_1.noteBlueBubblesActiveTurnVisibleActivity)(agentName, liveTurnId), {
+                const callbacks = createBlueBubblesCallbacks(client, event.chat, replyTarget, event.chat.isGroup, () => {
+                    spokeBeforeFinalTransport = true;
+                    (0, active_turns_1.noteBlueBubblesActiveTurnVisibleActivity)(agentName, liveTurnId);
+                }, {
                     admitOutbound: async () => (!options.lifecycleSignal?.aborted
                         && await (0, latest_turn_1.awaitDeliveryAdmission)(options.latestTurnCapability)
                         && !options.lifecycleSignal?.aborted),
@@ -1976,6 +1985,18 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source, opt
                                     reason: error instanceof Error ? error.message : String(error),
                                 },
                             });
+                            if (spokeBeforeFinalTransport) {
+                                // The friend already saw part of this turn; a retry would repeat it.
+                                const failed = (0, outbound_state_1.readBlueBubblesOutboundRecordByIdempotencyKey)((0, identity_1.getAgentRoot)(), blueBubblesInboundReplyIdempotencyKey(options.currentIngressEvidence.captureKeyHash));
+                                if (failed) {
+                                    (0, outbound_state_1.markBlueBubblesOutboundPendingManualVerification)({
+                                        agentRoot: (0, identity_1.getAgentRoot)(),
+                                        recordId: failed.recordId,
+                                        decidedAt: new Date().toISOString(),
+                                        reason: "mid-turn speech was visible before the final send failed",
+                                    });
+                                }
+                            }
                             return {
                                 handled: true,
                                 notifiedAgent: false,
@@ -2406,6 +2427,18 @@ function writeCapturedBlueBubblesHandled(agentName, capture, outcome, detailCode
 function blueBubblesInboundReplyIdempotencyKey(captureKeyHash) {
     return `bluebubbles-inbound-reply:${captureKeyHash}`;
 }
+async function blueBubblesFailedReplyIsVisible(deps, chat, record) {
+    const since = Date.parse(record.createdAt);
+    const recent = await deps.createClient().listRecentMessages?.({
+        chatGuid: chat.chatGuid,
+        limit: 25,
+    }) ?? [];
+    return recent.some((message) => (message.kind === "message"
+        && message.fromMe
+        && message.timestamp >= since
+        && message.chat.chatGuid === chat.chatGuid
+        && (0, outbound_state_1.blueBubblesOutboundTextMatches)(record, message.text)));
+}
 function blueBubblesRecoveredOutboundOutcome(record) {
     return BLUEBUBBLES_VISIBLE_OUTBOUND_STATUSES.has(record.status)
         ? "message_completed"
@@ -2520,7 +2553,13 @@ async function handleCapturedBlueBubblesSemanticEvent(captured, resolvedDeps, so
             return result;
         }
         const durableOutbound = (0, outbound_state_1.readBlueBubblesOutboundRecordByIdempotencyKey)((0, identity_1.getAgentRoot)(), blueBubblesInboundReplyIdempotencyKey(captured.capture.keyHash));
-        if (durableOutbound) {
+        const retryFailedReply = durableOutbound?.status === "failed"
+            && (durableOutbound.failedAttempts ?? 0) < BLUEBUBBLES_REPLY_DELIVERY_MAX_ATTEMPTS;
+        if (retryFailedReply
+            && Date.now() < Date.parse(durableOutbound.failedAt ?? durableOutbound.updatedAt) + BLUEBUBBLES_REPLY_RETRY_DELAY_MS) {
+            return { handled: true, notifiedAgent: false, kind: captured.normalized.kind, reason: "delivery_failed" };
+        }
+        if (durableOutbound && !retryFailedReply) {
             const outcome = blueBubblesRecoveredOutboundOutcome(durableOutbound);
             (0, runtime_1.emitNervesEvent)({
                 level: "warn",
@@ -2627,11 +2666,74 @@ async function handleCapturedBlueBubblesSemanticEvent(captured, resolvedDeps, so
                 orientationConversationKind: canonicalEvent.chat.isGroup ? "group" : "one_to_one",
                 publishAcceptedReceipt,
             };
+            let failedReplyVisible = false;
+            if (retryFailedReply) {
+                try {
+                    failedReplyVisible = await blueBubblesFailedReplyIsVisible(resolvedDeps, canonicalEvent.chat, durableOutbound);
+                }
+                catch (error) {
+                    // Without the chat history a retry could reply twice; try again later.
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "warn",
+                        component: "senses",
+                        event: "senses.bluebubbles_reply_retry_deferred",
+                        message: "deferred a bluebubbles reply retry because recent chat messages could not be read",
+                        meta: {
+                            messageGuid: captured.normalized.messageGuid,
+                            reason: error instanceof Error ? error.message : String(error),
+                        },
+                    });
+                    return { handled: true, notifiedAgent: false, kind: captured.normalized.kind, reason: "delivery_failed" };
+                }
+            }
+            if (failedReplyVisible) {
+                // The send that timed out reached the chat after all; do not reply twice.
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "senses",
+                    event: "senses.bluebubbles_inbound_reply_recovery_suppressed",
+                    message: "suppressed bluebubbles reply retry because a reply is already in the chat",
+                    meta: { messageGuid: captured.normalized.messageGuid, recordId: durableOutbound.recordId },
+                });
+                publishTerminalReceipt("message_completed", "reply_visible_after_failed_send");
+                semanticHandlingCompleted = true;
+                return { handled: true, notifiedAgent: false, kind: captured.normalized.kind, reason: "already_processed" };
+            }
             result = await handleBlueBubblesNormalizedEvent(canonicalEvent, resolvedDeps, source, capturedOptions);
             // A budget or storm-breaker block defers the message; it was never seen.
             // Leave it pending so a later recovery pass retries it once the block lifts.
             if (result.reason === "autonomy_budget_blocked")
                 return result;
+            if (result.reason === "delivery_failed") {
+                // The reply never reached the chat. Leave the message pending so a later
+                // recovery pass sends it, until the per-message attempt cap is reached.
+                let failed = (0, outbound_state_1.readBlueBubblesOutboundRecordByIdempotencyKey)((0, identity_1.getAgentRoot)(), blueBubblesInboundReplyIdempotencyKey(captured.capture.keyHash));
+                if (failed?.status === "failed") {
+                    if (retryFailedReply && failed.failedAttempts === durableOutbound.failedAttempts) {
+                        // The retry failed before it reached the transport; count it anyway.
+                        failed = (0, outbound_state_1.markBlueBubblesOutboundFailed)({
+                            agentRoot: (0, identity_1.getAgentRoot)(),
+                            recordId: failed.recordId,
+                            failedAt: new Date().toISOString(),
+                            reason: "retry failed before the final transport",
+                        });
+                    }
+                    /* v8 ignore next -- a failed record re-read after a send always carries its count @preserve */
+                    const failedAttempts = failed.failedAttempts ?? 0;
+                    if (failedAttempts < BLUEBUBBLES_REPLY_DELIVERY_MAX_ATTEMPTS)
+                        return result;
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "error",
+                        component: "senses",
+                        event: "senses.bluebubbles_reply_delivery_abandoned",
+                        message: "gave up sending a bluebubbles reply after repeated transport failures",
+                        meta: { messageGuid: captured.normalized.messageGuid, failedAttempts },
+                    });
+                    publishTerminalReceipt("message_observed", "reply_delivery_retries_exhausted");
+                    semanticHandlingCompleted = true;
+                    return result;
+                }
+            }
             handledOutcome = result.notifiedAgent ? "message_completed" : "message_observed";
         }
         if (result.notifiedAgent) {

package/dist/senses/bluebubbles/outbound-state.js

@@ -37,6 +37,7 @@ exports.BLUEBUBBLES_OUTBOUND_STATE_POLICY_VERSION = void 0;
 exports.blueBubblesOutboundRecordPath = blueBubblesOutboundRecordPath;
 exports.buildBlueBubblesRouteProof = buildBlueBubblesRouteProof;
 exports.buildBlueBubblesAttachmentProof = buildBlueBubblesAttachmentProof;
+exports.blueBubblesOutboundTextMatches = blueBubblesOutboundTextMatches;
 exports.readBlueBubblesOutboundRecord = readBlueBubblesOutboundRecord;
 exports.readBlueBubblesOutboundRecordByIdempotencyKey = readBlueBubblesOutboundRecordByIdempotencyKey;
 exports.reserveBlueBubblesOutbound = reserveBlueBubblesOutbound;
@@ -139,6 +140,10 @@ function buildRecord(input) {
         contentStored: false,
     };
 }
+/** True when `text` is the reply this record last tried to send. */
+function blueBubblesOutboundTextMatches(record, text) {
+    return hash(normalizeText(text)) === record.textHash;
+}
 function writeJsonAtomic(filePath, value) {
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
     const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
@@ -240,6 +245,26 @@ function reserveBlueBubblesOutbound(input) {
         const existing = readBlueBubblesOutboundRecord(input.agentRoot, record.recordId);
         if (!existing)
             throw new Error(`bluebubbles outbound reservation is unreadable: ${record.recordId}`);
+        if (existing.status === "failed"
+            && existing.routeProof.routeHash === record.routeProof.routeHash
+            && existing.attachmentProof.identityHash === record.attachmentProof.identityHash) {
+            // A failed send to the same chat is retryable, possibly with new text:
+            // reserve again, keeping the first attempt's time and the failure history.
+            const retry = writeBlueBubblesOutboundRecord(input.agentRoot, {
+                ...record,
+                createdAt: existing.createdAt,
+                ...(existing.failedAttempts ? { failedAttempts: existing.failedAttempts } : {}),
+                ...(existing.failedAt ? { failedAt: existing.failedAt } : {}),
+                ...(existing.failureReason ? { failureReason: existing.failureReason } : {}),
+            });
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.bluebubbles_outbound_reserved",
+                message: "reserved bluebubbles outbound idempotency key again after a failed send",
+                meta: { recordId: retry.recordId, textLength: retry.textLength, failedAttempts: retry.failedAttempts ?? 0 },
+            });
+            return { status: "reserved", record: retry };
+        }
         if (identityMatches(existing, record)) {
             emitDuplicate(existing);
             return { status: "duplicate", record: existing };
@@ -295,9 +320,11 @@ function markBlueBubblesOutboundDelivered(input) {
     });
 }
 function markBlueBubblesOutboundFailed(input) {
+    const failedAttempts = (readBlueBubblesOutboundRecord(input.agentRoot, input.recordId)?.failedAttempts ?? 0) + 1;
     return updateStatus(input.agentRoot, input.recordId, "failed", input.failedAt, {
         failedAt: input.failedAt,
         failureReason: input.reason.slice(0, 500),
+        failedAttempts,
     });
 }
 function markBlueBubblesOutboundPendingManualVerification(input) {

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.954",
+  "version": "0.1.0-alpha.955",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@ouro.bot/cli",
-      "version": "0.1.0-alpha.954",
+      "version": "0.1.0-alpha.955",
       "dependencies": {
         "@anthropic-ai/sdk": "^0.78.0",
         "@azure/identity": "^4.13.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.954",
+  "version": "0.1.0-alpha.955",
   "engines": {
     "node": ">=22"
   },