@ouro.bot/cli 0.1.0-alpha.541 → 0.1.0-alpha.543

package/changelog.json

@@ -1,6 +1,20 @@
 {
   "_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.543",
+      "changes": [
+        "Daemon health-monitor MCP canaries now ignore the daemon's aggregate overview health while still validating MCP transport, daemon liveness, version alignment, and required sense health, preventing the canary's previous failure from keeping the daemon in a self-reinforcing warning state."
+      ]
+    },
+    {
+      "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": [

package/dist/heart/daemon/daemon-entry.js

@@ -146,6 +146,7 @@ const healthMonitor = new health_monitor_1.HealthMonitor({
                 "--socket",
                 socketPath,
             ],
+            ignoreOverviewHealth: true,
         })),
     ],
     alertSink: (message) => {

package/dist/heart/daemon/mcp-canary.js

@@ -97,12 +97,12 @@ function parseMcpStatusText(text) {
     }
     return { daemon, senses, raw: text };
 }
-function validateMcpStatus(parsed, requiredSenses) {
+function validateMcpStatus(parsed, requiredSenses, options = {}) {
     const failures = [];
     if (parsed.daemon.daemon !== "running") {
         failures.push(`daemon=${parsed.daemon.daemon ?? "missing"}`);
     }
-    if (parsed.daemon.health !== "ok") {
+    if (!options.ignoreOverviewHealth && parsed.daemon.health !== "ok") {
         failures.push(`health=${parsed.daemon.health ?? "missing"}`);
     }
     if (parsed.daemon.daemonVersion &&
@@ -131,7 +131,7 @@ function validateMcpStatus(parsed, requiredSenses) {
         .map((row) => `${row.name}:${row.status}`)
         .join(",");
     const summary = failures.length === 0
-        ? `mcp canary ok: daemon=${parsed.daemon.daemon} health=${parsed.daemon.health} senses=${senseSummary}`
+        ? `mcp canary ok: daemon=${parsed.daemon.daemon} health=${parsed.daemon.health}${options.ignoreOverviewHealth ? " (overview ignored)" : ""} senses=${senseSummary}`
         : `mcp canary failed: ${failures.join("; ")}`;
     return {
         ok: failures.length === 0,
@@ -151,7 +151,14 @@ async function runMcpStatusCanary(options) {
         component: "daemon",
         event: "daemon.mcp_canary_start",
         message: "starting MCP status canary",
-        meta: { agent: options.agent, command, commandArgs, timeoutMs, requiredSenses },
+        meta: {
+            agent: options.agent,
+            command,
+            commandArgs,
+            timeoutMs,
+            requiredSenses,
+            ignoreOverviewHealth: options.ignoreOverviewHealth === true,
+        },
     });
     const child = spawnImpl(command, commandArgs, { stdio: ["pipe", "pipe", "pipe"] });
     let buffer = "";
@@ -244,7 +251,9 @@ async function runMcpStatusCanary(options) {
             throw new Error(responseText(statusResponse));
         }
         const parsed = parseMcpStatusText(responseText(statusResponse));
-        const canary = validateMcpStatus(parsed, requiredSenses);
+        const canary = validateMcpStatus(parsed, requiredSenses, {
+            ignoreOverviewHealth: options.ignoreOverviewHealth,
+        });
         (0, runtime_1.emitNervesEvent)({
             component: "daemon",
             event: canary.ok ? "daemon.mcp_canary_end" : "daemon.mcp_canary_error",

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,6 +823,7 @@ 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)
             || (0, processed_log_1.hasProcessedBlueBubblesMessageGuid)(agentName, event.messageGuid)) {
@@ -989,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)({
@@ -1072,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)({
@@ -1087,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 */
@@ -1160,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);
         }
     }
@@ -1237,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.hasProcessedBlueBubblesMessageGuid)(agentName, entry.messageGuid))
-        .length;
-}
-function countPendingCapturedInboundMessages(agentName) {
-    return listPendingCapturedInboundMessages(agentName).length;
-}
 function listPendingCapturedInboundMessages(agentName) {
     const seenMessageGuids = new Set();
     return (0, inbound_log_1.listRecordedBlueBubblesInbound)(agentName)
@@ -1256,6 +1252,30 @@ function listPendingCapturedInboundMessages(agentName) {
     })
         .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)
         return null;
@@ -1280,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.hasProcessedBlueBubblesMessageGuid)(agentName, 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,
     };
@@ -1484,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,
             });
@@ -1505,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",
@@ -1585,14 +1597,12 @@ async function recoverCapturedBlueBubblesInboundMessages(deps = {}) {
             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,
             });
@@ -1605,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",
@@ -1635,14 +1642,12 @@ async function recoverMissedBlueBubblesMessages(deps = {}) {
             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,
             });
@@ -1655,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

@@ -71,22 +71,26 @@ function readAllEntries(agentName) {
         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);
+    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.541",
+  "version": "0.1.0-alpha.543",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",