@ouro.bot/cli 0.1.0-alpha.704 → 0.1.0-alpha.706

package/changelog.json

@@ -1,6 +1,18 @@
 {
   "_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.706",
+      "changes": [
+        "Route native RSVP habit checks through typed refresh execution instead of private-runtime wake policy."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.705",
+      "changes": [
+        "Add a side-effect-safe BlueBubbles context smoke command for verifying same-thread packet ledgers."
+      ]
+    },
     {
       "version": "0.1.0-alpha.704",
       "changes": [

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

@@ -485,6 +485,7 @@ function agentResolutionFailureMode(command) {
         case "config.models":
         case "setup":
         case "bluebubbles.replay":
+        case "bluebubbles.context-smoke":
             return "throw";
         default:
             return undefined;
@@ -6081,6 +6082,19 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
         deps.writeStdout(text);
         return text;
     }
+    if (command.kind === "bluebubbles.context-smoke") {
+        const { smokeBlueBubblesContext, formatBlueBubblesContextSmokeText } = await Promise.resolve().then(() => __importStar(require("../../senses/bluebubbles/context-smoke")));
+        const smoke = await smokeBlueBubblesContext({
+            agentName: command.agent,
+            messageGuid: command.messageGuid,
+            persist: command.persist,
+        });
+        const text = command.json
+            ? JSON.stringify(smoke, null, 2)
+            : formatBlueBubblesContextSmokeText(smoke);
+        deps.writeStdout(text);
+        return text;
+    }
     if (isRsvpCliCommand(command)) {
         const { runRsvpCliCommand } = await Promise.resolve().then(() => __importStar(require("../../rsvp/cli")));
         return runRsvpCliCommand(command, deps);

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

@@ -359,9 +359,12 @@ exports.COMMAND_REGISTRY = {
     bluebubbles: {
         category: "System",
         description: "BlueBubbles integration commands",
-        usage: "ouro bluebubbles replay [--agent <name>] --message-guid <guid> [--event-type <type>] [--json]",
-        example: "ouro bluebubbles replay --message-guid abc123",
-        subcommands: ["replay"],
+        usage: [
+            "ouro bluebubbles replay [--agent <name>] --message-guid <guid> [--event-type <type>] [--json]",
+            "ouro bluebubbles context-smoke [--agent <name>] --message-guid <guid> [--persist] [--json]",
+        ].join("\n"),
+        example: "ouro bluebubbles context-smoke --agent slugger --message-guid abc123 --persist --json",
+        subcommands: ["replay", "context-smoke"],
     },
 };
 const SUBCOMMAND_HELP = {

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

@@ -114,6 +114,7 @@ function usage() {
         "  ouro habit summary [--agent <name>] (--run-id <id>|--habit <name>|--operation-id <id>) [--which latest|previous|latest-success|latest-failure] [--json]",
         "  ouro link <agent> --friend <id> --provider <provider> --external-id <external-id>",
         "  ouro bluebubbles replay [--agent <name>] --message-guid <guid> [--event-type new-message|updated-message] [--json]",
+        "  ouro bluebubbles context-smoke [--agent <name>] --message-guid <guid> [--persist] [--json]",
         "  ouro rsvp <doctor|incident|cutover|legacy-render|replay|config|habit|import-legacy|refresh|compare|smoke> ...",
         "  ouro friend list [--agent <name>]",
         "  ouro friend show <id> [--agent <name>]",
@@ -1643,12 +1644,13 @@ function parseMigrateToDeskCommand(args) {
 }
 function parseBlueBubblesCommand(args) {
     const subcommand = args[0];
-    if (subcommand !== "replay") {
+    if (subcommand !== "replay" && subcommand !== "context-smoke") {
         throw new Error(`Usage\n${usage()}`);
     }
     let agent;
     let messageGuid;
     let eventType = "new-message";
+    let persist = false;
     let json = false;
     for (let i = 1; i < args.length; i += 1) {
         if (args[i] === "--agent" && args[i + 1]) {
@@ -1667,13 +1669,26 @@ function parseBlueBubblesCommand(args) {
             eventType = candidate;
             continue;
         }
+        if (args[i] === "--persist") {
+            persist = true;
+            continue;
+        }
         if (args[i] === "--json") {
             json = true;
             continue;
         }
     }
     if (!messageGuid)
-        throw new Error("bluebubbles replay requires --message-guid <guid>");
+        throw new Error(`bluebubbles ${subcommand} requires --message-guid <guid>`);
+    if (subcommand === "context-smoke") {
+        return {
+            kind: "bluebubbles.context-smoke",
+            ...(agent ? { agent } : {}),
+            messageGuid,
+            ...(persist ? { persist: true } : {}),
+            ...(json ? { json: true } : {}),
+        };
+    }
     return {
         kind: "bluebubbles.replay",
         ...(agent ? { agent } : {}),

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

@@ -63,6 +63,7 @@ const pulse_1 = require("./pulse");
 const socket_client_1 = require("./socket-client");
 const await_private_wake_1 = require("./await-private-wake");
 const habit_private_wake_1 = require("./habit-private-wake");
+const habit_policy_1 = require("../../rsvp/habit-policy");
 const bundle_manifest_1 = require("../../mind/bundle-manifest");
 const mcp_canary_1 = require("./mcp-canary");
 const context_loss_sentinel_1 = require("../context-loss-sentinel");
@@ -629,6 +630,25 @@ void daemon.start().then(async () => {
                 habitsDir,
                 osCronManager,
                 onHabitFire: (habitName, trigger, context) => {
+                    if ((0, habit_policy_1.isRsvpHabitName)(habitName)) {
+                        (0, socket_client_1.sendDaemonCommand)(socketPath, {
+                            kind: "habit.poke",
+                            agent,
+                            habitName,
+                            trigger,
+                            ...(context?.occurrenceId ? { occurrenceId: context.occurrenceId } : {}),
+                        }).catch((error) => {
+                            emitHabitPrivateWakeDispatchError({
+                                agent,
+                                habitName,
+                                trigger,
+                                triggerSource: `habit-${trigger}`,
+                                socketPath,
+                                error,
+                            });
+                        });
+                        return;
+                    }
                     const command = (0, habit_private_wake_1.buildHabitPrivateWakeCommand)({
                         agent,
                         habitName,

package/dist/heart/daemon/daemon.js

@@ -567,6 +567,7 @@ class OuroDaemon {
     privateRuntimePolicyDeps;
     onStopCommandComplete;
     externalEventRoot;
+    rsvpHabitRunner;
     constructor(options) {
         this.socketPath = options.socketPath;
         this.processManager = options.processManager;
@@ -580,6 +581,7 @@ class OuroDaemon {
         this.privateRuntimePolicyDeps = options.privateRuntimePolicyDeps ?? {};
         this.onStopCommandComplete = options.onStopCommandComplete ?? null;
         this.externalEventRoot = options.externalEventRoot ?? null;
+        this.rsvpHabitRunner = options.rsvpHabitRunner;
     }
     /* v8 ignore start -- default mailbox server wiring: production-only path, tests inject mailboxServerFactory stub instead. startMailboxHttpServer itself has full coverage in mailbox-http.test.ts @preserve */
     createDefaultMailboxServer() {
@@ -1226,6 +1228,8 @@ class OuroDaemon {
         }
         if (trigger === "poke" || trigger === "manual")
             return undefined;
+        if (typeof command.occurrenceId === "string" && command.occurrenceId.trim().length > 0)
+            return command.occurrenceId.trim();
         if (!fs.existsSync(habitPath))
             return { skipReason: "habit file not found" };
         const habit = parsedHabit ?? (0, habit_runtime_state_1.applyHabitRuntimeState)(agentRoot, (0, habit_parser_1.parseHabitFile)(fs.readFileSync(habitPath, "utf-8"), habitPath));
@@ -1236,6 +1240,24 @@ class OuroDaemon {
             return `${trigger}:first-run:${cadence}`;
         return `${trigger}:last-run:${habit.lastRun}:cadence:${cadence}`;
     }
+    async runNativeRsvpHabit(command, trigger, occurrenceId) {
+        const runner = this.rsvpHabitRunner ?? (async (input) => {
+            const { runNativeRsvpHabit } = await Promise.resolve().then(() => __importStar(require("../../rsvp/native-habit-runner")));
+            return runNativeRsvpHabit(input);
+        });
+        const result = await runner({
+            agent: command.agent,
+            bundlesRoot: this.bundlesRoot,
+            habitName: command.habitName,
+            trigger,
+            ...(occurrenceId ? { occurrenceId } : {}),
+        });
+        return {
+            ok: result.ok,
+            message: result.message,
+            data: result,
+        };
+    }
     buildPrivateRuntimeWorkerWakeMessage(command, decision) {
         const awaitName = (0, await_private_wake_1.awaitNameFromPrivateWakeCommand)(command);
         if (awaitName) {
@@ -1635,7 +1657,7 @@ class OuroDaemon {
                 if (!(0, flight_recorder_1.isHabitRunTrigger)(trigger)) {
                     return { ok: false, error: `invalid habit trigger: ${String(trigger)}` };
                 }
-                if (!this.hasManagedPrivateRuntime(command.agent)) {
+                if (!(0, habit_policy_1.isRsvpHabitName)(command.habitName) && !this.hasManagedPrivateRuntime(command.agent)) {
                     return {
                         ok: false,
                         error: `No managed agent '${command.agent}' is registered with daemon-managed private runtime.`,
@@ -1648,6 +1670,9 @@ class OuroDaemon {
                         message: `skipped scheduled habit ${command.habitName} for ${command.agent}: ${occurrenceId.skipReason}`,
                     };
                 }
+                if ((0, habit_policy_1.isRsvpHabitName)(command.habitName)) {
+                    return this.runNativeRsvpHabit(command, trigger, occurrenceId);
+                }
                 return this.handlePrivateRuntimeWake((0, habit_private_wake_1.buildHabitPrivateWakeCommand)({
                     agent: command.agent,
                     habitName: command.habitName,

package/dist/rsvp/native-habit-runner.js

@@ -0,0 +1,321 @@
+"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.runNativeRsvpHabit = runNativeRsvpHabit;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const habit_parser_1 = require("../heart/habits/habit-parser");
+const habit_runtime_state_1 = require("../heart/habits/habit-runtime-state");
+const habit_session_1 = require("../heart/habits/habit-session");
+const run_ledger_1 = require("../heart/run-ledger");
+const spend_ledger_1 = require("./spend-ledger");
+const habit_policy_1 = require("./habit-policy");
+const runtime_1 = require("../nerves/runtime");
+function sha256Hex(input) {
+    return (0, node_crypto_1.createHash)("sha256").update(input).digest("hex");
+}
+function nowIso(now) {
+    const value = now ? now() : new Date();
+    return value instanceof Date ? value.toISOString() : value;
+}
+function nativeRunId(input) {
+    const digest = sha256Hex(JSON.stringify({
+        agent: input.agent,
+        habitName: input.habitName,
+        trigger: input.trigger,
+        occurrenceId: input.occurrenceId ?? null,
+    })).slice(0, 24);
+    return `rsvp-${input.trigger}-${digest}`;
+}
+function noopCliDeps(input, agentRoot) {
+    return {
+        socketPath: "",
+        sendCommand: async () => ({ ok: false, error: "daemon socket unavailable in native RSVP habit runner" }),
+        startDaemonProcess: async () => ({ pid: null }),
+        writeStdout: () => undefined,
+        checkSocketAlive: async () => false,
+        cleanupStaleSocket: () => undefined,
+        fallbackPendingMessage: () => "daemon socket unavailable in native RSVP habit runner",
+        bundlesRoot: input.bundlesRoot,
+        agentBundleRoot: agentRoot,
+    };
+}
+async function defaultRunRefresh(command, deps) {
+    const { runRsvpCliCommand } = await Promise.resolve().then(() => __importStar(require("./cli")));
+    return runRsvpCliCommand(command, deps);
+}
+function parseRefreshPayload(text) {
+    const parsed = JSON.parse(text);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("RSVP refresh returned a non-object payload");
+    }
+    return parsed;
+}
+function refreshCommandFor(input, sendAllowed, mode) {
+    return {
+        kind: "rsvp.refresh",
+        agent: input.agent,
+        mode,
+        json: true,
+        ...(sendAllowed ? { allowSend: true } : { noSend: true }),
+    };
+}
+function permissionEnvelope(sendAllowed) {
+    return {
+        schemaVersion: 1,
+        canMessageOutward: sendAllowed,
+        returnRoutes: sendAllowed
+            ? [{ kind: "family", recipient: "family", status: "allowed" }]
+            : [],
+        deniedTools: sendAllowed ? [] : ["send_message", "surface"],
+        warnings: [],
+    };
+}
+function toolPolicy(sendAllowed) {
+    return {
+        requestedTools: [...habit_policy_1.RSVP_HABIT_ALLOWED_TOOLS],
+        grantedTools: [...habit_policy_1.RSVP_HABIT_ALLOWED_TOOLS],
+        deniedTools: [],
+        outwardMessagingAllowed: sendAllowed,
+    };
+}
+function stringField(record, key) {
+    const value = record[key];
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function refreshRecord(payload) {
+    const value = payload.refresh;
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function producedRefsFor(payload) {
+    if (payload.sendAllowed === true)
+        return [];
+    const snapshotId = stringField(refreshRecord(payload) ?? {}, "snapshotId");
+    return snapshotId ? [{ kind: "none", locator: `state/rsvp/snapshots/${snapshotId}.json` }] : [];
+}
+function surfaceAttemptsFor(payload, requestedSend, errorMessage) {
+    if (payload.sendAllowed === true) {
+        return [{
+                recipient: "rsvp",
+                channel: "bluebubbles",
+                reason: "status",
+                result: "sent",
+            }];
+    }
+    if (requestedSend && errorMessage) {
+        return [{
+                recipient: "rsvp",
+                channel: "bluebubbles",
+                reason: "blocked",
+                result: "blocked",
+                error: errorMessage,
+            }];
+    }
+    return [];
+}
+function payloadError(payload) {
+    if (payload.ok === false || typeof payload.requires === "string") {
+        return stringField(payload, "message") ?? "RSVP refresh did not complete";
+    }
+    return null;
+}
+function recordNativeRunLedger(input) {
+    const target = {
+        habitName: input.habitName,
+        runId: input.runId,
+        trigger: input.trigger,
+        occurrenceId: input.occurrenceId ?? null,
+        command: "rsvp.refresh",
+    };
+    const record = (0, run_ledger_1.createRunLedgerRecord)({
+        agent: input.agent,
+        triggerType: "habit",
+        sourceKind: "daemon",
+        senseOrHabit: input.habitName,
+        lifecycle: input.lifecycle,
+        startedAt: input.startedAt,
+        ...(input.endedAt ? { endedAt: input.endedAt } : {}),
+        ...(input.lifecycle === "completed" || input.lifecycle === "error"
+            ? { usage: (0, run_ledger_1.usageMetadataFromUsageData)(undefined, "none") }
+            : {}),
+        target,
+        idempotencyScope: target,
+        sessionRef: {
+            channel: "rsvp",
+            keyHash: `sha256:${sha256Hex(input.runId)}`,
+        },
+    });
+    (0, run_ledger_1.appendRunLedgerRecordNonFatal)(input.agentRoot, record);
+    try {
+        (0, spend_ledger_1.recordRsvpSpendLedgerRun)(input.agentRoot, record);
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "rsvp",
+            event: "rsvp.native_habit_spend_ledger_error",
+            message: "failed to record native RSVP habit spend ledger row",
+            meta: { runId: input.runId, lifecycle: input.lifecycle, error: String(error) },
+        });
+    }
+}
+async function runNativeRsvpHabit(input) {
+    const agentRoot = path.join(input.bundlesRoot, `${input.agent}.ouro`);
+    const habitPath = path.join(agentRoot, "habits", `${input.habitName}.md`);
+    const startedAt = nowIso(input.now);
+    const runId = nativeRunId(input);
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.native_habit_start",
+        message: "native RSVP habit starting",
+        meta: {
+            agent: input.agent,
+            habitName: input.habitName,
+            trigger: input.trigger,
+            occurrenceId: input.occurrenceId ?? null,
+            runId,
+        },
+    });
+    const habit = (0, habit_runtime_state_1.applyHabitRuntimeState)(agentRoot, (0, habit_parser_1.parseHabitFile)(fs.readFileSync(habitPath, "utf-8"), habitPath));
+    if (!habit.rsvp)
+        throw new Error(`RSVP habit metadata is required before native execution: ${input.habitName}`);
+    const policy = (0, habit_policy_1.rsvpHabitRuntimePolicy)(habit.rsvp);
+    const command = refreshCommandFor(input, policy.sendAllowed, habit.rsvp.mode);
+    const deps = noopCliDeps(input, agentRoot);
+    recordNativeRunLedger({
+        agentRoot,
+        agent: input.agent,
+        habitName: input.habitName,
+        runId,
+        trigger: input.trigger,
+        occurrenceId: input.occurrenceId,
+        startedAt,
+        lifecycle: "started",
+    });
+    let payload;
+    let errorMessage = null;
+    try {
+        payload = parseRefreshPayload(await (input.runRefresh ?? defaultRunRefresh)(command, deps));
+        errorMessage = payloadError(payload);
+    }
+    catch (error) {
+        payload = {
+            ok: false,
+            command: "rsvp.refresh",
+            sideEffect: false,
+            agent: input.agent,
+            mode: habit.rsvp.mode,
+            message: error instanceof Error ? error.message : String(error),
+        };
+        errorMessage = stringField(payload, "message") ?? "RSVP refresh failed";
+    }
+    const endedAt = nowIso(input.now);
+    const lifecycle = errorMessage ? "error" : "completed";
+    const surfaceAttempts = surfaceAttemptsFor(payload, policy.sendAllowed, errorMessage);
+    const errors = errorMessage ? [errorMessage] : [];
+    recordNativeRunLedger({
+        agentRoot,
+        agent: input.agent,
+        habitName: input.habitName,
+        runId,
+        trigger: input.trigger,
+        occurrenceId: input.occurrenceId,
+        startedAt,
+        endedAt,
+        lifecycle,
+    });
+    const completion = (0, habit_session_1.completeHabitRun)({
+        agentRoot,
+        habit,
+        runId,
+        trigger: input.trigger,
+        startedAt,
+        endedAt,
+        operationId: `rsvp-native:${input.trigger}:${input.occurrenceId ?? runId}`,
+        permissionEnvelope: permissionEnvelope(policy.sendAllowed),
+        toolPolicy: toolPolicy(policy.sendAllowed),
+        producedRefs: producedRefsFor(payload),
+        surfaceAttempts,
+        errors,
+        summarySnapshot: {
+            summary: errorMessage
+                ? `Native RSVP habit failed: ${errorMessage}`
+                : "Native RSVP habit completed.",
+            decisions: [
+                `mode=${habit.rsvp.mode}`,
+                `sendAllowed=${String(policy.sendAllowed)}`,
+            ],
+            nextLikelyStep: null,
+        },
+    });
+    const ok = lifecycle === "completed" && completion.receiptWritten && completion.runtimeStateRecorded;
+    const message = ok
+        ? `native RSVP habit ${input.habitName} completed for ${input.agent}`
+        : `native RSVP habit ${input.habitName} failed for ${input.agent}: ${errorMessage ?? "runtime state was not recorded"}`;
+    const terminalEventMeta = {
+        agent: input.agent,
+        habitName: input.habitName,
+        trigger: input.trigger,
+        runId,
+        lifecycle,
+        receiptWritten: completion.receiptWritten,
+        runtimeStateRecorded: completion.runtimeStateRecorded,
+    };
+    if (lifecycle === "completed") {
+        (0, runtime_1.emitNervesEvent)({
+            component: "rsvp",
+            event: "rsvp.native_habit_end",
+            message,
+            meta: terminalEventMeta,
+        });
+    }
+    else {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "rsvp",
+            event: "rsvp.native_habit_error",
+            message,
+            meta: terminalEventMeta,
+        });
+    }
+    return {
+        ok,
+        message,
+        lifecycle,
+        runId,
+        payload,
+    };
+}

package/dist/senses/bluebubbles/context-packet.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BLUEBUBBLES_CONTEXT_PACKET_MAX_AGE_MS = exports.BLUEBUBBLES_CONTEXT_PACKET_LIMIT = void 0;
+exports.blueBubblesContextChatKey = blueBubblesContextChatKey;
+exports.blueBubblesContextChatKeyHash = blueBubblesContextChatKeyHash;
+exports.buildBlueBubblesContextPacket = buildBlueBubblesContextPacket;
+const node_crypto_1 = require("node:crypto");
+const runtime_1 = require("../../nerves/runtime");
+const context_packets_1 = require("../context-packets");
+exports.BLUEBUBBLES_CONTEXT_PACKET_LIMIT = 40;
+exports.BLUEBUBBLES_CONTEXT_PACKET_MAX_AGE_MS = 48 * 60 * 60 * 1000;
+function sha256Hex(input) {
+    return (0, node_crypto_1.createHash)("sha256").update(input).digest("hex");
+}
+function blueBubblesContextChatKey(event) {
+    return event.chat.chatGuid ?? event.chat.chatIdentifier ?? event.chat.sessionKey;
+}
+function blueBubblesContextChatKeyHash(event) {
+    return sha256Hex(blueBubblesContextChatKey(event));
+}
+function isSameBlueBubblesChat(candidate, anchor) {
+    return candidate.chat.sessionKey === anchor.chat.sessionKey
+        || (!!candidate.chat.chatGuid && candidate.chat.chatGuid === anchor.chat.chatGuid)
+        || (!!candidate.chat.chatIdentifier && candidate.chat.chatIdentifier === anchor.chat.chatIdentifier);
+}
+function contextAuthorLabel(event) {
+    if (event.fromMe)
+        return "Slugger";
+    return event.sender.displayName || event.sender.externalId || "Unknown";
+}
+function messageToContextInput(event, chatGuidHash) {
+    return {
+        timestamp: new Date(event.timestamp).toISOString(),
+        authorLabel: contextAuthorLabel(event),
+        body: event.textForAgent || event.text,
+        sourceRef: {
+            sense: "bluebubbles",
+            adapter: "bluebubbles-api-v1",
+            service: "imessage",
+            chatGuid: event.chat.chatGuid,
+            chatGuidHash,
+            messageGuid: event.messageGuid,
+            senderExternalIdHash: sha256Hex(event.sender.externalId || event.sender.rawId || "unknown"),
+            observedAt: new Date(event.timestamp).toISOString(),
+        },
+    };
+}
+async function buildBlueBubblesContextPacket(input) {
+    if (!Number.isFinite(input.event.timestamp))
+        return null;
+    if (!input.client.listRecentMessages)
+        return null;
+    const event = input.event;
+    const chatGuidHash = blueBubblesContextChatKeyHash(event);
+    const anchorTimestamp = new Date(event.timestamp).toISOString();
+    const candidates = await input.client.listRecentMessages({
+        beforeTimestamp: event.timestamp,
+        limit: exports.BLUEBUBBLES_CONTEXT_PACKET_LIMIT,
+        offset: 0,
+        ...(event.chat.chatGuid ? { chatGuid: event.chat.chatGuid } : {}),
+        ...(!event.chat.chatGuid && event.chat.chatIdentifier ? { chatIdentifier: event.chat.chatIdentifier } : {}),
+    });
+    const history = candidates
+        .filter((candidate) => candidate.kind === "message")
+        .filter((candidate) => isSameBlueBubblesChat(candidate, event))
+        .filter((candidate) => candidate.messageGuid !== event.messageGuid)
+        .filter((candidate) => candidate.timestamp <= event.timestamp)
+        .filter((candidate) => event.timestamp - candidate.timestamp <= exports.BLUEBUBBLES_CONTEXT_PACKET_MAX_AGE_MS);
+    if (history.length === 0)
+        return null;
+    const packet = (0, context_packets_1.buildSenseContextPacket)({
+        agent: input.agentName,
+        sense: "bluebubbles",
+        sessionKey: event.chat.sessionKey,
+        chatKeyHash: chatGuidHash,
+        anchorMessageGuid: event.messageGuid,
+        anchorTimestamp,
+        windowBeforeMessages: exports.BLUEBUBBLES_CONTEXT_PACKET_LIMIT,
+        windowBeforeMs: exports.BLUEBUBBLES_CONTEXT_PACKET_MAX_AGE_MS,
+        messages: history.map((candidate) => messageToContextInput(candidate, chatGuidHash)),
+    });
+    const rendered = (0, context_packets_1.renderSenseContextPacketForPrompt)(packet, {
+        redactionPatterns: [/password=[^\s]+/gi],
+    });
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.bluebubbles_context_packet_built",
+        message: "built bluebubbles same-chat context packet",
+        meta: {
+            packetId: packet.packetId,
+            messageGuid: event.messageGuid,
+            contextMessages: history.length,
+            renderedMessages: rendered.stats.renderedMessages,
+        },
+    });
+    return {
+        packet,
+        rendered,
+        historyCount: history.length,
+    };
+}

package/dist/senses/bluebubbles/context-smoke.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.smokeBlueBubblesContext = smokeBlueBubblesContext;
+exports.formatBlueBubblesContextSmokeText = formatBlueBubblesContextSmokeText;
+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 context_packet_ledger_1 = require("../context-packet-ledger");
+const client_1 = require("./client");
+const context_packet_1 = require("./context-packet");
+const model_1 = require("./model");
+function requireMessageEvent(event, messageGuid) {
+    if (event.kind !== "message") {
+        throw new Error(`BlueBubbles context smoke requires a message event; ${messageGuid} repaired to ${event.kind}`);
+    }
+}
+function smokeResult(params, writeResult) {
+    return {
+        ok: true,
+        sideEffect: writeResult ? "private-runtime-ledger-write" : false,
+        ...params,
+        ...(writeResult ? {
+            ledgerPath: writeResult.ledgerPath,
+            packetPath: writeResult.packetPath,
+            receiptPath: writeResult.receiptPath,
+        } : {}),
+    };
+}
+async function smokeBlueBubblesContext(params, deps = {}) {
+    const agentName = params.agentName.trim();
+    const messageGuid = params.messageGuid.trim();
+    if (!agentName)
+        throw new Error("bluebubbles context-smoke requires agentName");
+    if (!messageGuid)
+        throw new Error("bluebubbles context-smoke requires messageGuid");
+    const setSmokeAgentName = deps.setAgentName ?? identity_1.setAgentName;
+    const resetSmokeIdentity = 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;
+    const resolveAgentRoot = deps.getAgentRoot ?? identity_1.getAgentRoot;
+    const writePacket = deps.writePacket ?? context_packet_ledger_1.writeSenseContextPacket;
+    const createDefaultClient = deps.createDefaultClient ?? client_1.createBlueBubblesClient;
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.bluebubbles_context_smoke_start",
+        message: "starting bluebubbles context smoke",
+        meta: {
+            agentName,
+            messageGuid,
+            persist: params.persist === true,
+        },
+    });
+    setSmokeAgentName(agentName);
+    try {
+        if (!deps.createClient) {
+            const machineId = loadMachineId();
+            await refreshMachineRuntimeConfig(agentName, machineId, { preserveCachedOnFailure: true });
+        }
+        const client = deps.createClient ? deps.createClient() : createDefaultClient();
+        const probe = normalizeEvent({
+            type: "new-message",
+            data: {
+                guid: messageGuid,
+                hasPayloadData: true,
+            },
+        });
+        const event = await client.repairEvent(probe);
+        requireMessageEvent(event, messageGuid);
+        const built = await (0, context_packet_1.buildBlueBubblesContextPacket)({
+            agentName,
+            client,
+            event,
+        });
+        if (!built) {
+            throw new Error(`BlueBubbles context smoke found no same-thread history before ${messageGuid}`);
+        }
+        const writeResult = params.persist
+            ? writePacket(resolveAgentRoot(agentName), built.packet)
+            : undefined;
+        const result = smokeResult({
+            agentName,
+            messageGuid,
+            packetId: built.packet.packetId,
+            contextMessages: built.historyCount,
+            renderedMessages: built.rendered.stats.renderedMessages,
+            renderedCharacters: built.rendered.stats.outputCharacters,
+            omittedMessages: built.rendered.stats.omittedMessages,
+            truncatedMessages: built.rendered.stats.truncatedMessages,
+        }, writeResult);
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.bluebubbles_context_smoke_end",
+            message: "completed bluebubbles context smoke",
+            meta: {
+                agentName,
+                messageGuid,
+                packetId: result.packetId,
+                contextMessages: result.contextMessages,
+                sideEffect: result.sideEffect,
+            },
+        });
+        return result;
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.bluebubbles_context_smoke_error",
+            message: "bluebubbles context smoke failed",
+            meta: {
+                agentName,
+                messageGuid,
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+        throw error;
+    }
+    finally {
+        resetSmokeIdentity();
+    }
+}
+function formatBlueBubblesContextSmokeText(result) {
+    const lines = [
+        "bluebubbles context smoke passed",
+        `agent: ${result.agentName}`,
+        `message_guid: ${result.messageGuid}`,
+        `context_messages: ${result.contextMessages}`,
+        `packet_id: ${result.packetId}`,
+        `rendered_messages: ${result.renderedMessages}`,
+        `rendered_characters: ${result.renderedCharacters}`,
+        `truncated_messages: ${result.truncatedMessages}`,
+        `omitted_messages: ${result.omittedMessages}`,
+        `side_effect: ${result.sideEffect}`,
+    ];
+    if (result.ledgerPath)
+        lines.push(`ledger_path: ${result.ledgerPath}`);
+    if (result.packetPath)
+        lines.push(`packet_path: ${result.packetPath}`);
+    if (result.receiptPath)
+        lines.push(`receipt_path: ${result.receiptPath}`);
+    return lines.join("\n");
+}

package/dist/senses/bluebubbles/index.js

@@ -86,6 +86,7 @@ const trust_gate_1 = require("../trust-gate");
 const pipeline_1 = require("../pipeline");
 const context_packets_1 = require("../context-packets");
 const context_packet_ledger_1 = require("../context-packet-ledger");
+const context_packet_1 = require("./context-packet");
 const autonomy_budget_1 = require("../../heart/autonomy-budget");
 const bbFailoverStates = new Map();
 /**
@@ -263,8 +264,6 @@ const BLUEBUBBLES_LIVE_TURN_STALLED_MS = 90_000;
 const BLUEBUBBLES_SILENCE_WATCHDOG_MS = 75_000;
 const BLUEBUBBLES_CALLBACK_CLEANUP_TIMEOUT_MS = 2_000;
 const BLUEBUBBLES_ACTIVITY_OPERATION_TIMEOUT_MS = 20_000;
-const BLUEBUBBLES_CONTEXT_PACKET_LIMIT = 40;
-const BLUEBUBBLES_CONTEXT_PACKET_MAX_AGE_MS = 48 * 60 * 60 * 1000;
 const BLUEBUBBLES_CATCHUP_PAGE_SIZE = 50;
 const BLUEBUBBLES_CATCHUP_MAX_PAGES = 20;
 const BLUEBUBBLES_HEALTHY_CATCHUP_OVERLAP_MS = 90_000;
@@ -614,36 +613,6 @@ function recordBlueBubblesRecoveryFailureForBudget(agentName, event, source) {
         // Autonomy failure accounting must not turn a recovery error into a broader sense outage.
     }
 }
-function chatKeyForContext(event) {
-    return event.chat.chatGuid ?? event.chat.chatIdentifier ?? event.chat.sessionKey;
-}
-function isSameBlueBubblesChat(candidate, anchor) {
-    return candidate.chat.sessionKey === anchor.chat.sessionKey
-        || (!!candidate.chat.chatGuid && candidate.chat.chatGuid === anchor.chat.chatGuid)
-        || (!!candidate.chat.chatIdentifier && candidate.chat.chatIdentifier === anchor.chat.chatIdentifier);
-}
-function contextAuthorLabel(event) {
-    if (event.fromMe)
-        return "Slugger";
-    return event.sender.displayName || event.sender.externalId || "Unknown";
-}
-function messageToContextInput(event, chatGuidHash) {
-    return {
-        timestamp: new Date(event.timestamp).toISOString(),
-        authorLabel: contextAuthorLabel(event),
-        body: event.textForAgent || event.text,
-        sourceRef: {
-            sense: "bluebubbles",
-            adapter: "bluebubbles-api-v1",
-            service: "imessage",
-            chatGuid: event.chat.chatGuid,
-            chatGuidHash,
-            messageGuid: event.messageGuid,
-            senderExternalIdHash: sha256Hex(event.sender.externalId || event.sender.rawId || "unknown"),
-            observedAt: new Date(event.timestamp).toISOString(),
-        },
-    };
-}
 function insertEphemeralContextMessages(messages, contextMessages) {
     if (contextMessages.length === 0)
         return messages;
@@ -660,43 +629,18 @@ async function buildBlueBubblesContextMessages(input) {
     const event = input.event;
     if (!Number.isFinite(event.timestamp))
         return [];
-    const chatKey = chatKeyForContext(event);
-    const chatGuidHash = sha256Hex(chatKey);
+    const chatGuidHash = (0, context_packet_1.blueBubblesContextChatKeyHash)(event);
     const anchorTimestamp = new Date(event.timestamp).toISOString();
     try {
-        const query = {
-            beforeTimestamp: event.timestamp,
-            limit: BLUEBUBBLES_CONTEXT_PACKET_LIMIT,
-            offset: 0,
-            ...(event.chat.chatGuid ? { chatGuid: event.chat.chatGuid } : {}),
-            ...(!event.chat.chatGuid && event.chat.chatIdentifier ? { chatIdentifier: event.chat.chatIdentifier } : {}),
-        };
-        const candidates = input.client.listRecentMessages
-            ? await input.client.listRecentMessages(query)
-            : [];
-        const history = candidates
-            .filter((candidate) => candidate.kind === "message")
-            .filter((candidate) => isSameBlueBubblesChat(candidate, event))
-            .filter((candidate) => candidate.messageGuid !== event.messageGuid)
-            .filter((candidate) => candidate.timestamp <= event.timestamp)
-            .filter((candidate) => event.timestamp - candidate.timestamp <= BLUEBUBBLES_CONTEXT_PACKET_MAX_AGE_MS);
-        if (history.length === 0)
-            return [];
-        const packet = (0, context_packets_1.buildSenseContextPacket)({
-            agent: input.agentName,
-            sense: "bluebubbles",
-            sessionKey: event.chat.sessionKey,
-            chatKeyHash: chatGuidHash,
-            anchorMessageGuid: event.messageGuid,
-            anchorTimestamp,
-            windowBeforeMessages: BLUEBUBBLES_CONTEXT_PACKET_LIMIT,
-            windowBeforeMs: BLUEBUBBLES_CONTEXT_PACKET_MAX_AGE_MS,
-            messages: history.map((candidate) => messageToContextInput(candidate, chatGuidHash)),
+        const result = await (0, context_packet_1.buildBlueBubblesContextPacket)({
+            agentName: input.agentName,
+            client: input.client,
+            event,
         });
+        if (!result)
+            return [];
+        const { packet, rendered, historyCount } = result;
         (0, context_packet_ledger_1.writeSenseContextPacket)(input.agentRoot, packet);
-        const rendered = (0, context_packets_1.renderSenseContextPacketForPrompt)(packet, {
-            redactionPatterns: [/password=[^\s]+/gi],
-        });
         (0, runtime_1.emitNervesEvent)({
             component: "senses",
             event: "senses.bluebubbles_context_packet_injected",
@@ -704,7 +648,7 @@ async function buildBlueBubblesContextMessages(input) {
             meta: {
                 packetId: packet.packetId,
                 messageGuid: event.messageGuid,
-                contextMessages: history.length,
+                contextMessages: historyCount,
             },
         });
         return [{ role: "system", content: rendered.text }];

package/package.json

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