@ouro.bot/cli 0.1.0-alpha.540 → 0.1.0-alpha.542

package/changelog.json

@@ -1,6 +1,21 @@
 {
   "_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.542",
+      "changes": [
+        "BlueBubbles recovery timeouts now leave iMessage messages pending instead of marking them processed, and legacy `recovery-timeout` processed records no longer suppress retries.",
+        "Recovery turns now get a longer bounded timeout and keep their in-flight guard until the abandoned turn settles, preventing duplicate retries while preserving truthful pending recovery state.",
+        "iMessage recovery health now counts pending work by message GUID across captured inbound and mutation sidecars, preventing one missed message from being reported as multiple queued items."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.541",
+      "changes": [
+        "BlueBubbles recovery now treats message GUID completion as authoritative across repaired session keys, so stale `chat_identifier:unknown` mutation/capture sidecars stop keeping iMessage health in a false pending-recovery state after the real chat turn has completed.",
+        "Adds regression coverage for recovered captured-inbound and mutation backlog records whose original degraded session key differs from the canonical processed chat key."
+      ]
+    },
     {
       "version": "0.1.0-alpha.540",
       "changes": [

package/dist/senses/bluebubbles/index.js

@@ -170,7 +170,7 @@ const defaultDeps = {
 const BLUEBUBBLES_RUNTIME_SYNC_INTERVAL_MS = 30_000;
 const BLUEBUBBLES_RECOVERY_PASS_DELAY_MS = 1_000;
 const BLUEBUBBLES_RECOVERY_PASS_INTERVAL_MS = 30_000;
-const BLUEBUBBLES_RECOVERY_TURN_TIMEOUT_MS = 60_000;
+const BLUEBUBBLES_RECOVERY_TURN_TIMEOUT_MS = 10 * 60_000;
 const BLUEBUBBLES_CATCHUP_PAGE_SIZE = 50;
 const BLUEBUBBLES_CATCHUP_MAX_PAGES = 20;
 const BLUEBUBBLES_HEALTHY_CATCHUP_OVERLAP_MS = 90_000;
@@ -182,10 +182,6 @@ class BlueBubblesRecoveryTurnTimeoutError extends Error {
         this.name = "BlueBubblesRecoveryTurnTimeoutError";
     }
 }
-function isBlueBubblesRecoveryTurnTimeoutError(error) {
-    return error instanceof BlueBubblesRecoveryTurnTimeoutError
-        || (error instanceof Error && error.name === "BlueBubblesRecoveryTurnTimeoutError");
-}
 function resolveFriendParams(event) {
     if (event.chat.isGroup) {
         const groupKey = event.chat.chatGuid ?? event.chat.chatIdentifier ?? event.sender.externalId;
@@ -827,8 +823,10 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source, opt
         return { handled: true, notifiedAgent: false, kind: event.kind, reason: "mutation_state_only" };
     }
     let ownsInFlightMessage = false;
+    let releaseInFlightAfterTurnSettles = false;
     if (event.kind === "message") {
-        if ((0, processed_log_1.hasProcessedBlueBubblesMessage)(agentName, event.chat.sessionKey, event.messageGuid)) {
+        if ((0, processed_log_1.hasProcessedBlueBubblesMessage)(agentName, event.chat.sessionKey, event.messageGuid)
+            || (0, processed_log_1.hasProcessedBlueBubblesMessageGuid)(agentName, event.messageGuid)) {
             (0, runtime_1.emitNervesEvent)({
                 component: "senses",
                 event: "senses.bluebubbles_recovery_skip",
@@ -988,6 +986,7 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source, opt
                     timeoutTimer = setTimeout(() => {
                         const reason = new BlueBubblesRecoveryTurnTimeoutError(timeoutMs);
                         recoveryTimedOut = true;
+                        releaseInFlightAfterTurnSettles = true;
                         controller.abort(reason);
                         timeoutReject?.(reason);
                         (0, runtime_1.emitNervesEvent)({
@@ -1071,7 +1070,8 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source, opt
                 });
                 /* v8 ignore start -- detached late-rejection telemetry is asserted in timeout tests, but V8 does not reliably attribute Promise.catch callbacks @preserve */
                 if (timeoutPromise) {
-                    void turnPromise.catch((error) => {
+                    void turnPromise
+                        .catch((error) => {
                         if (!recoveryTimedOut)
                             return;
                         (0, runtime_1.emitNervesEvent)({
@@ -1086,6 +1086,11 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source, opt
                                 reason: error instanceof Error ? error.message : String(error),
                             },
                         });
+                    })
+                        .finally(() => {
+                        if (releaseInFlightAfterTurnSettles && ownsInFlightMessage && event.kind === "message") {
+                            endBlueBubblesMessageInFlight(event.chat.sessionKey, event.messageGuid);
+                        }
                     });
                 }
                 /* v8 ignore stop */
@@ -1159,7 +1164,7 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source, opt
         });
     }
     finally {
-        if (ownsInFlightMessage && event.kind === "message") {
+        if (ownsInFlightMessage && event.kind === "message" && !releaseInFlightAfterTurnSettles) {
             endBlueBubblesMessageInFlight(event.chat.sessionKey, event.messageGuid);
         }
     }
@@ -1211,6 +1216,7 @@ async function handleBlueBubblesEvent(payload, deps = {}) {
     // normalizeBlueBubblesEvent rejects guidless payloads, so duplicate handling
     // only needs to discriminate between known processed, in-flight, or new.
     const duplicateReason = (0, processed_log_1.hasProcessedBlueBubblesMessage)(agentName, normalized.chat.sessionKey, normalized.messageGuid)
+        || (0, processed_log_1.hasProcessedBlueBubblesMessageGuid)(agentName, normalized.messageGuid)
         ? "processed"
         : isBlueBubblesMessageInFlight(normalized.chat.sessionKey, normalized.messageGuid)
             ? "in_flight"
@@ -1235,14 +1241,6 @@ async function handleBlueBubblesEvent(payload, deps = {}) {
     const event = await client.repairEvent(normalized);
     return handleBlueBubblesNormalizedEvent(event, resolvedDeps, "webhook");
 }
-function countPendingRecoveryCandidates(agentName) {
-    return (0, mutation_log_1.listBlueBubblesRecoveryCandidates)(agentName)
-        .filter((entry) => !(0, processed_log_1.hasProcessedBlueBubblesMessage)(agentName, entry.sessionKey, entry.messageGuid))
-        .length;
-}
-function countPendingCapturedInboundMessages(agentName) {
-    return listPendingCapturedInboundMessages(agentName).length;
-}
 function listPendingCapturedInboundMessages(agentName) {
     const seenMessageGuids = new Set();
     return (0, inbound_log_1.listRecordedBlueBubblesInbound)(agentName)
@@ -1252,7 +1250,31 @@ function listPendingCapturedInboundMessages(agentName) {
         seenMessageGuids.add(entry.messageGuid);
         return true;
     })
-        .filter((entry) => !(0, processed_log_1.hasProcessedBlueBubblesMessage)(agentName, entry.sessionKey, entry.messageGuid));
+        .filter((entry) => !(0, processed_log_1.hasProcessedBlueBubblesMessageGuid)(agentName, entry.messageGuid));
+}
+function listPendingRecoveryEntries(agentName) {
+    const pendingByGuid = new Map();
+    const add = (messageGuid, recordedAt) => {
+        if ((0, processed_log_1.hasProcessedBlueBubblesMessageGuid)(agentName, messageGuid))
+            return;
+        const previous = pendingByGuid.get(messageGuid);
+        if (!previous) {
+            pendingByGuid.set(messageGuid, recordedAt);
+            return;
+        }
+        const previousMs = Date.parse(previous);
+        const nextMs = Date.parse(recordedAt);
+        if (Number.isFinite(nextMs) && (!Number.isFinite(previousMs) || nextMs < previousMs)) {
+            pendingByGuid.set(messageGuid, recordedAt);
+        }
+    };
+    for (const entry of listPendingCapturedInboundMessages(agentName)) {
+        add(entry.messageGuid, entry.recordedAt);
+    }
+    for (const entry of (0, mutation_log_1.listBlueBubblesRecoveryCandidates)(agentName)) {
+        add(entry.messageGuid, entry.recordedAt);
+    }
+    return [...pendingByGuid].map(([messageGuid, recordedAt]) => ({ messageGuid, recordedAt }));
 }
 function parseTimestampMs(value) {
     if (!value)
@@ -1278,18 +1300,15 @@ function formatBlueBubblesRuntimeDetail(queued, failed) {
     return "upstream reachable";
 }
 function blueBubblesPendingRecoverySnapshot(agentName, nowMs = Date.now()) {
-    const pendingRecordedAt = [
-        ...listPendingCapturedInboundMessages(agentName).map((entry) => entry.recordedAt),
-        ...(0, mutation_log_1.listBlueBubblesRecoveryCandidates)(agentName)
-            .filter((entry) => !(0, processed_log_1.hasProcessedBlueBubblesMessage)(agentName, entry.sessionKey, entry.messageGuid))
-            .map((entry) => entry.recordedAt),
-    ]
+    const pendingEntries = listPendingRecoveryEntries(agentName);
+    const pendingRecordedAt = pendingEntries
+        .map((entry) => entry.recordedAt)
         .map((value) => ({ value, ms: Date.parse(value) }))
         .filter((entry) => Number.isFinite(entry.ms))
         .sort((left, right) => left.ms - right.ms);
     const oldest = pendingRecordedAt[0];
     return {
-        pendingRecoveryCount: countPendingCapturedInboundMessages(agentName) + countPendingRecoveryCandidates(agentName),
+        pendingRecoveryCount: pendingEntries.length,
         oldestPendingRecoveryAt: oldest?.value,
         oldestPendingRecoveryAgeMs: oldest ? Math.max(0, nowMs - oldest.ms) : undefined,
     };
@@ -1468,7 +1487,7 @@ async function catchUpMissedBlueBubblesMessages(deps = {}, previousState, option
         result.inspected++;
         if (event.fromMe
             || event.timestamp < catchUpSince
-            || (0, processed_log_1.hasProcessedBlueBubblesMessage)(agentName, event.chat.sessionKey, event.messageGuid)
+            || (0, processed_log_1.hasProcessedBlueBubblesMessageGuid)(agentName, event.messageGuid)
             || isBlueBubblesMessageInFlight(event.chat.sessionKey, event.messageGuid)) {
             result.skipped++;
             continue;
@@ -1482,14 +1501,12 @@ async function catchUpMissedBlueBubblesMessages(deps = {}, previousState, option
             result.queued = (result.queued ?? 0) + 1;
             continue;
         }
-        let repairedMessage = null;
         try {
             const repaired = await client.repairEvent(event);
             if (repaired.kind !== "message") {
                 result.skipped++;
                 continue;
             }
-            repairedMessage = repaired;
             const handled = await handleBlueBubblesNormalizedEvent(repaired, resolvedDeps, "upstream-catchup", {
                 timeoutMs: BLUEBUBBLES_RECOVERY_TURN_TIMEOUT_MS,
             });
@@ -1503,9 +1520,6 @@ async function catchUpMissedBlueBubblesMessages(deps = {}, previousState, option
         }
         catch (error) {
             result.failed++;
-            if (repairedMessage && isBlueBubblesRecoveryTurnTimeoutError(error)) {
-                (0, processed_log_1.recordProcessedBlueBubblesMessage)(agentName, repairedMessage, "upstream-catchup", "recovery-timeout");
-            }
             (0, runtime_1.emitNervesEvent)({
                 level: "warn",
                 component: "senses",
@@ -1578,18 +1592,17 @@ async function recoverCapturedBlueBubblesInboundMessages(deps = {}) {
         .sort((left, right) => (parseTimestampMs(left.recordedAt) ?? 0) - (parseTimestampMs(right.recordedAt) ?? 0));
     for (const entry of candidates) {
         if ((0, processed_log_1.hasProcessedBlueBubblesMessage)(agentName, entry.sessionKey, entry.messageGuid)
+            || (0, processed_log_1.hasProcessedBlueBubblesMessageGuid)(agentName, entry.messageGuid)
             || isBlueBubblesMessageInFlight(entry.sessionKey, entry.messageGuid)) {
             result.skipped++;
             continue;
         }
-        let repairedMessage = null;
         try {
             const repaired = await client.repairEvent(inboundEntryToRecoveryEvent(entry));
             if (repaired.kind !== "message") {
                 result.skipped++;
                 continue;
             }
-            repairedMessage = repaired;
             const handled = await handleBlueBubblesNormalizedEvent(repaired, resolvedDeps, entry.source, {
                 timeoutMs: BLUEBUBBLES_RECOVERY_TURN_TIMEOUT_MS,
             });
@@ -1602,9 +1615,6 @@ async function recoverCapturedBlueBubblesInboundMessages(deps = {}) {
         }
         catch (error) {
             result.failed++;
-            if (repairedMessage && isBlueBubblesRecoveryTurnTimeoutError(error)) {
-                (0, processed_log_1.recordProcessedBlueBubblesMessage)(agentName, repairedMessage, entry.source, "recovery-timeout");
-            }
             (0, runtime_1.emitNervesEvent)({
                 level: "warn",
                 component: "senses",
@@ -1627,18 +1637,17 @@ async function recoverMissedBlueBubblesMessages(deps = {}) {
     const result = { recovered: 0, skipped: 0, pending: 0, failed: 0 };
     for (const candidate of (0, mutation_log_1.listBlueBubblesRecoveryCandidates)(agentName)) {
         if ((0, processed_log_1.hasProcessedBlueBubblesMessage)(agentName, candidate.sessionKey, candidate.messageGuid)
+            || (0, processed_log_1.hasProcessedBlueBubblesMessageGuid)(agentName, candidate.messageGuid)
             || isBlueBubblesMessageInFlight(candidate.sessionKey, candidate.messageGuid)) {
             result.skipped++;
             continue;
         }
-        let repairedMessage = null;
         try {
             const repaired = await client.repairEvent(mutationEntryToEvent(candidate));
             if (repaired.kind !== "message") {
                 result.pending++;
                 continue;
             }
-            repairedMessage = repaired;
             const handled = await handleBlueBubblesNormalizedEvent(repaired, resolvedDeps, "mutation-recovery", {
                 timeoutMs: BLUEBUBBLES_RECOVERY_TURN_TIMEOUT_MS,
             });
@@ -1651,9 +1660,6 @@ async function recoverMissedBlueBubblesMessages(deps = {}) {
         }
         catch (error) {
             result.failed++;
-            if (repairedMessage && isBlueBubblesRecoveryTurnTimeoutError(error)) {
-                (0, processed_log_1.recordProcessedBlueBubblesMessage)(agentName, repairedMessage, "mutation-recovery", "recovery-timeout");
-            }
             (0, runtime_1.emitNervesEvent)({
                 level: "warn",
                 component: "senses",

package/dist/senses/bluebubbles/processed-log.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getBlueBubblesProcessedLogPath = getBlueBubblesProcessedLogPath;
 exports.hasProcessedBlueBubblesMessage = hasProcessedBlueBubblesMessage;
+exports.hasProcessedBlueBubblesMessageGuid = hasProcessedBlueBubblesMessageGuid;
 exports.recordProcessedBlueBubblesMessage = recordProcessedBlueBubblesMessage;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
@@ -58,17 +59,38 @@ function readEntries(filePath) {
         return [];
     }
 }
+function readAllEntries(agentName) {
+    const processedDir = path.join((0, identity_1.getAgentRoot)(agentName), "state", "senses", "bluebubbles", "processed");
+    try {
+        return fs.readdirSync(processedDir)
+            .filter((name) => name.endsWith(".ndjson"))
+            .sort()
+            .flatMap((name) => readEntries(path.join(processedDir, name)));
+    }
+    catch {
+        return [];
+    }
+}
+function isCompletedProcessedEntry(entry) {
+    return entry.outcome !== "recovery-timeout";
+}
 function hasProcessedBlueBubblesMessage(agentName, sessionKey, messageGuid) {
     if (!messageGuid.trim())
         return false;
     const filePath = getBlueBubblesProcessedLogPath(agentName, sessionKey);
-    return readEntries(filePath).some((entry) => entry.messageGuid === messageGuid);
+    return readEntries(filePath).some((entry) => entry.messageGuid === messageGuid && isCompletedProcessedEntry(entry));
+}
+function hasProcessedBlueBubblesMessageGuid(agentName, messageGuid) {
+    if (!messageGuid.trim())
+        return false;
+    return readAllEntries(agentName).some((entry) => entry.messageGuid === messageGuid && isCompletedProcessedEntry(entry));
 }
 function recordProcessedBlueBubblesMessage(agentName, event, source, outcome) {
     const filePath = getBlueBubblesProcessedLogPath(agentName, event.chat.sessionKey);
     try {
         fs.mkdirSync(path.dirname(filePath), { recursive: true });
-        if (event.messageGuid.trim() && readEntries(filePath).some((entry) => entry.messageGuid === event.messageGuid)) {
+        if (event.messageGuid.trim() && readEntries(filePath).some((entry) => (entry.messageGuid === event.messageGuid
+            && isCompletedProcessedEntry(entry)))) {
             return filePath;
         }
         fs.appendFileSync(filePath, JSON.stringify({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.540",
+  "version": "0.1.0-alpha.542",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",