@ouro.bot/cli 0.1.0-alpha.44 → 0.1.0-alpha.46

package/changelog.json

@@ -1,6 +1,27 @@
 {
   "_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.46",
+      "changes": [
+        "Inner dialog now knows which task triggered it: taskId flows from daemon poke through the worker into the turn, and the agent gets the full task file content instead of a generic heartbeat prompt.",
+        "Inner dialog boot message includes aspirations and state summary instead of a vacuous placeholder, so the agent wakes up with context about what matters and what's happening.",
+        "Vestigial `drainInbox` removed from inner dialog — pipeline already handles pending drain correctly.",
+        "Inner dialog nerves events now include assistant response preview, tool call names, token usage, and taskId for meaningful observability.",
+        "`ouro thoughts` command reads and formats inner dialog session turns with `--last`, `--json`, `--follow`, and `--agent` flags — humans can now see what the agent has been thinking.",
+        "`readTaskFile` searches collection subdirectories (one-shots, ongoing, habits) since the scheduler sends bare task stems without collection prefixes.",
+        "`ouro reminder create` accepts `--requester` to track who requested a reminder for notification round-trip.",
+        "Response extraction handles `tool_choice=required` models by falling back to `final_answer` tool call arguments when assistant message content is empty."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.45",
+      "changes": [
+        "`ouro up` now persists a boot-time launch agent with `RunAtLoad`, so the daemon comes back reliably after reboot instead of only starting for the current session.",
+        "BlueBubbles sense status is now truthful about upstream health: it probes the real BlueBubbles API, records runtime state, and surfaces `error` when the webhook listener is alive but the upstream server is unreachable.",
+        "BlueBubbles intake now replays recoverable read/delivery mutation backlogs through the normal inbound agent path, with a small dedupe ledger so missed messages can be recovered without silent drops or duplicate delivery."
+      ]
+    },
     {
       "version": "0.1.0-alpha.44",
       "changes": [

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

@@ -62,7 +62,9 @@ const update_hooks_1 = require("./update-hooks");
 const bundle_meta_1 = require("./hooks/bundle-meta");
 const bundle_manifest_1 = require("../../mind/bundle-manifest");
 const tasks_1 = require("../../repertoire/tasks");
+const thoughts_1 = require("./thoughts");
 const ouro_bot_global_installer_1 = require("./ouro-bot-global-installer");
+const launchd_1 = require("./launchd");
 function stringField(value) {
     return typeof value === "string" ? value : null;
 }
@@ -257,6 +259,7 @@ function usage() {
         "  ouro friend list [--agent <name>]",
         "  ouro friend show <id> [--agent <name>]",
         "  ouro friend create --name <name> [--trust <level>] [--agent <name>]",
+        "  ouro thoughts [--last <n>] [--json] [--follow] [--agent <name>]",
         "  ouro friend link <agent> --friend <id> --provider <p> --external-id <eid>",
         "  ouro friend unlink <agent> --friend <id> --provider <p> --external-id <eid>",
         "  ouro whoami [--agent <name>]",
@@ -519,6 +522,7 @@ function parseReminderCommand(args) {
         let scheduledAt;
         let cadence;
         let category;
+        let requester;
         for (let i = 1; i < rest.length; i++) {
             if (rest[i] === "--body" && rest[i + 1]) {
                 body = rest[i + 1];
@@ -536,6 +540,10 @@ function parseReminderCommand(args) {
                 category = rest[i + 1];
                 i += 1;
             }
+            else if (rest[i] === "--requester" && rest[i + 1]) {
+                requester = rest[i + 1];
+                i += 1;
+            }
         }
         if (!body)
             throw new Error(`Usage\n${usage()}`);
@@ -548,6 +556,7 @@ function parseReminderCommand(args) {
             ...(scheduledAt ? { scheduledAt } : {}),
             ...(cadence ? { cadence } : {}),
             ...(category ? { category } : {}),
+            ...(requester ? { requester } : {}),
             ...(agent ? { agent } : {}),
         };
     }
@@ -562,6 +571,23 @@ function parseSessionCommand(args) {
         return { kind: "session.list", ...(agent ? { agent } : {}) };
     throw new Error(`Usage\n${usage()}`);
 }
+function parseThoughtsCommand(args) {
+    const { agent, rest: cleaned } = extractAgentFlag(args);
+    let last;
+    let json = false;
+    let follow = false;
+    for (let i = 0; i < cleaned.length; i++) {
+        if (cleaned[i] === "--last" && i + 1 < cleaned.length) {
+            last = Number.parseInt(cleaned[i + 1], 10);
+            i++;
+        }
+        if (cleaned[i] === "--json")
+            json = true;
+        if (cleaned[i] === "--follow" || cleaned[i] === "-f")
+            follow = true;
+    }
+    return { kind: "thoughts", ...(agent ? { agent } : {}), ...(last ? { last } : {}), ...(json ? { json } : {}), ...(follow ? { follow } : {}) };
+}
 function parseFriendCommand(args) {
     const { agent, rest: cleaned } = extractAgentFlag(args);
     const [sub, ...rest] = cleaned;
@@ -629,6 +655,8 @@ function parseOuroCommand(args) {
     }
     if (head === "session")
         return parseSessionCommand(args.slice(1));
+    if (head === "thoughts")
+        return parseThoughtsCommand(args.slice(1));
     if (head === "chat") {
         if (!second)
             throw new Error(`Usage\n${usage()}`);
@@ -761,6 +789,25 @@ function defaultFallbackPendingMessage(command) {
     });
     return pendingPath;
 }
+function defaultEnsureDaemonBootPersistence(socketPath) {
+    if (process.platform !== "darwin") {
+        return;
+    }
+    const homeDir = os.homedir();
+    const launchdDeps = {
+        writeFile: (filePath, content) => fs.writeFileSync(filePath, content, "utf-8"),
+        mkdirp: (dir) => fs.mkdirSync(dir, { recursive: true }),
+        homeDir,
+    };
+    const entryPath = path.join((0, identity_1.getRepoRoot)(), "dist", "heart", "daemon", "daemon-entry.js");
+    const logDir = path.join(homeDir, ".agentstate", "daemon", "logs");
+    (0, launchd_1.writeLaunchAgentPlist)(launchdDeps, {
+        nodePath: process.execPath,
+        entryPath,
+        socketPath,
+        logDir,
+    });
+}
 async function defaultInstallSubagents() {
     return (0, subagent_installer_1.installSubagentsForAvailableCli)({
         repoRoot: (0, identity_1.getRepoRoot)(),
@@ -1045,6 +1092,7 @@ function createDefaultOuroCliDeps(socketPath = "/tmp/ouroboros-daemon.sock") {
         registerOuroBundleType: ouro_uti_1.registerOuroBundleUti,
         installOuroCommand: ouro_path_installer_1.installOuroCommand,
         syncGlobalOuroBotWrapper: ouro_bot_global_installer_1.syncGlobalOuroBotWrapper,
+        ensureDaemonBootPersistence: defaultEnsureDaemonBootPersistence,
         /* v8 ignore next 3 -- integration: launches interactive CLI session @preserve */
         startChat: async (agentName) => {
             const { main } = await Promise.resolve().then(() => __importStar(require("../../senses/cli")));
@@ -1317,6 +1365,7 @@ function executeReminderCommand(command, taskMod) {
             body: command.body,
             scheduledAt: command.scheduledAt,
             cadence: command.cadence,
+            requester: command.requester,
         });
         return `created: ${created}`;
     }
@@ -1406,6 +1455,20 @@ async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
     });
     if (command.kind === "daemon.up") {
         await performSystemSetup(deps);
+        if (deps.ensureDaemonBootPersistence) {
+            try {
+                await Promise.resolve(deps.ensureDaemonBootPersistence(deps.socketPath));
+            }
+            catch (error) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "daemon",
+                    event: "daemon.system_setup_launchd_error",
+                    message: "failed to persist daemon boot startup",
+                    meta: { error: error instanceof Error ? error.message : String(error), socketPath: deps.socketPath },
+                });
+            }
+        }
         // Run update hooks before starting daemon so user sees the output
         (0, update_hooks_1.registerUpdateHook)(bundle_meta_1.bundleMetaHook);
         const bundlesRoot = (0, identity_1.getAgentBundlesRoot)();
@@ -1501,6 +1564,49 @@ async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
         }
         /* v8 ignore stop */
     }
+    // ── thoughts (local, no daemon socket needed) ──
+    if (command.kind === "thoughts") {
+        try {
+            const agentName = command.agent ?? (0, identity_1.getAgentName)();
+            const agentRoot = path.join((0, identity_1.getAgentBundlesRoot)(), `${agentName}.ouro`);
+            const sessionFilePath = (0, thoughts_1.getInnerDialogSessionPath)(agentRoot);
+            if (command.json) {
+                try {
+                    const raw = fs.readFileSync(sessionFilePath, "utf-8");
+                    deps.writeStdout(raw);
+                    return raw;
+                }
+                catch {
+                    const message = "no inner dialog session found";
+                    deps.writeStdout(message);
+                    return message;
+                }
+            }
+            const turns = (0, thoughts_1.parseInnerDialogSession)(sessionFilePath);
+            const message = (0, thoughts_1.formatThoughtTurns)(turns, command.last ?? 10);
+            deps.writeStdout(message);
+            if (command.follow) {
+                deps.writeStdout("\n\n--- following (ctrl+c to stop) ---\n");
+                /* v8 ignore start -- callback tested via followThoughts unit tests @preserve */
+                const stop = (0, thoughts_1.followThoughts)(sessionFilePath, (formatted) => {
+                    deps.writeStdout("\n" + formatted);
+                });
+                /* v8 ignore stop */
+                // Block until process exit; cleanup watcher on SIGINT/SIGTERM
+                return new Promise((resolve) => {
+                    const cleanup = () => { stop(); resolve(message); };
+                    process.once("SIGINT", cleanup);
+                    process.once("SIGTERM", cleanup);
+                });
+            }
+            return message;
+        }
+        catch {
+            const message = "error: no agent context — use --agent <name> to specify";
+            deps.writeStdout(message);
+            return message;
+        }
+    }
     // ── session list (local, no daemon socket needed) ──
     if (command.kind === "session.list") {
         /* v8 ignore start -- production default: requires full identity setup @preserve */

package/dist/heart/daemon/launchd.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DAEMON_PLIST_LABEL = void 0;
 exports.generateDaemonPlist = generateDaemonPlist;
+exports.writeLaunchAgentPlist = writeLaunchAgentPlist;
 exports.installLaunchAgent = installLaunchAgent;
 exports.uninstallLaunchAgent = uninstallLaunchAgent;
 exports.isDaemonInstalled = isDaemonInstalled;
@@ -65,6 +66,8 @@ function generateDaemonPlist(options) {
         `    <string>--socket</string>`,
         `    <string>${options.socketPath}</string>`,
         `  </array>`,
+        `  <key>RunAtLoad</key>`,
+        `  <true/>`,
         `  <key>KeepAlive</key>`,
         `  <true/>`,
     ];
@@ -74,6 +77,23 @@ function generateDaemonPlist(options) {
     lines.push(`</dict>`, `</plist>`, ``);
     return lines.join("\n");
 }
+function writeLaunchAgentPlist(deps, options) {
+    const launchAgentsDir = path.join(deps.homeDir, "Library", "LaunchAgents");
+    deps.mkdirp(launchAgentsDir);
+    if (options.logDir) {
+        deps.mkdirp(options.logDir);
+    }
+    const fullPath = plistFilePath(deps.homeDir);
+    const xml = generateDaemonPlist(options);
+    deps.writeFile(fullPath, xml);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.launchd_plist_written",
+        message: "daemon launch agent plist written",
+        meta: { plistPath: fullPath, entryPath: options.entryPath, socketPath: options.socketPath },
+    });
+    return fullPath;
+}
 function installLaunchAgent(deps, options) {
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
@@ -81,8 +101,6 @@ function installLaunchAgent(deps, options) {
         message: "installing launch agent",
         meta: { entryPath: options.entryPath, socketPath: options.socketPath },
     });
-    const launchAgentsDir = path.join(deps.homeDir, "Library", "LaunchAgents");
-    deps.mkdirp(launchAgentsDir);
     const fullPath = plistFilePath(deps.homeDir);
     // Unload existing (best effort) for idempotent re-install
     if (deps.existsFile(fullPath)) {
@@ -91,8 +109,7 @@ function installLaunchAgent(deps, options) {
         }
         catch { /* best effort */ }
     }
-    const xml = generateDaemonPlist(options);
-    deps.writeFile(fullPath, xml);
+    writeLaunchAgentPlist(deps, options);
     deps.exec(`launchctl load "${fullPath}"`);
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",

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

@@ -38,6 +38,7 @@ const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const runtime_1 = require("../../nerves/runtime");
+const bluebubbles_runtime_state_1 = require("../../senses/bluebubbles-runtime-state");
 const identity_1 = require("../identity");
 const sense_truth_1 = require("../sense-truth");
 const process_manager_1 = require("./process-manager");
@@ -175,12 +176,29 @@ function runtimeInfoFor(status) {
         return { runtime: "running" };
     return { runtime: "error" };
 }
+function readBlueBubblesRuntimeFacts(agent, bundlesRoot, snapshot) {
+    const agentRoot = path.join(bundlesRoot, `${agent}.ouro`);
+    const runtimePath = path.join(agentRoot, "state", "senses", "bluebubbles", "runtime.json");
+    if (snapshot?.runtime !== "running" || !fs.existsSync(runtimePath)) {
+        return { runtime: snapshot?.runtime };
+    }
+    const state = (0, bluebubbles_runtime_state_1.readBlueBubblesRuntimeState)(agent, agentRoot);
+    if (state.upstreamStatus === "error") {
+        return {
+            runtime: "error",
+            detail: state.detail,
+        };
+    }
+    return { runtime: snapshot.runtime };
+}
 class DaemonSenseManager {
     processManager;
     contexts;
+    bundlesRoot;
     constructor(options) {
         const bundlesRoot = options.bundlesRoot ?? path.join(os.homedir(), "AgentBundles");
         const secretsRoot = options.secretsRoot ?? path.join(os.homedir(), ".agentsecrets");
+        this.bundlesRoot = bundlesRoot;
         this.contexts = new Map(options.agents.map((agent) => {
             const senses = readAgentSenses(path.join(bundlesRoot, `${agent}.ouro`, "agent.json"));
             const facts = senseFactsFromSecrets(agent, senses, path.join(secretsRoot, agent, "secrets.json"));
@@ -227,6 +245,7 @@ class DaemonSenseManager {
             runtime.set(parsed.agent, current);
         }
         const rows = [...this.contexts.entries()].flatMap(([agent, context]) => {
+            const blueBubblesRuntimeFacts = readBlueBubblesRuntimeFacts(agent, this.bundlesRoot, runtime.get(agent)?.bluebubbles);
             const runtimeInfo = {
                 cli: { configured: true },
                 teams: {
@@ -235,7 +254,7 @@ class DaemonSenseManager {
                 },
                 bluebubbles: {
                     configured: context.facts.bluebubbles.configured,
-                    ...(runtime.get(agent)?.bluebubbles ?? {}),
+                    ...blueBubblesRuntimeFacts,
                 },
             };
             const inventory = (0, sense_truth_1.getSenseInventory)({ senses: context.senses }, runtimeInfo);
@@ -245,7 +264,12 @@ class DaemonSenseManager {
                 label: entry.label,
                 enabled: entry.enabled,
                 status: entry.status,
-                detail: entry.enabled ? context.facts[entry.sense].detail : "not enabled in agent.json",
+                detail: entry.enabled
+                    ? entry.sense === "bluebubbles"
+                        ? blueBubblesRuntimeFacts.detail
+                            ?? context.facts[entry.sense].detail
+                        : context.facts[entry.sense].detail
+                    : "not enabled in agent.json",
             }));
         });
         (0, runtime_1.emitNervesEvent)({

package/dist/heart/daemon/thoughts.js

@@ -0,0 +1,225 @@
+"use strict";
+// Formats inner dialog session turns for human consumption.
+// Used by `ouro thoughts` CLI command to show what the agent has been thinking.
+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.parseInnerDialogSession = parseInnerDialogSession;
+exports.formatThoughtTurns = formatThoughtTurns;
+exports.getInnerDialogSessionPath = getInnerDialogSessionPath;
+exports.followThoughts = followThoughts;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+function contentToText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => {
+        if (typeof part === "string")
+            return part;
+        if (part && typeof part === "object" && "text" in part && typeof part.text === "string") {
+            return part.text;
+        }
+        return "";
+    })
+        .join("\n");
+}
+function classifyTurn(userText) {
+    if (userText.includes("waking up."))
+        return { type: "boot" };
+    const taskMatch = /## task: (.+)$/m.exec(userText);
+    if (taskMatch)
+        return { type: "task", taskId: taskMatch[1] };
+    return { type: "heartbeat" };
+}
+function extractToolNames(messages) {
+    const names = [];
+    for (const msg of messages) {
+        if (msg.role === "assistant" && Array.isArray(msg.tool_calls)) {
+            for (const tc of msg.tool_calls) {
+                if (tc.function?.name && tc.function.name !== "final_answer")
+                    names.push(tc.function.name);
+            }
+        }
+    }
+    return names;
+}
+/** Extract text from a final_answer tool call's arguments. */
+function extractFinalAnswer(messages) {
+    for (let k = messages.length - 1; k >= 0; k--) {
+        const msg = messages[k];
+        if (msg.role !== "assistant" || !Array.isArray(msg.tool_calls))
+            continue;
+        for (const tc of msg.tool_calls) {
+            if (tc.function?.name !== "final_answer")
+                continue;
+            try {
+                const parsed = JSON.parse(tc.function.arguments ?? "{}");
+                if (typeof parsed.answer === "string" && parsed.answer.trim())
+                    return parsed.answer.trim();
+            }
+            catch {
+                // malformed arguments — skip
+            }
+        }
+    }
+    return "";
+}
+function parseInnerDialogSession(sessionPath) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.thoughts_parse",
+        message: "parsing inner dialog session",
+        meta: { sessionPath },
+    });
+    let raw;
+    try {
+        raw = fs.readFileSync(sessionPath, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    let data;
+    try {
+        data = JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+    if (data.version !== 1 || !Array.isArray(data.messages))
+        return [];
+    const turns = [];
+    const messages = data.messages;
+    // Walk messages, pairing user → (tool calls) → assistant sequences
+    let i = 0;
+    while (i < messages.length) {
+        const msg = messages[i];
+        if (msg.role === "system") {
+            i++;
+            continue;
+        }
+        if (msg.role !== "user") {
+            i++;
+            continue;
+        }
+        const userText = contentToText(msg.content);
+        const classification = classifyTurn(userText);
+        // Collect all messages until the next user message (or end)
+        const turnMessages = [];
+        let j = i + 1;
+        while (j < messages.length && messages[j].role !== "user") {
+            turnMessages.push(messages[j]);
+            j++;
+        }
+        // Find the last assistant text response in this turn.
+        // With tool_choice="required", the response may be inside a final_answer tool call.
+        const assistantMsgs = turnMessages.filter((m) => m.role === "assistant");
+        const lastAssistant = assistantMsgs.reverse().find((m) => contentToText(m.content).trim().length > 0);
+        const response = lastAssistant
+            ? contentToText(lastAssistant.content).trim()
+            : extractFinalAnswer(turnMessages);
+        const tools = extractToolNames(turnMessages);
+        turns.push({
+            type: classification.type,
+            prompt: userText.trim(),
+            response,
+            tools,
+            ...(classification.taskId ? { taskId: classification.taskId } : {}),
+        });
+        i = j;
+    }
+    return turns;
+}
+function formatThoughtTurns(turns, lastN) {
+    if (turns.length === 0)
+        return "no inner dialog activity";
+    const selected = lastN > 0 ? turns.slice(-lastN) : turns;
+    /* v8 ignore next -- unreachable: turns.length > 0 checked above, slice always returns ≥1 @preserve */
+    if (selected.length === 0)
+        return "no inner dialog activity";
+    const lines = [];
+    for (const turn of selected) {
+        const typeLabel = turn.type === "task" && turn.taskId
+            ? `task: ${turn.taskId}`
+            : turn.type;
+        lines.push(`--- ${typeLabel} ---`);
+        if (turn.tools.length > 0) {
+            lines.push(`tools: ${turn.tools.join(", ")}`);
+        }
+        if (turn.response) {
+            lines.push(turn.response);
+        }
+        else {
+            lines.push("(no response)");
+        }
+        lines.push("");
+    }
+    return lines.join("\n").trim();
+}
+function getInnerDialogSessionPath(agentRoot) {
+    return path.join(agentRoot, "state", "sessions", "self", "inner", "dialog.json");
+}
+/**
+ * Watch a session file and emit new turns as they appear.
+ * Returns a cleanup function that stops the watcher.
+ */
+function followThoughts(sessionPath, onNewTurns, pollIntervalMs = 1000) {
+    let displayedCount = parseInnerDialogSession(sessionPath).length;
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.thoughts_follow_start",
+        message: "started following inner dialog session",
+        meta: { sessionPath, initialTurns: displayedCount },
+    });
+    fs.watchFile(sessionPath, { interval: pollIntervalMs }, () => {
+        const turns = parseInnerDialogSession(sessionPath);
+        if (turns.length > displayedCount) {
+            const newTurns = turns.slice(displayedCount);
+            onNewTurns(formatThoughtTurns(newTurns, 0));
+            displayedCount = turns.length;
+        }
+    });
+    return () => {
+        fs.unwatchFile(sessionPath);
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.thoughts_follow_stop",
+            message: "stopped following inner dialog session",
+            meta: { sessionPath, totalTurns: displayedCount },
+        });
+    };
+}

package/dist/senses/bluebubbles-client.js

@@ -170,6 +170,12 @@ function applyRepairNotice(event, notice) {
         repairNotice: notice,
     };
 }
