@openclaw/imessage 2026.8.1-beta.2 → 2026.8.1

package/dist/{question-reactions-DVe50UhB.js → question-reactions-viP7ZcyG.js}

@@ -1,4 +1,5 @@
-import { E as resolveIMessageReactionContext, K as __exportAll } from "./group-policy-DF9xSdik.js";
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { t as resolveIMessageReactionContext } from "./reaction-context-BAYI7pz0.js";
 import { createQuestionReactionTargetStore, questionGatewayRuntime } from "openclaw/plugin-sdk/question-gateway-runtime";
 //#region extensions/imessage/src/question-reactions.ts
 var question_reactions_exports = /* @__PURE__ */ __exportAll({

package/dist/reaction-context-BAYI7pz0.js

@@ -0,0 +1,105 @@
+//#region extensions/imessage/src/monitor/reaction-context.ts
+const TAPBACK_TEXT_PATTERNS = [
+	{
+		prefix: "loved",
+		action: "added",
+		emoji: "❤️"
+	},
+	{
+		prefix: "liked",
+		action: "added",
+		emoji: "👍"
+	},
+	{
+		prefix: "disliked",
+		action: "added",
+		emoji: "👎"
+	},
+	{
+		prefix: "laughed at",
+		action: "added",
+		emoji: "😂"
+	},
+	{
+		prefix: "emphasized",
+		action: "added",
+		emoji: "‼️"
+	},
+	{
+		prefix: "questioned",
+		action: "added",
+		emoji: "❓"
+	},
+	{
+		prefix: "removed a heart from",
+		action: "removed",
+		emoji: "❤️"
+	},
+	{
+		prefix: "removed a like from",
+		action: "removed",
+		emoji: "👍"
+	},
+	{
+		prefix: "removed a dislike from",
+		action: "removed",
+		emoji: "👎"
+	},
+	{
+		prefix: "removed a laugh from",
+		action: "removed",
+		emoji: "😂"
+	},
+	{
+		prefix: "removed an emphasis from",
+		action: "removed",
+		emoji: "‼️"
+	},
+	{
+		prefix: "removed a question from",
+		action: "removed",
+		emoji: "❓"
+	}
+];
+function normalizeReactionValue(value) {
+	return typeof value === "string" ? value.trim().replace(/^p:\d+\//iu, "") || void 0 : void 0;
+}
+function resolveReactionTargetGuidCandidates(...values) {
+	const candidates = [];
+	for (const value of values) {
+		if (typeof value !== "string") continue;
+		const raw = value.trim();
+		if (!raw) continue;
+		const normalized = raw.replace(/^p:\d+\//iu, "");
+		for (const candidate of [normalized, raw]) if (candidate && !candidates.includes(candidate)) candidates.push(candidate);
+	}
+	return candidates;
+}
+function resolveTapbackTextContext(bodyText) {
+	const lower = bodyText.toLowerCase();
+	for (const pattern of TAPBACK_TEXT_PATTERNS) {
+		if (!lower.startsWith(pattern.prefix)) continue;
+		const afterPrefix = bodyText.slice(pattern.prefix.length).trim();
+		if (!/^(?:"[\s\S]*"|“[\s\S]*”)$/u.test(afterPrefix)) continue;
+		return {
+			action: pattern.action,
+			emoji: pattern.emoji,
+			targetText: afterPrefix.slice(1, -1).trim()
+		};
+	}
+	return null;
+}
+function resolveIMessageReactionContext(message, bodyText) {
+	if (message.is_reaction === true || message.is_tapback === true || typeof message.associated_message_type === "number" && Number.isFinite(message.associated_message_type) && message.associated_message_type >= 2e3 && message.associated_message_type < 4e3) {
+		const targetGuids = resolveReactionTargetGuidCandidates(message.reacted_to_guid, message.associated_message_guid);
+		return {
+			action: message.is_reaction_add === false ? "removed" : "added",
+			emoji: normalizeReactionValue(message.reaction_emoji) ?? normalizeReactionValue(message.reaction_type) ?? "reaction",
+			targetGuid: targetGuids[0],
+			targetGuids
+		};
+	}
+	return resolveTapbackTextContext(bodyText);
+}
+//#endregion
+export { resolveIMessageReactionContext as t };

package/dist/{remote-file-DLwO9ved.js → remote-file-6mCj2ZBy.js}

@@ -1,5 +1,5 @@
-import { p as resolveLocalIMessageChatDbPath, u as expandIMessageUserPath } from "./accounts-D00Njxg2.js";
-import { g as isIMessageEmailChatIdentifier, h as chatContextFromIMessageTarget, l as resolveIMessageCachedResourceBinding, u as resolveIMessageMessageId } from "./monitor-reply-cache-DKlYGd5x.js";
+import { p as resolveLocalIMessageChatDbPath, u as expandIMessageUserPath } from "./accounts-CCirBEIm.js";
+import { d as resolveIMessageCachedResourceBinding, f as resolveIMessageMessageId, g as isIMessageEmailChatIdentifier, h as chatContextFromIMessageTarget } from "./sanitize-outbound-Du-r1lNQ.js";
 import path from "node:path";
 import { normalizeScpRemoteHost } from "openclaw/plugin-sdk/host-runtime";
 import { createSubsystemLogger } from "openclaw/plugin-sdk/runtime-env";
@@ -121,7 +121,11 @@ function checkIMessageResourceBinding(params) {
          FROM message m
          JOIN chat_message_join cmj ON cmj.message_id = m.ROWID
          JOIN chat c ON c.ROWID = cmj.chat_id
-         WHERE m.guid = ?`).all(messageGuid).some((row) => (!hasChatId || row.chatId === chatId) && (expectedChatGuids.length === 0 || matchesAnyChatCandidate(row.chatGuid, expectedChatGuids)) && (expectedChatIdentifiers.length === 0 || matchesAnyChatCandidate(row.chatIdentifier, expectedChatIdentifiers)) && (identifierChatGuids.length === 0 || matchesAnyChatCandidate(row.chatGuid, identifierChatGuids))) ? "match" : "mismatch";
+         WHERE m.guid = ?`).all(messageGuid).map((row) => ({
+			chatId: row.chatId,
+			chatGuid: row.chatGuid,
+			chatIdentifier: row.chatIdentifier
+		})).some((row) => (!hasChatId || row.chatId === chatId) && (expectedChatGuids.length === 0 || matchesAnyChatCandidate(row.chatGuid, expectedChatGuids)) && (expectedChatIdentifiers.length === 0 || matchesAnyChatCandidate(row.chatIdentifier, expectedChatIdentifiers)) && (identifierChatGuids.length === 0 || matchesAnyChatCandidate(row.chatGuid, identifierChatGuids))) ? "match" : "mismatch";
 	} catch {
 		return "unavailable";
 	} finally {

package/dist/rolldown-runtime-D7D4PA-g.js

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };

package/dist/runtime-Cza4CY5T.js

@@ -0,0 +1,8 @@
+import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
+//#region extensions/imessage/src/runtime.ts
+const { getRuntime: getIMessageRuntime, setRuntime: setIMessageRuntime, tryGetRuntime: getOptionalIMessageRuntime } = createPluginRuntimeStore({
+	pluginId: "imessage",
+	errorMessage: "iMessage runtime not initialized"
+});
+//#endregion
+export { getOptionalIMessageRuntime as n, setIMessageRuntime as r, getIMessageRuntime as t };

package/dist/runtime-api.js

@@ -1,15 +1,16 @@
-import { F as imessageMessageActions, I as probeIMessage, h as normalizeIMessageMessagingTarget, l as chunkTextForOutbound, m as looksLikeIMessageTargetId, n as resolveIMessageGroupToolPolicy, t as resolveIMessageGroupRequireMention } from "./group-policy-DF9xSdik.js";
-import { o as resolveIMessageAccount } from "./accounts-D00Njxg2.js";
-import { m as setIMessageRuntime } from "./monitor-reply-cache-DKlYGd5x.js";
-import { n as IMessageConfigSchema } from "./config-schema-DV0KP5nC.js";
-import { t as sendMessageIMessage } from "./send-BUXW76tw.js";
-import { t as monitorIMessageProvider } from "./monitor-DnxJ8pW9.js";
-import { buildComputedAccountStatusSnapshot, collectStatusIssuesFromLastError } from "openclaw/plugin-sdk/status-helpers";
+import { o as resolveIMessageAccount } from "./accounts-CCirBEIm.js";
+import { c as normalizeIMessageMessagingTarget, d as imessageMessageActions, f as probeIMessage, n as resolveIMessageGroupToolPolicy, s as looksLikeIMessageTargetId, t as resolveIMessageGroupRequireMention } from "./group-policy-Dvc-BcWo.js";
+import { r as setIMessageRuntime } from "./runtime-Cza4CY5T.js";
+import { n as IMessageConfigSchema } from "./config-schema-DuGbA8Kp.js";
+import { t as sendMessageIMessage } from "./send-mgWPKqSV.js";
+import { t as monitorIMessageProvider } from "./monitor-BywJn1QW.js";
 import { formatTrimmedAllowFromEntries } from "openclaw/plugin-sdk/channel-config-helpers";
-import { PAIRING_APPROVED_MESSAGE } from "openclaw/plugin-sdk/channel-status";
+import { buildComputedAccountStatusSnapshot, collectStatusIssuesFromLastError } from "openclaw/plugin-sdk/status-helpers";
+import { resolveChannelMediaMaxBytes } from "openclaw/plugin-sdk/account-helpers";
+import { chunkTextForOutbound } from "openclaw/plugin-sdk/text-chunking";
 import { DEFAULT_ACCOUNT_ID, getChatChannelMeta } from "openclaw/plugin-sdk/core";
-import { resolveChannelMediaMaxBytes } from "openclaw/plugin-sdk/media-runtime";
 import { buildChannelConfigSchema } from "openclaw/plugin-sdk/channel-config-schema";
+import { PAIRING_APPROVED_MESSAGE } from "openclaw/plugin-sdk/channel-status";
 //#region extensions/imessage/src/config-accessors.ts
 function resolveIMessageConfigAllowFrom(params) {
 	return (resolveIMessageAccount(params).config.allowFrom ?? []).map((entry) => String(entry));

package/dist/{sanitize-outbound-CoTZLXMw.js → sanitize-outbound-Du-r1lNQ.js}

@@ -1,15 +1,352 @@
-import { u as expandIMessageUserPath } from "./accounts-D00Njxg2.js";
-import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { u as expandIMessageUserPath } from "./accounts-CCirBEIm.js";
+import { t as getIMessageRuntime } from "./runtime-Cza4CY5T.js";
+import { a as IMESSAGE_REPLY_CACHE_NAMESPACE, f as resolveIMessageReplyCacheEntryKey, i as IMESSAGE_REPLY_CACHE_MAX_ENTRIES, n as IMESSAGE_REPLY_CACHE_COUNTER_KEY, o as IMESSAGE_REPLY_CACHE_TTL_MS, r as IMESSAGE_REPLY_CACHE_COUNTER_NAMESPACE } from "./state-contract-4TK_cDDb.js";
+import { normalizeE164 } from "openclaw/plugin-sdk/account-resolution";
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { logVerbose } from "openclaw/plugin-sdk/runtime-env";
 import { resolveUserPath } from "openclaw/plugin-sdk/text-utility-runtime";
 import { spawn } from "node:child_process";
 import { StringDecoder } from "node:string_decoder";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { FormatCapabilityProfile, findCodeRegions, isInsideCode, markdownToIR, renderMarkdownWithAttributedRanges, sanitizeAssistantVisibleText, stripMarkdown, tokenizeHtmlTags } from "openclaw/plugin-sdk/text-chunking";
+//#region extensions/imessage/src/chat-context.ts
+const EMAIL_HANDLE_PATTERN = /^[^\s@]+@[^\s@]+$/u;
+function parseDirectChatIdentity(raw) {
+	const trimmed = raw.trim();
+	const parts = trimmed.split(";");
+	if (parts.length === 3 && parts[1] === "-" && parts[2]) {
+		const service = parts[0]?.toLowerCase();
+		if (service === "imessage" || service === "sms" || service === "any") {
+			const identifier = parts[2];
+			return {
+				service,
+				identifier: EMAIL_HANDLE_PATTERN.test(identifier) ? identifier.toLowerCase() : identifier
+			};
+		}
+	}
+	if (parts.length !== 1) return;
+	if (trimmed.startsWith("+") || EMAIL_HANDLE_PATTERN.test(trimmed)) return { identifier: trimmed.toLowerCase() };
+}
+function resolveIMessageDirectChatService(configuredService, chatGuid) {
+	if (configuredService === "imessage" || configuredService === "sms") return configuredService;
+	const observedService = chatGuid ? parseDirectChatIdentity(chatGuid)?.service : void 0;
+	return observedService === "imessage" || observedService === "sms" ? observedService : void 0;
+}
+function isIMessageEmailChatIdentifier(raw) {
+	const identity = parseDirectChatIdentity(raw);
+	return Boolean(identity && EMAIL_HANDLE_PATTERN.test(identity.identifier));
+}
+/**
+* Strip the `iMessage;-;` / `SMS;-;` / `any;-;` service prefix that Messages
+* uses for direct chats. Different layers report direct DMs in different
+* forms, so raw comparison would falsely treat one DM as different chats.
+*/
+function normalizeDirectChatIdentifier(raw) {
+	const trimmed = raw.trim();
+	return parseDirectChatIdentity(trimmed)?.identifier ?? trimmed;
+}
+function chatContextFromIMessageTarget(target, effectiveService) {
+	if (target.kind === "chat_id") return { chatId: target.chatId };
+	if (target.kind === "chat_guid") return { chatGuid: target.chatGuid };
+	if (target.kind === "chat_identifier") return { chatIdentifier: target.chatIdentifier };
+	const trimmedHandle = target.to.trim();
+	const canonicalHandle = trimmedHandle.startsWith("+") ? normalizeE164(trimmedHandle) : /^[^\s@]+@[^\s@]+$/u.test(trimmedHandle) ? trimmedHandle.toLowerCase() : void 0;
+	if (!canonicalHandle) return {};
+	const service = target.service === "auto" ? effectiveService : target.service;
+	if (service !== "imessage" && service !== "sms") return {};
+	return { chatIdentifier: `${service === "sms" ? "SMS" : "iMessage"};-;${canonicalHandle}` };
+}
+function compareOptional(left, right) {
+	return left === void 0 || right === void 0 ? void 0 : left === right;
+}
+function compareChatSelector(cachedRaw, currentRaw, crossKind = false) {
+	const cached = normalizeOptionalString(cachedRaw);
+	const current = normalizeOptionalString(currentRaw);
+	if (!cached || !current) return;
+	if (cached === current) return true;
+	const cachedDirect = parseDirectChatIdentity(cached);
+	const currentDirect = parseDirectChatIdentity(current);
+	if (!cachedDirect || !currentDirect) return crossKind ? void 0 : false;
+	if (cachedDirect.identifier !== currentDirect.identifier) return false;
+	if (cachedDirect.service === "any") return true;
+	if (!cachedDirect.service || !currentDirect.service) return;
+	return cachedDirect.service === currentDirect.service;
+}
+function resolveIMessageChatMatch(cached, current) {
+	const cachedChatGuid = normalizeOptionalString(cached.chatGuid);
+	const currentChatGuid = normalizeOptionalString(current.chatGuid);
+	const cachedChatIdentifier = normalizeOptionalString(cached.chatIdentifier);
+	const currentChatIdentifier = normalizeOptionalString(current.chatIdentifier);
+	const comparisons = [
+		compareChatSelector(cachedChatGuid, currentChatGuid),
+		compareChatSelector(cachedChatIdentifier, currentChatIdentifier),
+		compareOptional(cached.chatId, current.chatId),
+		compareChatSelector(cachedChatGuid, currentChatIdentifier, true),
+		compareChatSelector(cachedChatIdentifier, currentChatGuid, true)
+	].filter((comparison) => comparison !== void 0);
+	if (comparisons.length === 0) return "unknown";
+	return comparisons.every(Boolean) ? "match" : "mismatch";
+}
+function isPositiveIMessageChatMatch(cached, current) {
+	return resolveIMessageChatMatch(cached, current) === "match";
+}
+//#endregion
 //#region extensions/imessage/src/constants.ts
 /** Default timeout for iMessage probe/RPC operations (10 seconds). */
 const DEFAULT_IMESSAGE_PROBE_TIMEOUT_MS = 1e4;
 const DEFAULT_IMESSAGE_SEND_TIMEOUT_MS = 18e4;
 //#endregion
+//#region extensions/imessage/src/monitor-reply-cache.ts
+/** Recency window for the "react to the latest message" fallback. */
+const LATEST_FALLBACK_MS = 600 * 1e3;
+let persistenceFailureLogged = false;
+function reportPersistenceFailure(scope, err) {
+	if (persistenceFailureLogged) return;
+	persistenceFailureLogged = true;
+	logVerbose(`imessage reply-cache: ${scope} disabled after first failure: ${String(err)}`);
+}
+const imessageReplyCacheByMessageId = /* @__PURE__ */ new Map();
+const imessageShortIdToUuid = /* @__PURE__ */ new Map();
+const imessageUuidToShortId = /* @__PURE__ */ new Map();
+let imessageShortIdCounter = 0;
+function openReplyCacheStore() {
+	return getIMessageRuntime().state.openSyncKeyedStore({
+		namespace: IMESSAGE_REPLY_CACHE_NAMESPACE,
+		maxEntries: IMESSAGE_REPLY_CACHE_MAX_ENTRIES
+	});
+}
+function openReplyCacheCounterStore() {
+	return getIMessageRuntime().state.openSyncKeyedStore({
+		namespace: IMESSAGE_REPLY_CACHE_COUNTER_NAMESPACE,
+		maxEntries: 1
+	});
+}
+function remainingTtlMs(timestamp) {
+	const remaining = IMESSAGE_REPLY_CACHE_TTL_MS - Math.max(0, Date.now() - timestamp);
+	return remaining > 0 ? remaining : void 0;
+}
+let hydrated = false;
+function hydrateFromStoreOnce() {
+	if (hydrated) return;
+	hydrated = true;
+	const cutoff = Date.now() - IMESSAGE_REPLY_CACHE_TTL_MS;
+	let entries;
+	try {
+		const counter = openReplyCacheCounterStore().lookup(IMESSAGE_REPLY_CACHE_COUNTER_KEY);
+		if (counter && Number.isSafeInteger(counter.counter) && counter.counter > 0) imessageShortIdCounter = Math.max(imessageShortIdCounter, counter.counter);
+		entries = openReplyCacheStore().entries().map(({ value }) => value).filter((entry) => entry.timestamp >= cutoff).toSorted((a, b) => a.timestamp - b.timestamp).slice(-IMESSAGE_REPLY_CACHE_MAX_ENTRIES);
+		for (const entry of entries) {
+			const numeric = Number.parseInt(entry.shortId, 10);
+			if (Number.isFinite(numeric) && numeric > imessageShortIdCounter) imessageShortIdCounter = numeric;
+		}
+	} catch (err) {
+		reportPersistenceFailure("read", err);
+		return;
+	}
+	if (entries.length === 0) return;
+	for (const entry of entries) {
+		imessageReplyCacheByMessageId.set(entry.messageId, entry);
+		imessageShortIdToUuid.set(entry.shortId, entry.messageId);
+		imessageUuidToShortId.set(entry.messageId, entry.shortId);
+	}
+}
+function persistReplyCacheEntry(entry) {
+	const ttlMs = remainingTtlMs(entry.timestamp);
+	if (!ttlMs) return;
+	try {
+		openReplyCacheStore().register(resolveIMessageReplyCacheEntryKey(entry.messageId), entry, { ttlMs });
+	} catch (err) {
+		reportPersistenceFailure("write", err);
+	}
+}
+function deleteReplyCacheEntry(messageId) {
+	try {
+		openReplyCacheStore().delete(resolveIMessageReplyCacheEntryKey(messageId));
+	} catch (err) {
+		reportPersistenceFailure("delete", err);
+	}
+}
+function persistReplyCacheCounter() {
+	try {
+		openReplyCacheCounterStore().register(IMESSAGE_REPLY_CACHE_COUNTER_KEY, { counter: imessageShortIdCounter });
+	} catch (err) {
+		reportPersistenceFailure("counter", err);
+	}
+}
+function buildReplyCacheEntry(entry, messageId, shortId) {
+	return {
+		accountId: entry.accountId,
+		messageId,
+		shortId,
+		timestamp: entry.timestamp,
+		...typeof entry.chatGuid === "string" ? { chatGuid: entry.chatGuid } : {},
+		...typeof entry.chatIdentifier === "string" ? { chatIdentifier: entry.chatIdentifier } : {},
+		...typeof entry.chatId === "number" ? { chatId: entry.chatId } : {},
+		...typeof entry.isFromMe === "boolean" ? { isFromMe: entry.isFromMe } : {}
+	};
+}
+function generateShortId() {
+	imessageShortIdCounter += 1;
+	persistReplyCacheCounter();
+	return String(imessageShortIdCounter);
+}
+function rememberIMessageReplyCache(entry) {
+	hydrateFromStoreOnce();
+	const messageId = entry.messageId.trim();
+	if (!messageId) return {
+		...entry,
+		shortId: ""
+	};
+	let shortId = imessageUuidToShortId.get(messageId);
+	if (!shortId) {
+		shortId = generateShortId();
+		imessageShortIdToUuid.set(shortId, messageId);
+		imessageUuidToShortId.set(messageId, shortId);
+	}
+	const fullEntry = buildReplyCacheEntry(entry, messageId, shortId);
+	imessageReplyCacheByMessageId.delete(messageId);
+	imessageReplyCacheByMessageId.set(messageId, fullEntry);
+	const cutoff = Date.now() - IMESSAGE_REPLY_CACHE_TTL_MS;
+	let evicted = false;
+	const deletedMessageIds = [];
+	for (const [key, value] of imessageReplyCacheByMessageId) {
+		if (value.timestamp >= cutoff) break;
+		imessageReplyCacheByMessageId.delete(key);
+		deletedMessageIds.push(key);
+		if (value.shortId) {
+			imessageShortIdToUuid.delete(value.shortId);
+			imessageUuidToShortId.delete(key);
+		}
+		evicted = true;
+	}
+	while (imessageReplyCacheByMessageId.size > IMESSAGE_REPLY_CACHE_MAX_ENTRIES) {
+		const oldest = imessageReplyCacheByMessageId.keys().next().value;
+		if (!oldest) break;
+		const oldEntry = imessageReplyCacheByMessageId.get(oldest);
+		imessageReplyCacheByMessageId.delete(oldest);
+		deletedMessageIds.push(oldest);
+		if (oldEntry?.shortId) {
+			imessageShortIdToUuid.delete(oldEntry.shortId);
+			imessageUuidToShortId.delete(oldest);
+		}
+		evicted = true;
+	}
+	if (evicted) for (const messageIdToDelete of deletedMessageIds) deleteReplyCacheEntry(messageIdToDelete);
+	persistReplyCacheEntry(fullEntry);
+	return fullEntry;
+}
+function hasChatScope(ctx) {
+	if (!ctx) return false;
+	return Boolean(normalizeOptionalString(ctx.chatGuid) || normalizeOptionalString(ctx.chatIdentifier) || typeof ctx.chatId === "number");
+}
+function isCrossChatMismatch(cached, ctx) {
+	return resolveIMessageChatMatch(cached, ctx) === "mismatch";
+}
+function describeChatForError(values) {
+	const parts = [];
+	if (normalizeOptionalString(values.chatGuid)) parts.push("chatGuid=<redacted>");
+	if (normalizeOptionalString(values.chatIdentifier)) parts.push("chatIdentifier=<redacted>");
+	if (typeof values.chatId === "number") parts.push("chatId=<redacted>");
+	return parts.length === 0 ? "<unknown chat>" : parts.join(", ");
+}
+function describeMessageIdForError(inputId, inputKind) {
+	if (inputKind === "short") return `<short:${inputId.length}-digit>`;
+	return `<uuid:${inputId.slice(0, 8)}...>`;
+}
+function buildCrossChatError(inputId, inputKind, cached, ctx) {
+	const remediation = inputKind === "short" ? "Use a message ID from the current chat target; MessageSidFull from another chat is rejected." : "Retry with the correct chat target.";
+	return /* @__PURE__ */ new Error(`iMessage message id ${describeMessageIdForError(inputId, inputKind)} belongs to a different chat (${describeChatForError(cached)}) than the current call target (${describeChatForError(ctx)}). ${remediation}`);
+}
+function resolveIMessageMessageId(shortOrUuid, opts) {
+	const trimmed = shortOrUuid.trim();
+	if (!trimmed) return trimmed;
+	hydrateFromStoreOnce();
+	if (/^\d+$/.test(trimmed)) {
+		const uuid = imessageShortIdToUuid.get(trimmed);
+		if (uuid) {
+			const cached = imessageReplyCacheByMessageId.get(uuid);
+			if (opts?.chatContext && hasChatScope(opts.chatContext)) {
+				if (cached && isCrossChatMismatch(cached, opts.chatContext)) throw buildCrossChatError(trimmed, "short", cached, opts.chatContext);
+			}
+			if (opts?.requireFromMe && cached?.isFromMe !== true) throw buildFromMeError(trimmed, "short");
+			return uuid;
+		}
+		if (opts?.requireKnownShortId && !hasChatScope(opts.chatContext)) throw new Error(`iMessage short message id ${describeMessageIdForError(trimmed, "short")} requires a chat scope (chatGuid / chatIdentifier / chatId or a target).`);
+		if (opts?.requireKnownShortId) throw new Error(`iMessage short message id ${describeMessageIdForError(trimmed, "short")} is no longer available. Use MessageSidFull.`);
+		return trimmed;
+	}
+	const cached = imessageReplyCacheByMessageId.get(trimmed);
+	if (opts?.chatContext) {
+		if (cached && isCrossChatMismatch(cached, opts.chatContext)) throw buildCrossChatError(trimmed, "uuid", cached, opts.chatContext);
+	}
+	if (opts?.requireFromMe && cached?.isFromMe !== true) throw buildFromMeError(trimmed, "uuid");
+	return trimmed;
+}
+function isKnownFromMeIMessageMessageId(messageId, ctx) {
+	const trimmed = normalizeOptionalString(messageId);
+	if (!trimmed || !ctx.accountId || !hasChatScope(ctx)) return false;
+	hydrateFromStoreOnce();
+	const cached = imessageReplyCacheByMessageId.get(trimmed);
+	if (!cached || cached.isFromMe !== true || cached.accountId !== ctx.accountId) return false;
+	return isPositiveIMessageChatMatch(cached, ctx);
+}
+function buildFromMeError(inputId, inputKind) {
+	return /* @__PURE__ */ new Error(`iMessage message id ${describeMessageIdForError(inputId, inputKind)} is not one this agent sent. edit and unsend can only target messages the gateway delivered itself; messages received from other participants cannot be modified.`);
+}
+/**
+* Return the most recent cached entry whose chat scope matches the supplied
+* context. Used as a fallback when an agent calls a per-message action (e.g.
+* `react`) without specifying a `messageId` — the natural intent is "react
+* to the message I just received in this chat."
+*
+* Strict semantics for safety:
+*  - Caller must supply a chat scope. We refuse to "guess" the active chat.
+*  - Cached entry must positively match on at least one identifier kind
+*    (chatGuid, chatIdentifier, chatId, or normalized direct-DM fingerprint).
+*    We do NOT fall through on "no overlapping identifier" — that's how a
+*    cached entry from a foreign chat could be returned when the caller's
+*    context didn't share any identifier kind with the cache.
+*  - Caller must supply an accountId; we never cross account boundaries.
+*  - We only consider entries newer than `LATEST_FALLBACK_MS`. The intent
+*    of "react to the latest" is "the message I just received," not
+*    "anything in this chat from any time."
+*/
+function findLatestIMessageEntryForChat(ctx) {
+	if (!hasChatScope(ctx)) return;
+	if (!ctx.accountId) return;
+	const cutoff = Date.now() - LATEST_FALLBACK_MS;
+	let best;
+	for (const entry of imessageReplyCacheByMessageId.values()) {
+		if (entry.accountId !== ctx.accountId) continue;
+		if (entry.timestamp < cutoff) continue;
+		if (!isPositiveIMessageChatMatch(entry, ctx)) continue;
+		if (!best || entry.timestamp > best.timestamp) best = entry;
+	}
+	return best;
+}
+function resolveIMessageCachedResourceBinding(messageId, ctx) {
+	hydrateFromStoreOnce();
+	const entry = imessageReplyCacheByMessageId.get(messageId.trim());
+	if (!entry) return "unknown";
+	if (Date.now() - entry.timestamp > 216e5) return "unknown";
+	if (entry.accountId !== ctx.accountId) return "mismatch";
+	const chatMatch = resolveIMessageChatMatch(entry, ctx);
+	if (chatMatch !== "match") return chatMatch;
+	return "match";
+}
+function isIMessageCurrentMessageInChat(params) {
+	if (!params.accountId || !hasChatScope(params.chatContext)) return false;
+	const currentMessageId = normalizeOptionalString(String(params.currentMessageId));
+	if (!currentMessageId) return false;
+	hydrateFromStoreOnce();
+	const fullMessageId = /^\d+$/.test(currentMessageId) ? imessageShortIdToUuid.get(currentMessageId) : currentMessageId;
+	if (!fullMessageId) return false;
+	return resolveIMessageCachedResourceBinding(fullMessageId, {
+		...params.chatContext,
+		accountId: params.accountId
+	}) === "match";
+}
+//#endregion
 //#region extensions/imessage/src/client.ts
 var IMessageRpcRequestError = class extends Error {
 	constructor(message, code, data) {
@@ -329,35 +666,6 @@ function codeDelimiter(content) {
 	const longestRun = Math.max(0, ...[...content.matchAll(/`+/gu)].map((match) => match[0].length));
 	return "`".repeat(longestRun + 1);
 }
-function protectDunderIdentifiers(input) {
-	const protections = [];
-	let markdown = "";
-	let cursor = 0;
-	for (const match of input.matchAll(/__[\p{L}_][\p{L}\p{N}_]*__/gu)) {
-		const identifier = match[0];
-		const start = match.index ?? 0;
-		const end = start + identifier.length;
-		const before = input[start - 1];
-		const beforeBefore = input[start - 2];
-		const after = input[end];
-		const member = before === ".";
-		const call = after === "(";
-		const functionArgument = before === "(" && /[\p{L}\p{N}_]/u.test(beforeBefore ?? "");
-		if (!member && !call && !functionArgument && !(after === "[")) continue;
-		let token = `OCdunder${protections.length}token`;
-		while (input.includes(token)) token += "x";
-		markdown += input.slice(cursor, start) + token;
-		protections.push({
-			token,
-			identifier
-		});
-		cursor = end;
-	}
-	return {
-		markdown: markdown + input.slice(cursor),
-		protections
-	};
-}
 function applyTextEdits(text, edits) {
 	const ordered = edits.toSorted((left, right) => left.start - right.start);
 	let rendered = "";
@@ -372,26 +680,6 @@ function applyTextEdits(text, edits) {
 		mapOffset: (offset) => offset + ordered.reduce((delta, edit) => delta + (edit.end <= offset ? edit.text.length - edit.end + edit.start : 0), 0)
 	};
 }
-function restoreDunderIdentifiers(text, ranges, codeRanges, protections) {
-	const edited = applyTextEdits(text, protections.flatMap((protection) => {
-		const start = text.indexOf(protection.token);
-		return start === -1 ? [] : [{
-			start,
-			end: start + protection.token.length,
-			text: protection.identifier
-		}];
-	}));
-	const mapRange = (range) => ({
-		...range,
-		start: edited.mapOffset(range.start),
-		length: edited.mapOffset(range.start + range.length) - edited.mapOffset(range.start)
-	});
-	return {
-		text: edited.text,
-		ranges: ranges.map(mapRange),
-		codeRanges: codeRanges.map(mapRange)
-	};
-}
 function restoreCodeMarkers(text, ranges, codeRanges) {
 	const edited = applyTextEdits(text, codeRanges.map((range) => {
 		const end = range.start + range.length;
@@ -414,22 +702,21 @@ function restoreCodeMarkers(text, ranges, codeRanges) {
 	};
 }
 function extractMarkdownFormatRuns(input) {
-	const protectedDunders = protectDunderIdentifiers(input);
-	const ir = markdownToIR(protectedDunders.markdown, {
+	const ir = markdownToIR(input, {
 		autolink: false,
 		enableHtmlUnderline: true,
 		headingStyle: "rich",
 		linkify: false,
+		preserveDunderIdentifiers: true,
 		preserveSourceBlockSpacing: true
 	});
 	const rendered = renderMarkdownWithAttributedRanges(ir, { styleMap: IMESSAGE_STYLE_MAP }, IMESSAGE_FORMAT_PROFILE);
 	const code = renderMarkdownWithAttributedRanges(ir, { styleMap: { code: "code" } }, IMESSAGE_CODE_PROFILE);
-	const dunders = restoreDunderIdentifiers(rendered.text, rendered.ranges.map(({ start, length, style }) => ({
+	return restoreCodeMarkers(rendered.text, rendered.ranges.map(({ start, length, style }) => ({
 		start,
 		length,
 		styles: [style]
-	})), code.ranges, protectedDunders.protections);
-	return restoreCodeMarkers(dunders.text, dunders.ranges, dunders.codeRanges);
+	})), code.ranges);
 }
 //#endregion
 //#region extensions/imessage/src/monitor/sanitize-outbound.ts
@@ -445,7 +732,7 @@ const FINAL_PRIVATE_MARKER_RE = /(?:#\+){2,}#?|\bassistant\s+to\s*=\s*\w+|^[ \t]
 const PRIVATE_USE_START = 57344;
 const PRIVATE_USE_END = 63743;
 const MAX_PRIVATE_MARKDOWN_UNWRAP_PASSES = 32;
-const PLAIN_TEXT_HTML_TAG_RE = /<\/?[a-z][a-z0-9_-]*\b[^>]*>/gi;
+const PLAIN_TEXT_HTML_TAG_RE = /<\/?[a-z][a-z0-9_.:-]*(?=[\s/>])[^>]*>/gi;
 const PRIVATE_PROVIDER_TAG_NAMES = [
 	"think",
 	"thinking",
@@ -893,4 +1180,4 @@ function sanitizeOutboundText(text) {
 	return cleaned;
 }
 //#endregion
-export { IMessageRpcRequestError as a, DEFAULT_IMESSAGE_SEND_TIMEOUT_MS as c, extractMarkdownFormatRuns as i, sanitizeIMessageFinalOutboundText as n, createIMessageRpcClient as o, sanitizeOutboundText as r, DEFAULT_IMESSAGE_PROBE_TIMEOUT_MS as s, protectIMessageFencedRoleMarkers as t };
+export { normalizeDirectChatIdentifier as _, IMessageRpcRequestError as a, isIMessageCurrentMessageInChat as c, resolveIMessageCachedResourceBinding as d, resolveIMessageMessageId as f, isIMessageEmailChatIdentifier as g, chatContextFromIMessageTarget as h, extractMarkdownFormatRuns as i, isKnownFromMeIMessageMessageId as l, DEFAULT_IMESSAGE_SEND_TIMEOUT_MS as m, sanitizeIMessageFinalOutboundText as n, createIMessageRpcClient as o, DEFAULT_IMESSAGE_PROBE_TIMEOUT_MS as p, sanitizeOutboundText as r, findLatestIMessageEntryForChat as s, protectIMessageFencedRoleMarkers as t, rememberIMessageReplyCache as u, resolveIMessageDirectChatService as v };