@ouro.bot/cli 0.1.0-alpha.703 → 0.1.0-alpha.705

package/changelog.json

@@ -1,6 +1,19 @@
 {
   "_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.705",
+      "changes": [
+        "Add a side-effect-safe BlueBubbles context smoke command for verifying same-thread packet ledgers."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.704",
+      "changes": [
+        "Restore RSVP notification copy and harden RSVP run ledgers.",
+        "Preserve loose RSVP spend-ledger history while adding cold-start state coverage."
+      ]
+    },
     {
       "version": "0.1.0-alpha.703",
       "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/rsvp/diff-renderer.js

@@ -4,7 +4,7 @@ exports.guestDisplayName = guestDisplayName;
 exports.computeRsvpDelta = computeRsvpDelta;
 exports.renderRsvpReport = renderRsvpReport;
 const runtime_1 = require("../nerves/runtime");
-const RSVP_REPORT_FOOTER = "🤖 Beep boop! Automated RSVP update from Slugger — no need to reply here!";
+const RSVP_REPORT_FOOTER = "🤖 Beep boop! I'm a script, not Slugger — no need to reply here!";
 function byId(left, right) {
     return left.id.localeCompare(right.id);
 }

package/dist/rsvp/habit-stage.js

@@ -38,6 +38,8 @@ const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const habit_parser_1 = require("../heart/habits/habit-parser");
 const runtime_1 = require("../nerves/runtime");
+const outbound_state_1 = require("./outbound-state");
+const spend_ledger_1 = require("./spend-ledger");
 const habit_policy_1 = require("./habit-policy");
 function defaultRsvpHabitMetadata(mode) {
     return {
@@ -62,17 +64,20 @@ function stagedHabitBody() {
 function stageRsvpHabit(input) {
     const habitPath = path.join(input.agentRoot, "habits", `${habit_policy_1.RSVP_HABIT_NAME}.md`);
     const rsvp = defaultRsvpHabitMetadata(input.mode);
+    const created = (input.now ?? new Date()).toISOString();
     const content = (0, habit_parser_1.renderHabitFile)({
         title: "RSVP Ari & Rachel",
         status: "active",
         cadence: input.cadence,
-        created: (input.now ?? new Date()).toISOString(),
+        created,
         tools: [...habit_policy_1.RSVP_HABIT_ALLOWED_TOOLS],
         continuity: { mode: "stateful" },
         rsvp,
     }, stagedHabitBody());
     fs.mkdirSync(path.dirname(habitPath), { recursive: true });
     fs.writeFileSync(habitPath, content, "utf-8");
+    (0, outbound_state_1.ensureRsvpOutboundState)(input.agentRoot, created);
+    (0, spend_ledger_1.ensureRsvpSpendLedger)(input.agentRoot, created);
     (0, runtime_1.emitNervesEvent)({
         component: "rsvp",
         event: "rsvp.habit_staged",

package/dist/rsvp/outbound-state.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RSVP_OUTBOUND_STATE_POLICY_VERSION = void 0;
 exports.readRsvpOutboundState = readRsvpOutboundState;
+exports.ensureRsvpOutboundState = ensureRsvpOutboundState;
 exports.writeRsvpBaseline = writeRsvpBaseline;
 exports.decideRsvpOutboundReport = decideRsvpOutboundReport;
 exports.recordRsvpOutboundAttempt = recordRsvpOutboundAttempt;
@@ -135,6 +136,19 @@ function writeState(agentRoot, state) {
     fs.renameSync(tmp, filePath);
     return state;
 }
+function ensureRsvpOutboundState(agentRoot, now = new Date().toISOString()) {
+    const filePath = rsvpOutboundStatePath(agentRoot);
+    if (fs.existsSync(filePath))
+        return readRsvpOutboundState(agentRoot);
+    const state = writeState(agentRoot, emptyState(now));
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.outbound_state_initialized",
+        message: "initialized RSVP outbound state",
+        meta: { updatedAt: state.updatedAt },
+    });
+    return state;
+}
 function writeRsvpBaseline(input) {
     const current = readRsvpOutboundState(input.agentRoot);
     const state = writeState(input.agentRoot, {

package/dist/rsvp/spend-ledger.js

@@ -0,0 +1,175 @@
+"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.RSVP_SPEND_LEDGER_POLICY_VERSION = void 0;
+exports.readRsvpSpendLedger = readRsvpSpendLedger;
+exports.ensureRsvpSpendLedger = ensureRsvpSpendLedger;
+exports.recordRsvpSpendLedgerRun = recordRsvpSpendLedgerRun;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const runtime_1 = require("../nerves/runtime");
+exports.RSVP_SPEND_LEDGER_POLICY_VERSION = "rsvp-spend-ledger/v1";
+function ledgerPath(agentRoot) {
+    return path.join(agentRoot, "state", "rsvp", "spend-ledger.json");
+}
+function emptyLedger(now) {
+    return {
+        schemaVersion: 1,
+        policyVersion: exports.RSVP_SPEND_LEDGER_POLICY_VERSION,
+        createdAt: now,
+        updatedAt: now,
+        runs: [],
+    };
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function stringField(record, key) {
+    const value = record[key];
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function isRun(value) {
+    const row = value;
+    return !!row
+        && row.schemaVersion === 1
+        && typeof row.runId === "string"
+        && typeof row.rootRunId === "string"
+        && typeof row.idempotencyKey === "string"
+        && typeof row.targetHash === "string"
+        && typeof row.habitName === "string"
+        && typeof row.trigger === "string"
+        && typeof row.lifecycle === "string"
+        && typeof row.startedAt === "string"
+        && typeof row.recordedAt === "string"
+        && row.contentStored === false;
+}
+function storedRun(value) {
+    if (isRun(value))
+        return value;
+    return isRecord(value) ? value : null;
+}
+function isLedger(value) {
+    const row = value;
+    return !!row
+        && row.schemaVersion === 1
+        && row.policyVersion === exports.RSVP_SPEND_LEDGER_POLICY_VERSION
+        && typeof row.createdAt === "string"
+        && typeof row.updatedAt === "string"
+        && Array.isArray(row.runs);
+}
+function readRsvpSpendLedger(agentRoot) {
+    const filePath = ledgerPath(agentRoot);
+    if (!fs.existsSync(filePath))
+        return emptyLedger(new Date().toISOString());
+    try {
+        const now = new Date().toISOString();
+        const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        if (!isLedger(parsed)) {
+            if (!isRecord(parsed) || !Array.isArray(parsed.runs))
+                return emptyLedger(now);
+            return {
+                schemaVersion: 1,
+                policyVersion: exports.RSVP_SPEND_LEDGER_POLICY_VERSION,
+                createdAt: stringField(parsed, "createdAt") ?? now,
+                updatedAt: stringField(parsed, "updatedAt") ?? now,
+                runs: parsed.runs.map(storedRun).filter((run) => run !== null),
+            };
+        }
+        return {
+            schemaVersion: 1,
+            policyVersion: exports.RSVP_SPEND_LEDGER_POLICY_VERSION,
+            createdAt: parsed.createdAt,
+            updatedAt: parsed.updatedAt,
+            runs: parsed.runs.map(storedRun).filter((run) => run !== null),
+        };
+    }
+    catch {
+        return emptyLedger(new Date().toISOString());
+    }
+}
+function writeLedger(agentRoot, ledger) {
+    const filePath = ledgerPath(agentRoot);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+    fs.writeFileSync(tmp, `${JSON.stringify(ledger, null, 2)}\n`, "utf-8");
+    fs.renameSync(tmp, filePath);
+    return ledger;
+}
+function ensureRsvpSpendLedger(agentRoot, now = new Date().toISOString()) {
+    const filePath = ledgerPath(agentRoot);
+    if (fs.existsSync(filePath))
+        return readRsvpSpendLedger(agentRoot);
+    const ledger = writeLedger(agentRoot, emptyLedger(now));
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.spend_ledger_initialized",
+        message: "initialized RSVP spend ledger",
+        meta: { updatedAt: ledger.updatedAt },
+    });
+    return ledger;
+}
+function recordRsvpSpendLedgerRun(agentRoot, record) {
+    const current = readRsvpSpendLedger(agentRoot);
+    const run = {
+        schemaVersion: 1,
+        runId: record.runId,
+        rootRunId: record.rootRunId,
+        idempotencyKey: record.idempotencyKey,
+        targetHash: record.targetHash,
+        habitName: record.senseOrHabit,
+        trigger: record.triggerType,
+        lifecycle: record.lifecycle,
+        startedAt: record.startedAt,
+        recordedAt: record.recordedAt,
+        ...(record.endedAt ? { endedAt: record.endedAt } : {}),
+        ...(record.usage ? { usage: record.usage } : {}),
+        contentStored: false,
+    };
+    const withoutDuplicate = current.runs.filter((entry) => !(entry.runId === run.runId && entry.lifecycle === run.lifecycle));
+    const updated = writeLedger(agentRoot, {
+        schemaVersion: 1,
+        policyVersion: exports.RSVP_SPEND_LEDGER_POLICY_VERSION,
+        createdAt: current.createdAt,
+        updatedAt: run.recordedAt,
+        runs: [...withoutDuplicate, run],
+    });
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.spend_ledger_recorded",
+        message: "recorded RSVP spend ledger row",
+        meta: { runId: run.runId, lifecycle: run.lifecycle, habitName: run.habitName },
+    });
+    return updated;
+}

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/dist/senses/private-runtime-worker.js

@@ -52,6 +52,7 @@ const tools_base_1 = require("../repertoire/tools-base");
 const tools_surface_1 = require("../repertoire/tools-surface");
 const tools_1 = require("../repertoire/tools");
 const habit_policy_1 = require("../rsvp/habit-policy");
+const spend_ledger_1 = require("../rsvp/spend-ledger");
 const run_ledger_1 = require("../heart/run-ledger");
 const autonomy_budget_1 = require("../heart/autonomy-budget");
 function isUsageData(value) {
@@ -108,14 +109,29 @@ function habitRunLedgerBase(habitRun) {
 }
 function recordHabitRunLedger(habitRun, lifecycle, endedAt) {
     const usage = extractUsageFromHabitResults(habitRun.results);
-    (0, run_ledger_1.appendRunLedgerRecordNonFatal)(habitRun.agentRoot, (0, run_ledger_1.createRunLedgerRecord)({
+    const record = (0, run_ledger_1.createRunLedgerRecord)({
         ...habitRunLedgerBase(habitRun),
         lifecycle,
         ...(endedAt ? { endedAt } : {}),
         ...(lifecycle === "completed" || lifecycle === "error"
             ? { usage: (0, run_ledger_1.usageMetadataFromUsageData)(usage, usage ? "provider" : "none") }
             : {}),
-    }));
+    });
+    (0, run_ledger_1.appendRunLedgerRecordNonFatal)(habitRun.agentRoot, record);
+    if (habitRun.rsvpPolicy) {
+        try {
+            (0, spend_ledger_1.recordRsvpSpendLedgerRun)(habitRun.agentRoot, record);
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "rsvp",
+                event: "rsvp.spend_ledger_record_error",
+                message: "failed to record RSVP spend ledger row",
+                meta: { runId: record.runId, lifecycle, error: String(error) },
+            });
+        }
+    }
 }
 function reserveHabitAutonomyBudget(habitRun, nowIso) {
     const target = {

package/package.json

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