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

package/changelog.json

@@ -1,6 +1,22 @@
 {
   "_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.545",
+      "changes": [
+        "Launchd-managed habit jobs now inherit the runtime PATH in their plist environment, preventing login-started jobs from failing to find the Node runtime.",
+        "The default daemon starter now launches with the current process executable instead of a bare `node` lookup, so background restarts survive sparse launch contexts.",
+        "Adds regression coverage for restart launch path hardening and mail-import discovery timestamp fallbacks."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.544",
+      "changes": [
+        "BlueBubbles live webhook turns now have a bounded timeout, visible timeout notice, and recoverable captured-message retry path, so a long iMessage turn cannot silently monopolize the live chat lane.",
+        "BlueBubbles runtime health now records active and stalled live turns, exposes them in status output, and marks the sense unhealthy when the listener is reachable but a live iMessage turn is stuck.",
+        "The `ouro bluebubbles replay` debug command now refreshes this machine's BlueBubbles runtime credentials before creating the client, matching the daemon-launched listener's vault-backed configuration."
+      ]
+    },
     {
       "version": "0.1.0-alpha.543",
       "changes": [

package/dist/heart/daemon/cli-defaults.js

@@ -81,7 +81,7 @@ function defaultStartDaemonProcess(socketPath) {
     // when the daemon's logging system writes to stderr after the parent exits.
     const outFd = fs.openSync(os.devNull, "w");
     const errFd = fs.openSync(os.devNull, "w");
-    const child = (0, child_process_1.spawn)("node", [entry, "--socket", socketPath], {
+    const child = (0, child_process_1.spawn)(process.execPath, [entry, "--socket", socketPath], {
         detached: true,
         stdio: ["ignore", outFd, errFd],
     });

package/dist/heart/daemon/cli-render.js

@@ -97,6 +97,14 @@ function formatSenseDetail(row) {
         recoveryParts.push(`oldestPending=${row.oldestPendingRecoveryAt}`);
     if (row.oldestPendingRecoveryAgeMs !== undefined)
         recoveryParts.push(`oldestPendingAge=${formatDurationMs(row.oldestPendingRecoveryAgeMs)}`);
+    if (row.activeTurnCount !== undefined)
+        recoveryParts.push(`activeTurns=${row.activeTurnCount}`);
+    if (row.stalledTurnCount !== undefined)
+        recoveryParts.push(`stalledTurns=${row.stalledTurnCount}`);
+    if (row.oldestActiveTurnStartedAt)
+        recoveryParts.push(`oldestActive=${row.oldestActiveTurnStartedAt}`);
+    if (row.oldestActiveTurnAgeMs !== undefined)
+        recoveryParts.push(`oldestActiveAge=${formatDurationMs(row.oldestActiveTurnAgeMs)}`);
     if (recoveryParts.length > 0)
         details.push(recoveryParts.join(" "));
     const failureParts = [];
@@ -181,6 +189,10 @@ function parseStatusPayload(data) {
         const failedRecoveryCount = numberField(row.failedRecoveryCount);
         const oldestPendingRecoveryAt = stringField(row.oldestPendingRecoveryAt);
         const oldestPendingRecoveryAgeMs = numberField(row.oldestPendingRecoveryAgeMs);
+        const activeTurnCount = numberField(row.activeTurnCount);
+        const stalledTurnCount = numberField(row.stalledTurnCount);
+        const oldestActiveTurnStartedAt = stringField(row.oldestActiveTurnStartedAt);
+        const oldestActiveTurnAgeMs = numberField(row.oldestActiveTurnAgeMs);
         if (proofMethod !== null)
             parsed.proofMethod = proofMethod;
         if (lastProofAt !== null)
@@ -201,6 +213,14 @@ function parseStatusPayload(data) {
             parsed.oldestPendingRecoveryAt = oldestPendingRecoveryAt;
         if (oldestPendingRecoveryAgeMs !== null)
             parsed.oldestPendingRecoveryAgeMs = oldestPendingRecoveryAgeMs;
+        if (activeTurnCount !== null)
+            parsed.activeTurnCount = activeTurnCount;
+        if (stalledTurnCount !== null)
+            parsed.stalledTurnCount = stalledTurnCount;
+        if (oldestActiveTurnStartedAt !== null)
+            parsed.oldestActiveTurnStartedAt = oldestActiveTurnStartedAt;
+        if (oldestActiveTurnAgeMs !== null)
+            parsed.oldestActiveTurnAgeMs = oldestActiveTurnAgeMs;
         return parsed;
     });
     const parsedWorkers = workers.map((entry) => {

package/dist/heart/daemon/os-cron-deps.js

@@ -77,6 +77,7 @@ function createRealOsCronDeps() {
         },
         mkdirp: (dir) => fs.mkdirSync(dir, { recursive: true }),
         homeDir: os.homedir(),
+        envPath: process.env.PATH ?? "",
     };
 }
 function createRealCrontabDeps() {

package/dist/heart/daemon/os-cron.js

@@ -80,7 +80,7 @@ function scheduleToCalendarInterval(schedule) {
         result.Month = parseInt(month, 10);
     return Object.keys(result).length > 0 ? result : null;
 }
-function generatePlistXml(job) {
+function generatePlistXml(job, envPath) {
     const label = plistLabel(job);
     const seconds = cadenceToSeconds(job.schedule);
     const calendar = seconds === null ? scheduleToCalendarInterval(job.schedule) : null;
@@ -97,7 +97,7 @@ function generatePlistXml(job) {
     else {
         triggerXml = `  <key>StartInterval</key>\n  <integer>1800</integer>`;
     }
-    return [
+    const lines = [
         `<?xml version="1.0" encoding="UTF-8"?>`,
         `<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">`,
         `<plist version="1.0">`,
@@ -110,14 +110,12 @@ function generatePlistXml(job) {
         ...job.command.split(" ").slice(1).map((arg) => `    <string>${arg}</string>`),
         `  </array>`,
         triggerXml,
-        `  <key>StandardOutPath</key>`,
-        `  <string>/tmp/${label}.stdout.log</string>`,
-        `  <key>StandardErrorPath</key>`,
-        `  <string>/tmp/${label}.stderr.log</string>`,
-        `</dict>`,
-        `</plist>`,
-        ``,
-    ].join("\n");
+    ];
+    if (envPath) {
+        lines.push(`  <key>EnvironmentVariables</key>`, `  <dict>`, `    <key>PATH</key>`, `    <string>${envPath}</string>`, `  </dict>`);
+    }
+    lines.push(`  <key>StandardOutPath</key>`, `  <string>/tmp/${label}.stdout.log</string>`, `  <key>StandardErrorPath</key>`, `  <string>/tmp/${label}.stderr.log</string>`, `</dict>`, `</plist>`, ``);
+    return lines.join("\n");
 }
 class LaunchdCronManager {
     deps;
@@ -148,7 +146,7 @@ class LaunchdCronManager {
             const label = plistLabel(job);
             const filename = `${label}.plist`;
             const fullPath = `${this.launchAgentsDir}/${filename}`;
-            const xml = generatePlistXml(job);
+            const xml = generatePlistXml(job, this.deps.envPath);
             try {
                 this.deps.exec(`launchctl unload "${fullPath}"`);
             }
@@ -248,6 +246,7 @@ function createOsCronManager(options = {}) {
             listDir: () => [],
             mkdirp: () => { },
             homeDir: os.homedir(),
+            envPath: process.env.PATH ?? "",
         };
         /* v8 ignore stop */
         return new LaunchdCronManager(deps);

package/dist/heart/daemon/sense-manager.js

@@ -279,6 +279,16 @@ function readBlueBubblesRuntimeJson(runtimePath) {
             oldestPendingRecoveryAgeMs: typeof parsed.oldestPendingRecoveryAgeMs === "number" && Number.isFinite(parsed.oldestPendingRecoveryAgeMs)
                 ? parsed.oldestPendingRecoveryAgeMs
                 : undefined,
+            activeTurnCount: typeof parsed.activeTurnCount === "number" && Number.isFinite(parsed.activeTurnCount)
+                ? parsed.activeTurnCount
+                : undefined,
+            stalledTurnCount: typeof parsed.stalledTurnCount === "number" && Number.isFinite(parsed.stalledTurnCount)
+                ? parsed.stalledTurnCount
+                : undefined,
+            oldestActiveTurnStartedAt: typeof parsed.oldestActiveTurnStartedAt === "string" ? parsed.oldestActiveTurnStartedAt : undefined,
+            oldestActiveTurnAgeMs: typeof parsed.oldestActiveTurnAgeMs === "number" && Number.isFinite(parsed.oldestActiveTurnAgeMs)
+                ? parsed.oldestActiveTurnAgeMs
+                : undefined,
         };
         /* v8 ignore stop */
         /* v8 ignore start -- defensive: catch for missing/corrupt BB runtime state file @preserve */
@@ -304,6 +314,10 @@ function readBlueBubblesRuntimeFacts(agent, bundlesRoot, snapshot) {
         failedRecoveryCount: state.failedRecoveryCount,
         oldestPendingRecoveryAt: state.oldestPendingRecoveryAt,
         oldestPendingRecoveryAgeMs: state.oldestPendingRecoveryAgeMs,
+        activeTurnCount: state.activeTurnCount,
+        stalledTurnCount: state.stalledTurnCount,
+        oldestActiveTurnStartedAt: state.oldestActiveTurnStartedAt,
+        oldestActiveTurnAgeMs: state.oldestActiveTurnAgeMs,
     };
     if (!blueBubblesRuntimeStateIsFresh(state.lastCheckedAt)) {
         return {
@@ -342,6 +356,16 @@ function readBlueBubblesRuntimeFacts(agent, bundlesRoot, snapshot) {
             recoveryAction: "queued recovery will retry; inspect BlueBubbles inbound/recovery sidecar logs if age keeps growing",
         };
     }
+    if ((state.stalledTurnCount ?? 0) > 0) {
+        return {
+            runtime: "error",
+            detail: state.detail,
+            ...proofFacts,
+            lastFailure: state.detail,
+            failureLayer: "live_turn_stall",
+            recoveryAction: "live iMessage turn timeout/watchdog will release the lane and recovery will retry captured messages",
+        };
+    }
     if (state.upstreamStatus === "ok") {
         return {
             runtime: "running",
@@ -573,6 +597,10 @@ class DaemonSenseManager {
                     failedRecoveryCount: blueBubblesRuntimeFacts.failedRecoveryCount,
                     oldestPendingRecoveryAt: blueBubblesRuntimeFacts.oldestPendingRecoveryAt,
                     oldestPendingRecoveryAgeMs: blueBubblesRuntimeFacts.oldestPendingRecoveryAgeMs,
+                    activeTurnCount: blueBubblesRuntimeFacts.activeTurnCount,
+                    stalledTurnCount: blueBubblesRuntimeFacts.stalledTurnCount,
+                    oldestActiveTurnStartedAt: blueBubblesRuntimeFacts.oldestActiveTurnStartedAt,
+                    oldestActiveTurnAgeMs: blueBubblesRuntimeFacts.oldestActiveTurnAgeMs,
                 } : {}),
             }));
         });

package/dist/senses/bluebubbles/active-turns.js

@@ -0,0 +1,216 @@
+"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.beginBlueBubblesActiveTurn = beginBlueBubblesActiveTurn;
+exports.noteBlueBubblesActiveTurnVisibleActivity = noteBlueBubblesActiveTurnVisibleActivity;
+exports.finishBlueBubblesActiveTurn = finishBlueBubblesActiveTurn;
+exports.listBlueBubblesActiveTurns = listBlueBubblesActiveTurns;
+exports.snapshotBlueBubblesActiveTurns = snapshotBlueBubblesActiveTurns;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const config_1 = require("../../heart/config");
+const identity_1 = require("../../heart/identity");
+const runtime_1 = require("../../nerves/runtime");
+function activeTurnsDir(agentName) {
+    return path.join((0, identity_1.getAgentRoot)(agentName), "state", "senses", "bluebubbles", "active-turns");
+}
+function activeTurnPath(agentName, turnId) {
+    return path.join(activeTurnsDir(agentName), `${(0, config_1.sanitizeKey)(turnId)}.json`);
+}
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function parseActiveTurn(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed.turnId || !parsed.messageGuid || !parsed.sessionKey || !parsed.startedAt)
+            return null;
+        if (typeof parsed.pid !== "number")
+            return null;
+        return {
+            turnId: parsed.turnId,
+            pid: parsed.pid,
+            startedAt: parsed.startedAt,
+            lastVisibleActivityAt: typeof parsed.lastVisibleActivityAt === "string"
+                ? parsed.lastVisibleActivityAt
+                : undefined,
+            messageGuid: parsed.messageGuid,
+            sessionKey: parsed.sessionKey,
+            chatGuid: parsed.chatGuid ?? null,
+            chatIdentifier: parsed.chatIdentifier ?? null,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function beginBlueBubblesActiveTurn(agentName, event) {
+    const turnId = `${event.chat.sessionKey}:${event.messageGuid}:${process.pid}`;
+    const entry = {
+        turnId,
+        pid: process.pid,
+        startedAt: new Date().toISOString(),
+        messageGuid: event.messageGuid,
+        sessionKey: event.chat.sessionKey,
+        chatGuid: event.chat.chatGuid ?? null,
+        chatIdentifier: event.chat.chatIdentifier ?? null,
+    };
+    const filePath = activeTurnPath(agentName, turnId);
+    try {
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, JSON.stringify(entry, null, 2) + "\n", "utf-8");
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.bluebubbles_active_turn_write_error",
+            message: "failed to record active bluebubbles turn",
+            meta: {
+                agentName,
+                messageGuid: event.messageGuid,
+                sessionKey: event.chat.sessionKey,
+                /* v8 ignore next -- filesystem writes throw Error instances; stringify guard is defensive @preserve */
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+    }
+    return turnId;
+}
+function noteBlueBubblesActiveTurnVisibleActivity(agentName, turnId) {
+    const filePath = activeTurnPath(agentName, turnId);
+    let entry = null;
+    try {
+        entry = parseActiveTurn(fs.readFileSync(filePath, "utf-8"));
+    }
+    catch {
+        return;
+    }
+    if (!entry)
+        return;
+    try {
+        fs.writeFileSync(filePath, JSON.stringify({ ...entry, lastVisibleActivityAt: new Date().toISOString() }, null, 2) + "\n", "utf-8");
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.bluebubbles_active_turn_write_error",
+            message: "failed to update active bluebubbles turn",
+            meta: {
+                agentName,
+                turnId,
+                /* v8 ignore next -- filesystem writes throw Error instances; stringify guard is defensive @preserve */
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+    }
+}
+function finishBlueBubblesActiveTurn(agentName, turnId) {
+    try {
+        fs.unlinkSync(activeTurnPath(agentName, turnId));
+    }
+    catch {
+        // Missing active-turn files are harmless: this is best-effort telemetry.
+    }
+}
+function listBlueBubblesActiveTurns(agentName) {
+    let files;
+    try {
+        files = fs.readdirSync(activeTurnsDir(agentName)).filter((name) => name.endsWith(".json")).sort();
+    }
+    catch {
+        return [];
+    }
+    const entries = [];
+    for (const file of files) {
+        const filePath = path.join(activeTurnsDir(agentName), file);
+        let entry = null;
+        try {
+            entry = parseActiveTurn(fs.readFileSync(filePath, "utf-8"));
+        }
+        catch {
+            entry = null;
+        }
+        if (!entry) {
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { /* ignore corrupt cleanup races */ }
+            continue;
+        }
+        if (!isPidAlive(entry.pid)) {
+            try {
+                fs.unlinkSync(filePath);
+            }
+            catch { /* ignore stale cleanup races */ }
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.bluebubbles_active_turn_pruned",
+                message: "pruned stale bluebubbles active-turn marker",
+                meta: {
+                    agentName,
+                    messageGuid: entry.messageGuid,
+                    sessionKey: entry.sessionKey,
+                    pid: entry.pid,
+                },
+            });
+            continue;
+        }
+        entries.push(entry);
+    }
+    return entries;
+}
+function snapshotBlueBubblesActiveTurns(agentName, stalledAfterMs, nowMs = Date.now()) {
+    const entries = listBlueBubblesActiveTurns(agentName);
+    const started = entries
+        .map((entry) => ({ value: entry.startedAt, ms: Date.parse(entry.startedAt) }))
+        .filter((entry) => Number.isFinite(entry.ms))
+        .sort((left, right) => left.ms - right.ms);
+    const oldest = started[0];
+    return {
+        activeTurnCount: entries.length,
+        stalledTurnCount: started.filter((entry) => nowMs - entry.ms >= stalledAfterMs).length,
+        oldestActiveTurnStartedAt: oldest?.value,
+        oldestActiveTurnAgeMs: oldest ? Math.max(0, nowMs - oldest.ms) : undefined,
+    };
+}

package/dist/senses/bluebubbles/index.js

@@ -76,6 +76,7 @@ const mutation_log_1 = require("./mutation-log");
 const processed_log_1 = require("./processed-log");
 const runtime_state_1 = require("./runtime-state");
 const session_cleanup_1 = require("./session-cleanup");
+const active_turns_1 = require("./active-turns");
 const tool_activity_callbacks_1 = require("../../heart/tool-activity-callbacks");
 const commands_1 = require("../commands");
 const trust_gate_1 = require("../trust-gate");
@@ -170,7 +171,10 @@ 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_LIVE_TURN_TIMEOUT_MS = 2 * 60_000;
 const BLUEBUBBLES_RECOVERY_TURN_TIMEOUT_MS = 10 * 60_000;
+const BLUEBUBBLES_LIVE_TURN_STALLED_MS = 90_000;
+const BLUEBUBBLES_SILENCE_WATCHDOG_MS = 75_000;
 const BLUEBUBBLES_CATCHUP_PAGE_SIZE = 50;
 const BLUEBUBBLES_CATCHUP_MAX_PAGES = 20;
 const BLUEBUBBLES_HEALTHY_CATCHUP_OVERLAP_MS = 90_000;
@@ -447,10 +451,12 @@ function emitBlueBubblesMarkReadWarning(chat, error) {
         },
     });
 }
-function createBlueBubblesCallbacks(client, chat, replyTarget, isGroupChat) {
+function createBlueBubblesCallbacks(client, chat, replyTarget, isGroupChat, onVisibleActivity) {
     let textBuffer = "";
     let typingActive = false;
     let queue = Promise.resolve();
+    let lastVisibleActivityMs = Date.now();
+    let silenceWatchdog = null;
     function enqueue(operation, task) {
         queue = queue.then(task).catch((error) => {
             (0, runtime_1.emitNervesEvent)({
@@ -480,6 +486,29 @@ function createBlueBubblesCallbacks(client, chat, replyTarget, isGroupChat) {
             }
         });
     }
+    function recordVisibleActivity() {
+        lastVisibleActivityMs = Date.now();
+        onVisibleActivity?.();
+    }
+    function stopSilenceWatchdog() {
+        if (silenceWatchdog === null)
+            return;
+        clearInterval(silenceWatchdog);
+        silenceWatchdog = null;
+    }
+    function startSilenceWatchdog() {
+        if (silenceWatchdog !== null)
+            return;
+        silenceWatchdog = setInterval(() => {
+            if (Date.now() - lastVisibleActivityMs < BLUEBUBBLES_SILENCE_WATCHDOG_MS)
+                return;
+            sendStatus("still working on this...");
+        }, BLUEBUBBLES_SILENCE_WATCHDOG_MS);
+        /* v8 ignore next -- timer handles expose unref only in some runtimes @preserve */
+        if (typeof silenceWatchdog.unref === "function") {
+            silenceWatchdog.unref();
+        }
+    }
     function sendStatus(text) {
         enqueue("send_status", async () => {
             await client.sendText({
@@ -487,6 +516,7 @@ function createBlueBubblesCallbacks(client, chat, replyTarget, isGroupChat) {
                 text,
                 replyToMessageGuid: replyTarget.getReplyToMessageGuid(),
             });
+            recordVisibleActivity();
             // Re-enable typing indicator — sending a message clears the typing bubble
             await client.setTyping(chat, true);
         });
@@ -502,6 +532,7 @@ function createBlueBubblesCallbacks(client, chat, replyTarget, isGroupChat) {
     });
     return {
         onModelStart() {
+            startSilenceWatchdog();
             if (!isGroupChat)
                 startTypingNow();
             (0, runtime_1.emitNervesEvent)({
@@ -590,6 +621,7 @@ function createBlueBubblesCallbacks(client, chat, replyTarget, isGroupChat) {
                 text: trimmed,
                 replyToMessageGuid: replyTarget.getReplyToMessageGuid(),
             });
+            recordVisibleActivity();
             // Note: do NOT call client.setTyping(chat, false) here — the agent is
             // still mid-turn, so the typing indicator stays ACTIVE.
             (0, runtime_1.emitNervesEvent)({
@@ -623,8 +655,10 @@ function createBlueBubblesCallbacks(client, chat, replyTarget, isGroupChat) {
                 text: trimmed,
                 replyToMessageGuid: replyTarget.getReplyToMessageGuid(),
             });
+            recordVisibleActivity();
         },
         async finish() {
+            stopSilenceWatchdog();
             statusBatcher.flush();
             if (!typingActive) {
                 await queue;
@@ -824,6 +858,7 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source, opt
     }
     let ownsInFlightMessage = false;
     let releaseInFlightAfterTurnSettles = false;
+    let activeTurnId = null;
     if (event.kind === "message") {
         if ((0, processed_log_1.hasProcessedBlueBubblesMessage)(agentName, event.chat.sessionKey, event.messageGuid)
             || (0, processed_log_1.hasProcessedBlueBubblesMessageGuid)(agentName, event.messageGuid)) {
@@ -855,6 +890,7 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source, opt
             return { handled: true, notifiedAgent: false, kind: event.kind, reason: "already_processed" };
         }
         ownsInFlightMessage = true;
+        activeTurnId = (0, active_turns_1.beginBlueBubblesActiveTurn)(agentName, event);
     }
     try {
         // ── Adapter setup: friend, session, content, callbacks ──────────
@@ -945,10 +981,12 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source, opt
                 role: "user",
                 content: buildInboundContent(event, existing?.messages ?? sessionMessages, repliedToText),
             };
-            const callbacks = createBlueBubblesCallbacks(client, event.chat, replyTarget, event.chat.isGroup);
+            const callbacks = createBlueBubblesCallbacks(client, event.chat, replyTarget, event.chat.isGroup, activeTurnId
+                ? () => (0, active_turns_1.noteBlueBubblesActiveTurnVisibleActivity)(agentName, activeTurnId)
+                : undefined);
             const controller = new AbortController();
-            let timeoutTimer = null;
-            let timeoutPromise = null;
+            let timeoutTimer;
+            let timeoutPromise;
             let timeoutReject;
             let recoveryTimedOut = false;
             // BB-specific tool context wrappers
@@ -978,34 +1016,39 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source, opt
             };
             /* v8 ignore stop */
             try {
-                const timeoutMs = options.timeoutMs;
-                if (typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0) {
-                    timeoutPromise = new Promise((_, reject) => {
-                        timeoutReject = reject;
-                    });
-                    timeoutTimer = setTimeout(() => {
-                        const reason = new BlueBubblesRecoveryTurnTimeoutError(timeoutMs);
-                        recoveryTimedOut = true;
+                const liveWebhookTimeout = source === "webhook" && options.timeoutMs === undefined;
+                const timeoutMs = options.timeoutMs ?? BLUEBUBBLES_LIVE_TURN_TIMEOUT_MS;
+                timeoutPromise = new Promise((_, reject) => {
+                    timeoutReject = reject;
+                });
+                timeoutTimer = setTimeout(() => {
+                    const reason = new BlueBubblesRecoveryTurnTimeoutError(timeoutMs);
+                    recoveryTimedOut = true;
+                    if (liveWebhookTimeout && ownsInFlightMessage && event.kind === "message") {
+                        endBlueBubblesMessageInFlight(event.chat.sessionKey, event.messageGuid);
+                        ownsInFlightMessage = false;
+                    }
+                    else {
                         releaseInFlightAfterTurnSettles = true;
-                        controller.abort(reason);
-                        timeoutReject?.(reason);
-                        (0, runtime_1.emitNervesEvent)({
-                            level: "warn",
-                            component: "senses",
-                            event: "senses.bluebubbles_turn_timeout",
-                            message: "bluebubbles recovery turn timed out",
-                            meta: {
-                                messageGuid: event.messageGuid,
-                                sessionKey: event.chat.sessionKey,
-                                source,
-                                timeoutMs,
-                            },
-                        });
-                    }, timeoutMs);
-                    /* v8 ignore next -- timer handles expose unref only in some runtimes @preserve */
-                    if (typeof timeoutTimer.unref === "function") {
-                        timeoutTimer.unref();
                     }
+                    controller.abort(reason);
+                    timeoutReject?.(reason);
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "warn",
+                        component: "senses",
+                        event: "senses.bluebubbles_turn_timeout",
+                        message: "bluebubbles turn timed out",
+                        meta: {
+                            messageGuid: event.messageGuid,
+                            sessionKey: event.chat.sessionKey,
+                            source,
+                            timeoutMs,
+                        },
+                    });
+                }, timeoutMs);
+                /* v8 ignore next -- timer handles expose unref only in some runtimes @preserve */
+                if (typeof timeoutTimer.unref === "function") {
+                    timeoutTimer.unref();
                 }
                 const turnPromise = (0, pipeline_1.handleInboundTurn)({
                     channel: "bluebubbles",
@@ -1069,34 +1112,40 @@ 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) => {
-                        if (!recoveryTimedOut)
-                            return;
-                        (0, runtime_1.emitNervesEvent)({
-                            level: "warn",
-                            component: "senses",
-                            event: "senses.bluebubbles_recovery_error",
-                            message: "bluebubbles recovery turn rejected after timeout",
-                            meta: {
-                                messageGuid: event.messageGuid,
-                                sessionKey: event.chat.sessionKey,
-                                source,
-                                reason: error instanceof Error ? error.message : String(error),
-                            },
-                        });
-                    })
-                        .finally(() => {
-                        if (releaseInFlightAfterTurnSettles && ownsInFlightMessage && event.kind === "message") {
-                            endBlueBubblesMessageInFlight(event.chat.sessionKey, event.messageGuid);
-                        }
+                void turnPromise
+                    .catch((error) => {
+                    if (!recoveryTimedOut)
+                        return;
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "warn",
+                        component: "senses",
+                        event: "senses.bluebubbles_recovery_error",
+                        message: "bluebubbles recovery turn rejected after timeout",
+                        meta: {
+                            messageGuid: event.messageGuid,
+                            sessionKey: event.chat.sessionKey,
+                            source,
+                            reason: error instanceof Error ? error.message : String(error),
+                        },
                     });
-                }
+                })
+                    .finally(() => {
+                    if (releaseInFlightAfterTurnSettles && ownsInFlightMessage && event.kind === "message") {
+                        endBlueBubblesMessageInFlight(event.chat.sessionKey, event.messageGuid);
+                    }
+                });
                 /* v8 ignore stop */
-                const result = timeoutPromise
-                    ? await Promise.race([turnPromise, timeoutPromise])
-                    : await turnPromise;
+                const result = await (async () => {
+                    try {
+                        return await Promise.race([turnPromise, timeoutPromise]);
+                    }
+                    catch (error) {
+                        if (error instanceof BlueBubblesRecoveryTurnTimeoutError) {
+                            callbacks.onError(new Error("live iMessage turn timed out; I captured it for recovery instead of silently hanging"), "terminal");
+                        }
+                        throw error;
+                    }
+                })();
                 /* v8 ignore start -- failover display + error replay @preserve */
                 if (result.failoverMessage) {
                     // Failover handled it — show the failover message, skip the buffered error
@@ -1155,15 +1204,14 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source, opt
                     bufferedTerminalError = null;
                 }
                 /* v8 ignore stop */
-                if (timeoutTimer !== null) {
-                    clearTimeout(timeoutTimer);
-                    timeoutTimer = null;
-                }
+                clearTimeout(timeoutTimer);
                 await callbacks.finish();
             }
         });
     }
     finally {
+        if (activeTurnId)
+            (0, active_turns_1.finishBlueBubblesActiveTurn)(agentName, activeTurnId);
         if (ownsInFlightMessage && event.kind === "message" && !releaseInFlightAfterTurnSettles) {
             endBlueBubblesMessageInFlight(event.chat.sessionKey, event.messageGuid);
         }
@@ -1292,7 +1340,12 @@ function resolveBlueBubblesCatchUpSince(previousState, nowMs = Date.now()) {
     }
     return nowMs - BLUEBUBBLES_FIRST_CATCHUP_LOOKBACK_MS;
 }
-function formatBlueBubblesRuntimeDetail(queued, failed) {
+function formatBlueBubblesRuntimeDetail(queued, failed, active) {
+    if (active.stalledTurnCount > 0) {
+        return `iMessage live turn appears stalled; ${active.stalledTurnCount} active turn(s) older than ${BLUEBUBBLES_LIVE_TURN_STALLED_MS}ms`;
+    }
+    if (active.activeTurnCount > 0)
+        return `upstream reachable; ${active.activeTurnCount} live turn(s) active`;
     if (queued > 0)
         return `upstream reachable but iMessage is not caught up; ${queued} recovery item(s) queued`;
     if (failed > 0)
@@ -1322,12 +1375,14 @@ async function syncBlueBubblesRuntime(deps = {}) {
     try {
         await client.checkHealth();
         const pendingBeforeCatchup = blueBubblesPendingRecoverySnapshot(agentName);
+        const activeBeforeCatchup = (0, active_turns_1.snapshotBlueBubblesActiveTurns)(agentName, BLUEBUBBLES_LIVE_TURN_STALLED_MS);
         (0, runtime_state_1.writeBlueBubblesRuntimeState)(agentName, {
             upstreamStatus: "ok",
             detail: "upstream reachable; recovery pass running",
             lastCheckedAt: checkedAt,
             proofMethod: "bluebubbles.checkHealth",
             ...pendingBeforeCatchup,
+            ...activeBeforeCatchup,
             lastRecoveredAt: previousState.lastRecoveredAt,
             lastRecoveredMessageGuid: previousState.lastRecoveredMessageGuid,
         });
@@ -1336,6 +1391,7 @@ async function syncBlueBubblesRuntime(deps = {}) {
         });
         const failed = catchUp.failed;
         const pendingAfterCatchup = blueBubblesPendingRecoverySnapshot(agentName);
+        const activeAfterCatchup = (0, active_turns_1.snapshotBlueBubblesActiveTurns)(agentName, BLUEBUBBLES_LIVE_TURN_STALLED_MS);
         const queued = pendingAfterCatchup.pendingRecoveryCount;
         // upstreamStatus reflects whether BlueBubbles itself and the local bridge
         // can answer webhook traffic. The daemon status layer treats
@@ -1343,10 +1399,11 @@ async function syncBlueBubblesRuntime(deps = {}) {
         // while this field stays scoped to upstream transport reachability.
         (0, runtime_state_1.writeBlueBubblesRuntimeState)(agentName, {
             upstreamStatus: "ok",
-            detail: formatBlueBubblesRuntimeDetail(queued, failed),
+            detail: formatBlueBubblesRuntimeDetail(queued, failed, activeAfterCatchup),
             lastCheckedAt: checkedAt,
             proofMethod: "bluebubbles.checkHealth",
             ...pendingAfterCatchup,
+            ...activeAfterCatchup,
             pendingRecoveryCount: queued,
             failedRecoveryCount: failed,
             lastRecoveredAt: previousState.lastRecoveredAt,
@@ -1360,6 +1417,7 @@ async function syncBlueBubblesRuntime(deps = {}) {
             lastCheckedAt: checkedAt,
             proofMethod: "bluebubbles.checkHealth",
             ...blueBubblesPendingRecoverySnapshot(agentName),
+            ...(0, active_turns_1.snapshotBlueBubblesActiveTurns)(agentName, BLUEBUBBLES_LIVE_TURN_STALLED_MS),
             failedRecoveryCount: 0,
         });
     }
@@ -1382,12 +1440,14 @@ async function recoverQueuedBlueBubblesMessages(deps = {}) {
     const checkedAt = new Date().toISOString();
     try {
         await resolvedDeps.createClient().checkHealth();
+        const activeSnapshot = (0, active_turns_1.snapshotBlueBubblesActiveTurns)(agentName, BLUEBUBBLES_LIVE_TURN_STALLED_MS);
         (0, runtime_state_1.writeBlueBubblesRuntimeState)(agentName, {
             upstreamStatus: "ok",
-            detail: formatBlueBubblesRuntimeDetail(pendingRecoveryCount, failed),
+            detail: formatBlueBubblesRuntimeDetail(pendingRecoveryCount, failed, activeSnapshot),
             lastCheckedAt: checkedAt,
             proofMethod: "bluebubbles.checkHealth",
             ...pendingSnapshot,
+            ...activeSnapshot,
             failedRecoveryCount: failed,
             lastRecoveredAt: recovered > 0 ? checkedAt : previousState.lastRecoveredAt,
             lastRecoveredMessageGuid: previousState.lastRecoveredMessageGuid,
@@ -1400,6 +1460,7 @@ async function recoverQueuedBlueBubblesMessages(deps = {}) {
             lastCheckedAt: checkedAt,
             proofMethod: "bluebubbles.checkHealth",
             ...pendingSnapshot,
+            ...(0, active_turns_1.snapshotBlueBubblesActiveTurns)(agentName, BLUEBUBBLES_LIVE_TURN_STALLED_MS),
             failedRecoveryCount: failed,
             lastRecoveredAt: recovered > 0 ? checkedAt : previousState.lastRecoveredAt,
             lastRecoveredMessageGuid: previousState.lastRecoveredMessageGuid,

package/dist/senses/bluebubbles/replay.js

@@ -4,7 +4,9 @@ exports.replayBlueBubblesMessage = replayBlueBubblesMessage;
 exports.formatBlueBubblesReplayText = formatBlueBubblesReplayText;
 const render_1 = require("../../heart/attachments/render");
 const bluebubbles_1 = require("../../heart/attachments/sources/bluebubbles");
+const machine_identity_1 = require("../../heart/machine-identity");
 const identity_1 = require("../../heart/identity");
+const runtime_credentials_1 = require("../../heart/runtime-credentials");
 const runtime_1 = require("../../nerves/runtime");
 const client_1 = require("./client");
 const model_1 = require("./model");
@@ -29,6 +31,8 @@ async function replayBlueBubblesMessage(params, deps = {}) {
     const setReplayAgentName = deps.setAgentName ?? identity_1.setAgentName;
     const resetReplayIdentity = deps.resetIdentity ?? identity_1.resetIdentity;
     const normalizeEvent = deps.normalizeEvent ?? model_1.normalizeBlueBubblesEvent;
+    const loadMachineId = deps.loadMachineId ?? (() => (0, machine_identity_1.loadOrCreateMachineIdentity)().machineId);
+    const refreshMachineRuntimeConfig = deps.refreshMachineRuntimeConfig ?? runtime_credentials_1.refreshMachineRuntimeCredentialConfig;
     (0, runtime_1.emitNervesEvent)({
         component: "senses",
         event: "senses.bluebubbles_replay_start",
@@ -41,6 +45,10 @@ async function replayBlueBubblesMessage(params, deps = {}) {
     });
     setReplayAgentName(agentName);
     try {
+        if (!deps.createClient) {
+            const machineId = loadMachineId();
+            await refreshMachineRuntimeConfig(agentName, machineId, { preserveCachedOnFailure: true });
+        }
         const client = deps.createClient ? deps.createClient() : (0, client_1.createBlueBubblesClient)();
         const probe = normalizeEvent({
             type: eventType,

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

@@ -77,6 +77,18 @@ function readBlueBubblesRuntimeState(agentName, agentRoot) {
             oldestPendingRecoveryAgeMs: typeof parsed.oldestPendingRecoveryAgeMs === "number" && Number.isFinite(parsed.oldestPendingRecoveryAgeMs)
                 ? parsed.oldestPendingRecoveryAgeMs
                 : undefined,
+            activeTurnCount: typeof parsed.activeTurnCount === "number" && Number.isFinite(parsed.activeTurnCount)
+                ? parsed.activeTurnCount
+                : undefined,
+            stalledTurnCount: typeof parsed.stalledTurnCount === "number" && Number.isFinite(parsed.stalledTurnCount)
+                ? parsed.stalledTurnCount
+                : undefined,
+            oldestActiveTurnStartedAt: typeof parsed.oldestActiveTurnStartedAt === "string"
+                ? parsed.oldestActiveTurnStartedAt
+                : undefined,
+            oldestActiveTurnAgeMs: typeof parsed.oldestActiveTurnAgeMs === "number" && Number.isFinite(parsed.oldestActiveTurnAgeMs)
+                ? parsed.oldestActiveTurnAgeMs
+                : undefined,
             lastRecoveredAt: typeof parsed.lastRecoveredAt === "string" ? parsed.lastRecoveredAt : undefined,
             lastRecoveredMessageGuid: typeof parsed.lastRecoveredMessageGuid === "string"
                 ? parsed.lastRecoveredMessageGuid
@@ -116,6 +128,8 @@ function writeBlueBubblesRuntimeState(agentName, state, agentRoot) {
             upstreamStatus: state.upstreamStatus,
             pendingRecoveryCount: state.pendingRecoveryCount,
             failedRecoveryCount: state.failedRecoveryCount ?? 0,
+            activeTurnCount: state.activeTurnCount ?? 0,
+            stalledTurnCount: state.stalledTurnCount ?? 0,
             path: filePath,
         },
     });

package/package.json

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