+function hasRecoverableMessageContent(event) {
+    return event.kind === "message"
+        && (event.textForAgent.trim().length > 0
+            || event.attachments.length > 0
+            || event.hasPayloadData);
+}
 function hydrateTextForAgent(event, rawData) {
     if (event.kind !== "message") {
         return { ...event, requiresRepair: false };
@@ -323,6 +329,40 @@ function createBlueBubblesClient(config = (0, config_1.getBlueBubblesConfig)(),
                 throw new Error(`BlueBubbles read failed (${response.status}): ${errorText || "unknown"}`);
             }
         },
+        async checkHealth() {
+            const url = buildBlueBubblesApiUrl(config.serverUrl, "/api/v1/message/count", config.password);
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.bluebubbles_healthcheck_start",
+                message: "probing bluebubbles upstream health",
+                meta: { serverUrl: config.serverUrl },
+            });
+            const response = await fetch(url, {
+                method: "GET",
+                signal: AbortSignal.timeout(channelConfig.requestTimeoutMs),
+            });
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => "");
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "senses",
+                    event: "senses.bluebubbles_healthcheck_error",
+                    message: "bluebubbles upstream health probe failed",
+                    meta: {
+                        serverUrl: config.serverUrl,
+                        status: response.status,
+                        reason: errorText || "unknown",
+                    },
+                });
+                throw new Error(`BlueBubbles upstream health check failed (${response.status}): ${errorText || "unknown"}`);
+            }
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.bluebubbles_healthcheck_end",
+                message: "bluebubbles upstream health probe succeeded",
+                meta: { serverUrl: config.serverUrl },
+            });
+        },
         async repairEvent(event) {
             if (!event.requiresRepair) {
                 (0, runtime_1.emitNervesEvent)({
@@ -387,7 +427,16 @@ function createBlueBubblesClient(config = (0, config_1.getBlueBubblesConfig)(),
                     type: event.eventType,
                     data,
                 });
-                let hydrated = hydrateTextForAgent(normalized, data);
+                const recoveredMessage = event.kind === "mutation"
+                    && !event.shouldNotifyAgent
+                    ? (0, bluebubbles_model_1.normalizeBlueBubblesEvent)({
+                        type: "new-message",
+                        data,
+                    })
+                    : null;
+                let hydrated = recoveredMessage && hasRecoverableMessageContent(recoveredMessage)
+                    ? hydrateTextForAgent(recoveredMessage, data)
+                    : hydrateTextForAgent(normalized, data);
                 if (hydrated.kind === "message" &&
                     hydrated.balloonBundleId !== "com.apple.messages.URLBalloonProvider" &&
                     hydrated.attachments.length > 0) {
@@ -411,6 +460,7 @@ function createBlueBubblesClient(config = (0, config_1.getBlueBubblesConfig)(),
                         kind: hydrated.kind,
                         messageGuid: hydrated.messageGuid,
                         repairedFrom: event.kind,
+                        promotedFromMutation: event.kind === "mutation" && hydrated.kind === "message",
                     },
                 });
                 return hydrated;

package/dist/senses/bluebubbles-entry.js

@@ -8,4 +8,6 @@ if (!process.argv.includes("--agent")) {
     process.exit(1);
 }
 const bluebubbles_1 = require("./bluebubbles");
+const runtime_logging_1 = require("../heart/daemon/runtime-logging");
+(0, runtime_logging_1.configureDaemonRuntimeLogger)("bluebubbles");
 (0, bluebubbles_1.startBlueBubblesApp)();