@ouro.bot/cli 0.1.0-alpha.83 → 0.1.0-alpha.831

package/dist/senses/{bluebubbles-model.js → bluebubbles/model.js}

@@ -1,7 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlueBubblesIgnoredEventError = void 0;
+exports.describeBlueBubblesReaction = describeBlueBubblesReaction;
+exports.renderBlueBubblesReactionText = renderBlueBubblesReactionText;
 exports.normalizeBlueBubblesEvent = normalizeBlueBubblesEvent;
-const runtime_1 = require("../nerves/runtime");
+const runtime_1 = require("../../nerves/runtime");
+const render_1 = require("../../heart/attachments/render");
+const bluebubbles_1 = require("../../heart/attachments/sources/bluebubbles");
+const IGNORABLE_GUIDLESS_EVENT_TYPES = new Set([
+    "chat-read-status-changed",
+]);
+class BlueBubblesIgnoredEventError extends Error {
+    eventType;
+    constructor(eventType, message) {
+        super(message);
+        this.name = "BlueBubblesIgnoredEventError";
+        this.eventType = eventType;
+    }
+}
+exports.BlueBubblesIgnoredEventError = BlueBubblesIgnoredEventError;
 function asRecord(value) {
     return value && typeof value === "object" && !Array.isArray(value)
         ? value
@@ -75,9 +92,11 @@ function buildChatRef(data, threadOriginatorGuid) {
 }
 function extractSender(data, chat) {
     const handle = asRecord(data.handle) ?? asRecord(data.sender) ?? null;
-    const rawId = readString(handle, "address") ??
+    const observedRawId = readString(handle, "address") ??
         readString(handle, "id") ??
-        readString(data, "senderId") ??
+        readString(data, "senderId");
+    const observed = typeof observedRawId === "string" && observedRawId.trim().length > 0;
+    const rawId = observedRawId ??
         chat.chatIdentifier ??
         chat.chatGuid ??
         "unknown";
@@ -88,6 +107,7 @@ function extractSender(data, chat) {
         externalId,
         rawId,
         displayName,
+        observed,
     };
 }
 function extractAttachments(data) {
@@ -107,18 +127,14 @@ function extractAttachments(data) {
 function formatAttachmentText(attachments) {
     if (attachments.length === 0)
         return "";
+    const renderable = attachments
+        .filter((attachment) => typeof attachment.guid === "string" && attachment.guid.trim().length > 0)
+        .map((attachment) => (0, bluebubbles_1.buildBlueBubblesAttachmentRecord)(attachment));
+    if (renderable.length > 0) {
+        return (0, render_1.renderAttachmentBlock)(renderable);
+    }
     const [first] = attachments;
-    const mime = first.mimeType ?? "";
-    const label = mime.startsWith("image/")
-        ? "image attachment"
-        : mime.startsWith("audio/")
-            ? "audio attachment"
-            : "attachment";
-    const name = first.transferName ? `: ${first.transferName}` : "";
-    const dimensions = typeof first.width === "number" && typeof first.height === "number" && first.width > 0 && first.height > 0
-        ? ` (${first.width}x${first.height})`
-        : "";
-    return `[${label}${name}${dimensions}]`;
+    return `[attachment: ${first.transferName?.trim() || "unknown"}]`;
 }
 function formatMessageText(data, attachments) {
     const text = readString(data, "text")?.trim() ?? "";
@@ -127,16 +143,91 @@ function formatMessageText(data, attachments) {
         if (balloonBundleId === "com.apple.messages.URLBalloonProvider") {
             return `${text}\n[link preview attached]`;
         }
+        // B2 fix: when text and attachments both exist, append the attachment
+        // marker so downstream senses can see the guid/filename. Previously the
+        // marker was dropped whenever text was non-empty, which hid images from
+        // the agent when the user captioned a screenshot.
+        if (attachments.length > 0) {
+            return `${text}\n${formatAttachmentText(attachments)}`;
+        }
         return text;
     }
     return formatAttachmentText(attachments);
 }
 function normalizeReactionName(value) {
+    // chat.db stores associated_message_type as an integer; BlueBubbles forwards it
+    // as either the integer, its decimal string, or a name ("love", "-love").
+    if (typeof value === "number") {
+        return Number.isFinite(value) && value !== 0 ? String(value) : undefined;
+    }
     if (typeof value !== "string")
         return undefined;
     const trimmed = value.trim();
     return trimmed ? trimmed.toLowerCase() : undefined;
 }
+/**
+ * iMessage tapbacks: associated_message_type 2000-2006 add a tapback, 3000-3006
+ * remove the same tapback. BlueBubbles may send either the code or the name.
+ */
+const REACTION_VOCABULARY = [
+    { code: 2000, name: "love", verb: "loved", noun: "love" },
+    { code: 2001, name: "like", verb: "liked", noun: "like" },
+    { code: 2002, name: "dislike", verb: "disliked", noun: "dislike" },
+    { code: 2003, name: "laugh", verb: "laughed at", noun: "laugh" },
+    { code: 2004, name: "emphasize", verb: "emphasized", noun: "emphasis" },
+    { code: 2005, name: "question", verb: "questioned", noun: "question" },
+    { code: 2006, name: "custom", verb: "reacted with custom emoji to", noun: "custom emoji" },
+];
+const REACTION_EXCERPT_MAX_LENGTH = 80;
+function describeBlueBubblesReaction(raw, rawTransportValue = raw) {
+    const stripped = raw.startsWith("-") ? raw.slice(1) : raw;
+    const code = /^\d+$/.test(stripped) ? Number(stripped) : undefined;
+    const removal = raw.startsWith("-") || (code !== undefined && code >= 3000 && code < 4000);
+    const action = removal ? "remove" : "add";
+    const entry = REACTION_VOCABULARY.find((candidate) => candidate.name === stripped || candidate.code === code || candidate.code + 1000 === code);
+    const canonicalValue = entry?.name ?? "unknown";
+    if (!entry)
+        return { raw, rawTransportValue, canonicalValue, action };
+    return {
+        raw,
+        rawTransportValue,
+        canonicalValue,
+        action,
+        verb: entry.verb,
+        noun: entry.noun,
+    };
+}
+function reactionExcerpt(text) {
+    return text.length > REACTION_EXCERPT_MAX_LENGTH
+        ? `${text.slice(0, REACTION_EXCERPT_MAX_LENGTH - 3)}...`
+        : text;
+}
+function reactionTargetPhrase(target) {
+    const text = target.text?.trim();
+    if (text) {
+        const owner = target.fromMe === true ? "your" : target.fromMe === false ? "their" : "a";
+        return `${owner} message: "${reactionExcerpt(text)}"`;
+    }
+    // Never hand the agent a bare "reacted with love" stub — say plainly that the
+    // referent is missing so it can ask instead of guessing what was approved.
+    return target.guid
+        ? `an unidentified message (target guid ${target.guid}; its text could not be resolved)`
+        : "an unidentified message (the reaction carried no target message reference)";
+}
+/**
+ * Render a reaction as speech the agent can act on: what the tapback was, whether
+ * it was added or removed, and which message it points at.
+ */
+function renderBlueBubblesReactionText(reaction, target) {
+    const phrase = reactionTargetPhrase(target);
+    if (reaction.action === "remove") {
+        const noun = reaction.noun ?? reaction.raw.replace(/^-/, "");
+        return `removed their ${noun} reaction from ${phrase}`;
+    }
+    return reaction.verb
+        ? `${reaction.verb} ${phrase}`
+        : `reacted with ${reaction.raw} to ${phrase}`;
+}
 function stripPartPrefix(guid) {
     if (!guid)
         return undefined;
@@ -144,10 +235,10 @@ function stripPartPrefix(guid) {
     const marker = trimmed.lastIndexOf("/");
     return marker >= 0 ? trimmed.slice(marker + 1) : trimmed;
 }
-function buildMutationText(mutationType, data, reactionName) {
-    if (mutationType === "reaction") {
-        return `reacted with ${reactionName}`;
-    }
+// Reactions never reach here: `detectMutationType` returns "reaction" only when a
+// reaction name was decoded, and that same name produces the descriptor the caller
+// renders with `renderBlueBubblesReactionText` instead.
+function buildMutationText(mutationType, data) {
     if (mutationType === "edit") {
         const editedText = readString(data, "text")?.trim() ?? "";
         return editedText ? `edited message: ${editedText}` : "edited a message";
@@ -164,17 +255,35 @@ function detectMutationType(eventType, data, reactionName) {
     if (reactionName)
         return "reaction";
     if (eventType === "updated-message") {
-        if (readNumber(data, "dateRetracted"))
+        if (readNumber(data, "dateRetracted") !== undefined)
             return "unsend";
-        if (readNumber(data, "dateEdited"))
+        if (readNumber(data, "dateEdited") !== undefined)
             return "edit";
-        if (readNumber(data, "dateRead"))
+        if (readNumber(data, "dateRead") !== undefined)
             return "read";
-        if (readBoolean(data, "isDelivered") || readNumber(data, "dateDelivered"))
+        if (readBoolean(data, "isDelivered") || readNumber(data, "dateDelivered") !== undefined)
             return "delivery";
     }
     return null;
 }
+function readProviderRevision(data) {
+    const value = data.revision;
+    if (typeof value !== "string" && typeof value !== "number")
+        return undefined;
+    const normalized = String(value).trim();
+    return normalized || undefined;
+}
+function mutationEffectiveTimestamp(mutationType, data) {
+    if (mutationType === "reaction")
+        return readNumber(data, "dateCreated");
+    if (mutationType === "edit")
+        return readNumber(data, "dateEdited");
+    if (mutationType === "unsend")
+        return readNumber(data, "dateRetracted");
+    if (mutationType === "read")
+        return readNumber(data, "dateRead");
+    return readNumber(data, "dateDelivered");
+}
 function normalizeBlueBubblesEvent(payload) {
     const envelope = asRecord(payload);
     const eventType = readString(envelope, "type")?.trim() ?? "";
@@ -198,16 +307,33 @@ function normalizeBlueBubblesEvent(payload) {
             message: "ignored bluebubbles payload without guid",
             meta: { eventType },
         });
+        if (IGNORABLE_GUIDLESS_EVENT_TYPES.has(eventType)) {
+            throw new BlueBubblesIgnoredEventError(eventType, `Ignored BlueBubbles event '${eventType}' without data.guid`);
+        }
         throw new Error("BlueBubbles payload is missing data.guid");
     }
     const threadOriginatorGuid = readString(data, "threadOriginatorGuid")?.trim() || undefined;
     const chat = buildChatRef(data, threadOriginatorGuid);
     const sender = extractSender(data, chat);
     const timestamp = readNumber(data, "dateCreated") ?? Date.now();
-    const fromMe = readBoolean(data, "isFromMe") ?? false;
+    const fromMe = readBoolean(data, "isFromMe") ?? null;
     const attachments = extractAttachments(data);
     const reactionName = normalizeReactionName(data.associatedMessageType);
+    const reaction = reactionName
+        ? describeBlueBubblesReaction(reactionName, String(data.associatedMessageType))
+        : undefined;
+    const targetMessageGuid = reaction
+        ? stripPartPrefix(readString(data, "associatedMessageGuid"))
+        : undefined;
     const mutationType = detectMutationType(eventType, data, reactionName);
+    const revision = mutationType ? readProviderRevision(data) : undefined;
+    const effectiveTimestamp = mutationType
+        ? mutationEffectiveTimestamp(mutationType, data)
+        : undefined;
+    const editedText = mutationType === "edit" ? readString(data, "text") : undefined;
+    const retractionTimestamp = mutationType === "unsend"
+        ? readNumber(data, "dateRetracted")
+        : undefined;
     const requiresRepair = (readBoolean(data, "hasPayloadData") ?? false) ||
         attachments.length > 0 ||
         eventType === "updated-message";
@@ -217,16 +343,21 @@ function normalizeBlueBubblesEvent(payload) {
             eventType,
             mutationType,
             messageGuid,
-            targetMessageGuid: mutationType === "reaction"
-                ? stripPartPrefix(readString(data, "associatedMessageGuid"))
-                : undefined,
+            targetMessageGuid,
             timestamp,
             fromMe,
             sender,
             chat,
             shouldNotifyAgent: mutationType === "reaction" || mutationType === "edit" || mutationType === "unsend",
-            textForAgent: buildMutationText(mutationType, data, reactionName),
+            textForAgent: reaction
+                ? renderBlueBubblesReactionText(reaction, { guid: targetMessageGuid })
+                : buildMutationText(mutationType, data),
             requiresRepair,
+            ...(reaction ? { reaction } : {}),
+            ...(editedText !== undefined ? { editedText } : {}),
+            ...(revision ? { revision } : {}),
+            ...(effectiveTimestamp !== undefined ? { effectiveTimestamp } : {}),
+            ...(retractionTimestamp !== undefined ? { retractionTimestamp } : {}),
         }
         : {
             kind: "message",
@@ -236,7 +367,7 @@ function normalizeBlueBubblesEvent(payload) {
             fromMe,
             sender,
             chat,
-            text: readString(data, "text")?.trim() ?? "",
+            text: readString(data, "text") ?? "",
             textForAgent: formatMessageText(data, attachments),
             attachments,
             balloonBundleId: readString(data, "balloonBundleId")?.trim() || undefined,

package/dist/senses/{bluebubbles-mutation-log.js → bluebubbles/mutation-log.js}

@@ -35,12 +35,13 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getBlueBubblesMutationLogPath = getBlueBubblesMutationLogPath;
 exports.recordBlueBubblesMutation = recordBlueBubblesMutation;
+exports.listRecordedBlueBubblesMutations = listRecordedBlueBubblesMutations;
 exports.listBlueBubblesRecoveryCandidates = listBlueBubblesRecoveryCandidates;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
-const runtime_1 = require("../nerves/runtime");
-const identity_1 = require("../heart/identity");
-const config_1 = require("../heart/config");
+const runtime_1 = require("../../nerves/runtime");
+const identity_1 = require("../../heart/identity");
+const config_1 = require("../../heart/config");
 function getBlueBubblesMutationLogPath(agentName, sessionKey) {
     return path.join((0, identity_1.getAgentRoot)(agentName), "state", "senses", "bluebubbles", "mutations", `${(0, config_1.sanitizeKey)(sessionKey)}.ndjson`);
 }
@@ -73,7 +74,7 @@ function recordBlueBubblesMutation(agentName, event) {
     });
     return filePath;
 }
-function listBlueBubblesRecoveryCandidates(agentName) {
+function readBlueBubblesMutationRows(agentName) {
     const rootDir = path.join((0, identity_1.getAgentRoot)(agentName), "state", "senses", "bluebubbles", "mutations");
     let files;
     try {
@@ -82,7 +83,7 @@ function listBlueBubblesRecoveryCandidates(agentName) {
     catch {
         return [];
     }
-    const deduped = new Map();
+    const entries = [];
     for (const file of files.filter((entry) => entry.endsWith(".ndjson")).sort()) {
         const filePath = path.join(rootDir, file);
         let raw = "";
@@ -98,19 +99,29 @@ function listBlueBubblesRecoveryCandidates(agentName) {
                 continue;
             try {
                 const entry = JSON.parse(trimmed);
-                if (typeof entry.messageGuid !== "string"
-                    || !entry.messageGuid.trim()
-                    || entry.fromMe
-                    || entry.shouldNotifyAgent
-                    || (entry.mutationType !== "read" && entry.mutationType !== "delivery")) {
+                if (typeof entry.messageGuid !== "string" || !entry.messageGuid.trim())
                     continue;
-                }
-                deduped.set(entry.messageGuid, entry);
+                entries.push(entry);
             }
             catch {
-                // ignore malformed recovery candidates
+                // Keep malformed legacy rows inert while retaining readable audit rows.
             }
         }
     }
+    return entries;
+}
+function listRecordedBlueBubblesMutations(agentName) {
+    return readBlueBubblesMutationRows(agentName).filter((entry) => (typeof entry.sessionKey === "string" && entry.sessionKey.trim().length > 0));
+}
+function listBlueBubblesRecoveryCandidates(agentName) {
+    const deduped = new Map();
+    for (const entry of readBlueBubblesMutationRows(agentName)) {
+        if (entry.fromMe !== false
+            || entry.shouldNotifyAgent
+            || (entry.mutationType !== "read" && entry.mutationType !== "delivery")) {
+            continue;
+        }
+        deduped.set(entry.messageGuid, entry);
+    }
     return [...deduped.values()].sort((left, right) => left.recordedAt.localeCompare(right.recordedAt));
 }

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

@@ -0,0 +1,308 @@
+"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.BLUEBUBBLES_OUTBOUND_STATE_POLICY_VERSION = void 0;
+exports.blueBubblesOutboundRecordPath = blueBubblesOutboundRecordPath;
+exports.buildBlueBubblesRouteProof = buildBlueBubblesRouteProof;
+exports.buildBlueBubblesAttachmentProof = buildBlueBubblesAttachmentProof;
+exports.readBlueBubblesOutboundRecord = readBlueBubblesOutboundRecord;
+exports.readBlueBubblesOutboundRecordByIdempotencyKey = readBlueBubblesOutboundRecordByIdempotencyKey;
+exports.reserveBlueBubblesOutbound = reserveBlueBubblesOutbound;
+exports.markBlueBubblesOutboundAccepted = markBlueBubblesOutboundAccepted;
+exports.markBlueBubblesOutboundEnqueued = markBlueBubblesOutboundEnqueued;
+exports.markBlueBubblesOutboundLocalVisible = markBlueBubblesOutboundLocalVisible;
+exports.markBlueBubblesOutboundDelivered = markBlueBubblesOutboundDelivered;
+exports.markBlueBubblesOutboundFailed = markBlueBubblesOutboundFailed;
+exports.markBlueBubblesOutboundPendingManualVerification = markBlueBubblesOutboundPendingManualVerification;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const runtime_1 = require("../../nerves/runtime");
+exports.BLUEBUBBLES_OUTBOUND_STATE_POLICY_VERSION = "bluebubbles-outbound-state/v1";
+function sha256Hex(input) {
+    return (0, node_crypto_1.createHash)("sha256").update(input).digest("hex");
+}
+function hash(input) {
+    return `sha256:${sha256Hex(canonicalJson(input))}`;
+}
+function canonicalJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map((entry) => canonicalJson(entry)).join(",")}]`;
+    if (value && typeof value === "object") {
+        const record = value;
+        return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+function nowIso(input) {
+    return input ?? new Date().toISOString();
+}
+function recordIdFor(idempotencyKey) {
+    return `bbout_${sha256Hex(`bluebubbles-outbound:${idempotencyKey}`).slice(0, 32)}`;
+}
+function normalizeText(value) {
+    return value.trim().replace(/\s+/g, " ");
+}
+function endpointOrigin(serverUrl) {
+    const parsed = new URL(serverUrl);
+    return parsed.origin;
+}
+function blueBubblesOutboundDir(agentRoot) {
+    return path.join(agentRoot, "state", "bluebubbles", "outbound");
+}
+function blueBubblesOutboundRecordPath(agentRoot, recordId) {
+    return path.join(blueBubblesOutboundDir(agentRoot), `${recordId}.json`);
+}
+function buildBlueBubblesRouteProof(chat) {
+    const participantHandles = [...chat.participantHandles].sort();
+    const base = {
+        chatGuid: chat.chatGuid?.trim() || null,
+        chatIdentifier: chat.chatIdentifier?.trim() || null,
+        sendTarget: chat.sendTarget,
+        sessionKey: chat.sessionKey,
+        isGroup: chat.isGroup,
+        participantHandles,
+    };
+    return {
+        chatGuid: base.chatGuid,
+        chatIdentifier: base.chatIdentifier,
+        sendTarget: base.sendTarget,
+        sessionKey: base.sessionKey,
+        isGroup: base.isGroup,
+        participantHandlesHash: hash(participantHandles),
+        routeHash: hash(base),
+        rawParticipantHandlesStored: false,
+    };
+}
+function buildBlueBubblesAttachmentProof(input) {
+    const proof = {
+        endpointOrigin: endpointOrigin(input.serverUrl),
+        accountId: input.accountId?.trim() || null,
+    };
+    return {
+        ...proof,
+        identityHash: hash(proof),
+        secretStored: false,
+    };
+}
+function buildRecord(input) {
+    const createdAt = nowIso(input.now);
+    const idempotencyKey = input.idempotencyKey.trim();
+    const text = normalizeText(input.text);
+    return {
+        schemaVersion: 1,
+        policyVersion: exports.BLUEBUBBLES_OUTBOUND_STATE_POLICY_VERSION,
+        recordId: recordIdFor(idempotencyKey),
+        idempotencyKey,
+        idempotencyHash: hash(idempotencyKey),
+        status: "reserved",
+        createdAt,
+        updatedAt: createdAt,
+        tempGuid: input.tempGuid.trim(),
+        routeProof: buildBlueBubblesRouteProof(input.chat),
+        attachmentProof: buildBlueBubblesAttachmentProof(input.attachment),
+        textHash: hash(text),
+        textLength: text.length,
+        ...(input.replyToMessageGuid?.trim() ? { replyToMessageGuidHash: hash(input.replyToMessageGuid.trim()) } : {}),
+        contentStored: false,
+    };
+}
+function writeJsonAtomic(filePath, value) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+    fs.writeFileSync(tmp, `${JSON.stringify(value, null, 2)}\n`, "utf-8");
+    fs.renameSync(tmp, filePath);
+}
+function readJson(filePath) {
+    if (!fs.existsSync(filePath))
+        return null;
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+}
+function isOutboundRecord(value) {
+    const row = value;
+    return !!row
+        && row.schemaVersion === 1
+        && row.policyVersion === exports.BLUEBUBBLES_OUTBOUND_STATE_POLICY_VERSION
+        && typeof row.recordId === "string"
+        && typeof row.idempotencyKey === "string"
+        && typeof row.idempotencyHash === "string"
+        && typeof row.status === "string"
+        && typeof row.createdAt === "string"
+        && typeof row.updatedAt === "string"
+        && typeof row.tempGuid === "string"
+        && typeof row.textHash === "string"
+        && typeof row.textLength === "number"
+        && row.contentStored === false;
+}
+function readBlueBubblesOutboundRecord(agentRoot, recordId) {
+    try {
+        const parsed = readJson(blueBubblesOutboundRecordPath(agentRoot, recordId));
+        return isOutboundRecord(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function readBlueBubblesOutboundRecordByIdempotencyKey(agentRoot, idempotencyKey) {
+    return readBlueBubblesOutboundRecord(agentRoot, recordIdFor(idempotencyKey.trim()));
+}
+function writeBlueBubblesOutboundRecord(agentRoot, record) {
+    writeJsonAtomic(blueBubblesOutboundRecordPath(agentRoot, record.recordId), record);
+    return record;
+}
+function identityMatches(left, right) {
+    return left.routeProof.routeHash === right.routeProof.routeHash
+        && left.attachmentProof.identityHash === right.attachmentProof.identityHash
+        && left.textHash === right.textHash
+        && left.replyToMessageGuidHash === right.replyToMessageGuidHash;
+}
+function emitDuplicate(record) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "senses",
+        event: "senses.bluebubbles_outbound_duplicate",
+        message: "duplicate bluebubbles outbound reservation suppressed",
+        meta: { recordId: record.recordId, status: record.status },
+    });
+}
+function markPendingManualVerification(agentRoot, record, decidedAt, reason) {
+    const updated = writeBlueBubblesOutboundRecord(agentRoot, {
+        ...record,
+        status: "pending-manual-verification",
+        updatedAt: decidedAt,
+        manualVerificationReason: reason,
+    });
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "senses",
+        event: "senses.bluebubbles_outbound_pending_manual_verification",
+        message: "bluebubbles outbound requires manual verification",
+        meta: { recordId: updated.recordId, reason },
+    });
+    return updated;
+}
+function reserveBlueBubblesOutbound(input) {
+    const record = buildRecord(input);
+    const filePath = blueBubblesOutboundRecordPath(input.agentRoot, record.recordId);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    try {
+        const fd = fs.openSync(filePath, "wx");
+        try {
+            fs.writeFileSync(fd, `${JSON.stringify(record, null, 2)}\n`, "utf-8");
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.bluebubbles_outbound_reserved",
+            message: "reserved bluebubbles outbound idempotency key",
+            meta: { recordId: record.recordId, textLength: record.textLength },
+        });
+        return { status: "reserved", record };
+    }
+    catch (error) {
+        /* v8 ignore next -- non-EEXIST filesystem failures are rethrown fail-closed; hard to trigger portably after mkdir succeeds @preserve */
+        if (!isNodeFileExistsError(error))
+            throw error;
+        const existing = readBlueBubblesOutboundRecord(input.agentRoot, record.recordId);
+        if (!existing)
+            throw new Error(`bluebubbles outbound reservation is unreadable: ${record.recordId}`);
+        if (identityMatches(existing, record)) {
+            emitDuplicate(existing);
+            return { status: "duplicate", record: existing };
+        }
+        const updated = markPendingManualVerification(input.agentRoot, existing, nowIso(input.now), "identity-proof-mismatch");
+        return { status: "pending-manual-verification", reason: "identity-proof-mismatch", record: updated };
+    }
+}
+function isNodeFileExistsError(error) {
+    return typeof error === "object" && error !== null && error.code === "EEXIST";
+}
+function updateStatus(agentRoot, recordId, status, updatedAt, patch) {
+    const existing = readBlueBubblesOutboundRecord(agentRoot, recordId);
+    if (!existing)
+        throw new Error(`bluebubbles outbound record not found: ${recordId}`);
+    const updated = writeBlueBubblesOutboundRecord(agentRoot, {
+        ...existing,
+        ...patch,
+        status,
+        updatedAt,
+    });
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.bluebubbles_outbound_state_changed",
+        message: "bluebubbles outbound state changed",
+        meta: { recordId, status },
+    });
+    return updated;
+}
+function markBlueBubblesOutboundAccepted(input) {
+    return updateStatus(input.agentRoot, input.recordId, "accepted", input.acceptedAt, {
+        acceptedAt: input.acceptedAt,
+        ...(input.messageGuid?.trim() ? { messageGuid: input.messageGuid.trim() } : {}),
+    });
+}
+function markBlueBubblesOutboundEnqueued(input) {
+    return updateStatus(input.agentRoot, input.recordId, "enqueued", input.enqueuedAt, {
+        enqueuedAt: input.enqueuedAt,
+        messageGuid: input.messageGuid.trim(),
+    });
+}
+function markBlueBubblesOutboundLocalVisible(input) {
+    return updateStatus(input.agentRoot, input.recordId, "local-visible", input.visibleAt, {
+        localVisibleAt: input.visibleAt,
+        messageGuid: input.messageGuid.trim(),
+        ...(input.tempGuid?.trim() ? { tempGuid: input.tempGuid.trim() } : {}),
+    });
+}
+function markBlueBubblesOutboundDelivered(input) {
+    return updateStatus(input.agentRoot, input.recordId, "delivered", input.deliveredAt, {
+        deliveredAt: input.deliveredAt,
+        ...(input.messageGuid?.trim() ? { messageGuid: input.messageGuid.trim() } : {}),
+    });
+}
+function markBlueBubblesOutboundFailed(input) {
+    return updateStatus(input.agentRoot, input.recordId, "failed", input.failedAt, {
+        failedAt: input.failedAt,
+        failureReason: input.reason.slice(0, 500),
+    });
+}
+function markBlueBubblesOutboundPendingManualVerification(input) {
+    const existing = readBlueBubblesOutboundRecord(input.agentRoot, input.recordId);
+    if (!existing)
+        throw new Error(`bluebubbles outbound record not found: ${input.recordId}`);
+    return markPendingManualVerification(input.agentRoot, existing, input.decidedAt, input.reason);
+}