@openclaw/signal 2026.7.2-beta.3 → 2026.7.2-beta.5

package/dist/{monitor-D2nTNhM2.js → monitor-CHBkf7lk.js}

@@ -1,30 +1,31 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { a as resolveSignalReplyToMode, i as resolveSignalAccount } from "./accounts-Bz4HtP0g.js";
+import { i as resolveSignalAccount, o as resolveSignalReplyToMode } from "./accounts-DrStJjiK.js";
 import { a as normalizeSignalAllowRecipient, c as resolveSignalSender, d as normalizeSignalMessagingTarget, i as isSignalSenderAllowed, l as looksLikeUuid, n as formatSignalSenderDisplay, o as resolveSignalPeerId, r as formatSignalSenderId, s as resolveSignalRecipient, t as formatSignalPairingIdLine } from "./identity-BQ4OzXXk.js";
-import { t as getOptionalSignalRuntime } from "./runtime-B900w6lc.js";
-import { a as resolveSignalReactionLevel, c as isSignalNativeApprovalHandlerConfigured, r as materializeSignalPresentationFallback, t as registerSignalReplyContext } from "./reply-authors-DcNqGpX-.js";
-import { n as signalRpcRequest, r as streamSignalEvents, t as signalCheck } from "./client-adapter-DZD8DCai.js";
-import { n as sendReactionSignal, t as removeReactionSignal } from "./reaction-runtime-api-tPkUVRoL.js";
-import { a as maybeResolveSignalApprovalReaction, l as resolveSignalApprovalConversationKey, s as registerSignalApprovalReactionTargetForDeliveredPayload, t as addSignalApprovalReactionHintToStructuredPayload } from "./approval-reactions-DcpZRS5-.js";
-import { r as registerSignalQuestionReactionTargetForDeliveredPayload, t as maybeResolveSignalQuestionReaction } from "./question-reactions-BFFJNQsu.js";
-import { n as sendReadReceiptSignal, r as sendTypingSignal, t as sendMessageSignal } from "./send-f6JLstd2.js";
-import { DEFAULT_INGRESS_RETRY_DEAD_LETTER_MIN_AGE_MS, DEFAULT_INGRESS_RETRY_MAX_ATTEMPTS, bindIngressLifecycleToReplyOptions, createChannelIngressDrain, createChannelMessageReplyPipeline, resolveChannelStreamingBlockEnabled } from "openclaw/plugin-sdk/channel-outbound";
+import { t as getOptionalSignalRuntime } from "./runtime-JPrGlV7h.js";
+import { i as materializeSignalPresentationFallback, n as registerSignalReplyContext, o as resolveSignalReactionLevel, s as formatSignalMediaText, u as isSignalNativeApprovalHandlerConfigured } from "./transport-detection-Da06-LOL.js";
+import { n as signalRpcRequest, r as streamSignalEvents, t as signalCheck } from "./client-adapter-mXGeEHQJ.js";
+import { n as sendReactionSignal } from "./reaction-runtime-api-BjeDyKcz.js";
+import { a as maybeResolveSignalApprovalReaction, l as resolveSignalApprovalConversationKey, s as registerSignalApprovalReactionTargetForDeliveredPayload, t as addSignalApprovalReactionHintToStructuredPayload } from "./approval-reactions-DtL47gSK.js";
+import { r as registerSignalQuestionReactionTargetForDeliveredPayload, t as maybeResolveSignalQuestionReaction } from "./question-reactions-Ds48FtEu.js";
+import { n as sendReadReceiptSignal, r as sendTypingSignal, t as sendMessageSignal } from "./send-B_Ks4MZr.js";
+import { bindIngressLifecycleToReplyOptions, createChannelIngressMonitor, createChannelMessageReplyPipeline, resolveChannelStreamingBlockEnabled } from "openclaw/plugin-sdk/channel-outbound";
 import { createChannelPairingChallengeIssuer } from "openclaw/plugin-sdk/channel-pairing";
 import { detectMime, estimateBase64DecodedBytes, kindFromMime, saveMediaBuffer } from "openclaw/plugin-sdk/media-runtime";
 import { resolveAgentRoute, resolveInboundLastRouteSessionKey } from "openclaw/plugin-sdk/routing";
 import { normalizeOptionalString, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { CHANNEL_APPROVAL_NATIVE_RUNTIME_CONTEXT_CAPABILITY } from "openclaw/plugin-sdk/approval-handler-adapter-runtime";
 import { normalizeE164, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+import { buildChannelInboundEventContext, buildMentionRegexes, createChannelInboundDebouncer, filterChannelInboundQuoteContext, formatInboundEnvelope, formatInboundFromLabel, formatInboundMediaUnavailableText, hasVisibleInboundReplyDispatch, logInboundDrop, matchesMentionPatterns, resolveEnvelopeFormatOptions, resolveInboundMentionDecision, resolveInboundSupplementalSenderAllowed, runChannelInboundEvent, shouldDebounceTextInbound, toHistoryMediaEntries, toInboundMediaFacts } from "openclaw/plugin-sdk/channel-inbound";
 import nodePath from "node:path";
-import { resolvePinnedMainDmOwnerFromAllowlist } from "openclaw/plugin-sdk/security-runtime";
 import { collectErrorGraphCandidates, formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import { resolvePinnedMainDmOwnerFromAllowlist } from "openclaw/plugin-sdk/security-runtime";
 import { resolveChannelGroupPolicy, resolveChannelGroupRequireMention } from "openclaw/plugin-sdk/channel-policy";
 import { registerChannelRuntimeContext } from "openclaw/plugin-sdk/channel-runtime-context";
 import { DEFAULT_GROUP_HISTORY_LIMIT, createChannelHistoryWindow } from "openclaw/plugin-sdk/reply-history";
 import { deliverTextOrMediaReply, resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
 import { chunkTextWithMode, createReplyReferencePlanner, resolveChunkMode, resolveTextChunkLimit } from "openclaw/plugin-sdk/reply-runtime";
 import { getRuntimeConfig } from "openclaw/plugin-sdk/runtime-config-snapshot";
-import { computeBackoff, createNonExitingRuntime, danger, logVerbose, shouldLogVerbose, sleep, sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
+import { computeBackoff, createNonExitingRuntime, danger, logVerbose, shouldLogVerbose, sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 import { resolveAllowlistProviderRuntimeGroupPolicy, resolveDefaultGroupPolicy, warnMissingProviderGroupPolicyFallbackOnce } from "openclaw/plugin-sdk/runtime-group-policy";
 import { waitForTransportReady } from "openclaw/plugin-sdk/transport-ready-runtime";
 import { spawn } from "node:child_process";
@@ -33,13 +34,12 @@ import { createInterface } from "node:readline";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { resolveHumanDelayConfig } from "openclaw/plugin-sdk/agent-runtime";
 import { DEFAULT_EMOJIS, DEFAULT_TIMING, createStatusReactionController, logAckFailure, logTypingFailure, resolveAckReaction, shouldAckReaction } from "openclaw/plugin-sdk/channel-feedback";
-import { buildChannelInboundEventContext, buildMentionRegexes, createChannelInboundDebouncer, filterChannelInboundQuoteContext, formatInboundEnvelope, formatInboundFromLabel, formatInboundMediaUnavailableText, hasVisibleInboundReplyDispatch, logInboundDrop, matchesMentionPatterns, resolveEnvelopeFormatOptions, resolveInboundMentionDecision, resolveInboundSupplementalSenderAllowed, runChannelInboundEvent, shouldDebounceTextInbound } from "openclaw/plugin-sdk/channel-inbound";
+import { createChannelIngressResolver, defineStableChannelIngressIdentity, fanInChannelIngressLifecycles } from "openclaw/plugin-sdk/channel-ingress-runtime";
 import { isControlCommandMessage } from "openclaw/plugin-sdk/command-detection";
 import { createInternalHookEvent, fireAndForgetHook, toInternalMessageReceivedContext, triggerInternalHook } from "openclaw/plugin-sdk/hook-runtime";
 import { resolveBatchedReplyThreadingPolicy } from "openclaw/plugin-sdk/reply-reference";
 import { readSessionUpdatedAt, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
 import { enqueueSystemEvent } from "openclaw/plugin-sdk/system-event-runtime";
-import { createChannelIngressResolver, defineStableChannelIngressIdentity } from "openclaw/plugin-sdk/channel-ingress-runtime";
 import { upsertChannelPairingRequest } from "openclaw/plugin-sdk/conversation-runtime";
 import { listChatCommands, maybeResolveTextAlias, normalizeCommandBody } from "openclaw/plugin-sdk/command-auth-native";
 import { isAbortRequestText } from "openclaw/plugin-sdk/command-primitives-runtime";
@@ -514,18 +514,6 @@ const RETRYABLE_FLUSH_RETRY_DELAYS_MS = [
 function isSignalReplySessionInitConflictError(error) {
 	return collectErrorGraphCandidates(error, (current) => [current.cause, current.error]).some((candidate) => REPLY_SESSION_INIT_CONFLICT_MESSAGE_RE.test(formatErrorMessage(candidate)));
 }
-function formatAttachmentKindCount(kind, count) {
-	if (kind === "attachment") return `${count} file${count > 1 ? "s" : ""}`;
-	return `${count} ${kind}${count > 1 ? "s" : ""}`;
-}
-function formatAttachmentSummaryPlaceholder(contentTypes) {
-	const kindCounts = /* @__PURE__ */ new Map();
-	for (const contentType of contentTypes) {
-		const kind = kindFromMime(contentType) ?? "attachment";
-		kindCounts.set(kind, (kindCounts.get(kind) ?? 0) + 1);
-	}
-	return `[${[...kindCounts.entries()].map(([kind, count]) => formatAttachmentKindCount(kind, count)).join(" + ")} attached]`;
-}
 function resolveSignalInboundRoute(params) {
 	return resolveAgentRoute({
 		cfg: params.cfg,
@@ -554,26 +542,12 @@ function resolveSignalStatusReactionEmojis(emojis) {
 	};
 }
 async function finalizeSignalStatusReaction(params) {
-	if (params.outcome === "done") {
-		await params.controller.setDone();
-		if (params.removeAckAfterReply) {
-			await sleep(params.timing.doneHoldMs);
-			await params.controller.clear();
-		} else await params.controller.restoreInitial();
-		return;
-	}
-	await params.controller.setError();
-	if (params.hasFinalResponse) {
-		if (params.removeAckAfterReply) {
-			await sleep(params.timing.errorHoldMs);
-			await params.controller.clear();
-		} else await params.controller.restoreInitial();
-		return;
-	}
-	if (params.removeAckAfterReply) await sleep(params.timing.errorHoldMs);
+	if (params.outcome === "done") await params.controller.setDone();
+	else await params.controller.setError();
 	await params.controller.restoreInitial();
 }
 function createSignalEventHandler(deps) {
+	const statusReactionTiming = deps.statusReactionTiming ?? DEFAULT_TIMING;
 	const activeEnqueueEntries = /* @__PURE__ */ new WeakSet();
 	async function handleSignalInboundMessage(entry) {
 		const fromLabel = formatInboundFromLabel({
@@ -620,7 +594,7 @@ function createSignalEventHandler(deps) {
 				channel: "Signal",
 				from: fromLabel,
 				timestamp: historyEntry.timestamp,
-				body: `${historyEntry.body}${historyEntry.messageId ? ` [id:${historyEntry.messageId}]` : ""}`,
+				body: `${[historyEntry.body, formatSignalMediaText(historyEntry.media ?? [])].filter(Boolean).join("\n")}${historyEntry.messageId ? ` [id:${historyEntry.messageId}]` : ""}`,
 				chatType: "group",
 				senderLabel: historyEntry.sender,
 				envelope: envelopeOptions
@@ -638,15 +612,7 @@ function createSignalEventHandler(deps) {
 			chatType: entry.isGroup ? "group" : "direct"
 		});
 		const replyThreading = resolveBatchedReplyThreadingPolicy(replyToMode, entry.isBatched === true);
-		const media = entry.mediaPaths && entry.mediaPaths.length > 0 ? entry.mediaPaths.map((path, index) => ({
-			path,
-			url: path,
-			contentType: entry.mediaTypes?.[index]
-		})) : entry.mediaPath ? [{
-			path: entry.mediaPath,
-			url: entry.mediaPath,
-			contentType: entry.mediaType
-		}] : void 0;
+		const media = toInboundMediaFacts(entry.media);
 		const ctxPayload = buildChannelInboundEventContext({
 			channel: "signal",
 			supplemental: { quote: entry.replyToBody ? {
@@ -683,6 +649,7 @@ function createSignalEventHandler(deps) {
 				rawBody: entry.commandBody,
 				commandBody: entry.commandBody
 			},
+			sessionTranscript: { historyLimit: entry.isGroup ? deps.historyLimit : 0 },
 			access: {
 				...entry.isGroup ? { mentions: {
 					canDetectMention: true,
@@ -731,23 +698,14 @@ function createSignalEventHandler(deps) {
 			} : {}
 		};
 		const statusReactionRecipient = entry.isGroup ? "" : entry.senderRecipient;
-		let currentStatusReactionEmoji = ackReaction;
 		const statusReactionController = statusReactionsConfig?.enabled === true && signalReactionLevel.level !== "off" && shouldSendStatusReaction && statusReactionTimestamp ? createStatusReactionController({
 			enabled: true,
-			adapter: {
-				setReaction: async (emoji) => {
-					await sendReactionSignal(statusReactionRecipient, statusReactionTimestamp, emoji, signalReactionOpts);
-					currentStatusReactionEmoji = emoji;
-				},
-				clearReaction: async () => {
-					if (!currentStatusReactionEmoji) return;
-					await removeReactionSignal(statusReactionRecipient, statusReactionTimestamp, currentStatusReactionEmoji, signalReactionOpts);
-					currentStatusReactionEmoji = "";
-				}
-			},
+			adapter: { setReaction: async (emoji) => {
+				await sendReactionSignal(statusReactionRecipient, statusReactionTimestamp, emoji, signalReactionOpts);
+			} },
 			initialEmoji: ackReaction,
-			emojis: resolveSignalStatusReactionEmojis(statusReactionsConfig.emojis),
-			timing: statusReactionsConfig.timing,
+			emojis: resolveSignalStatusReactionEmojis(void 0),
+			timing: statusReactionTiming,
 			onError: (err) => {
 				logAckFailure({
 					log: logVerbose,
@@ -757,10 +715,6 @@ function createSignalEventHandler(deps) {
 				});
 			}
 		}) : null;
-		const statusReactionTiming = {
-			...DEFAULT_TIMING,
-			...statusReactionsConfig?.timing
-		};
 		if (statusReactionController) statusReactionController.setQueued();
 		const { onModelSelected, typingCallbacks, ...replyPipeline } = createChannelMessageReplyPipeline({
 			cfg: deps.cfg,
@@ -910,10 +864,7 @@ function createSignalEventHandler(deps) {
 					const hasDeliveryFailure = result.dispatched && hasSignalStatusReplyDeliveryFailure(result.dispatchResult);
 					finalizeSignalStatusReaction({
 						controller: statusReactionController,
-						outcome: hasFinalResponse && !hasDeliveryFailure ? "done" : "error",
-						hasFinalResponse,
-						removeAckAfterReply: deps.cfg.messages?.removeAckAfterReply ?? false,
-						timing: statusReactionTiming
+						outcome: hasFinalResponse && !hasDeliveryFailure ? "done" : "error"
 					}).catch((err) => {
 						logVerbose(`signal: status reaction finalize failed: ${String(err)}`);
 					});
@@ -921,45 +872,10 @@ function createSignalEventHandler(deps) {
 			}
 		});
 	}
-	function buildFlushIngressLifecycle(entries) {
-		const lifecycles = entries.map((entry) => entry.turnAdoptionLifecycle).filter((lifecycle) => lifecycle !== void 0);
-		const [firstLifecycle] = lifecycles;
-		if (!firstLifecycle) return {
-			lifecycle: void 0,
-			settle: async () => {}
-		};
-		let handedOff = false;
-		const adoptAll = async () => {
-			for (const lifecycle of lifecycles) await lifecycle.onAdopted();
-		};
-		return {
-			lifecycle: {
-				abortSignal: lifecycles.length === 1 ? firstLifecycle.abortSignal : AbortSignal.any(lifecycles.map((lifecycle) => lifecycle.abortSignal)),
-				onAdopted: async () => {
-					handedOff = true;
-					await adoptAll();
-				},
-				onDeferred: () => {
-					handedOff = true;
-					for (const lifecycle of lifecycles) lifecycle.onDeferred();
-				},
-				onAdoptionFinalizing: () => {
-					for (const lifecycle of lifecycles) lifecycle.onAdoptionFinalizing();
-				},
-				onAbandoned: async () => {
-					handedOff = true;
-					await Promise.all(lifecycles.map((lifecycle) => Promise.resolve(lifecycle.onAbandoned())));
-				}
-			},
-			settle: async () => {
-				if (!handedOff) await adoptAll();
-			}
-		};
-	}
 	async function flushSignalInboundEntries(entries) {
 		const last = entries.at(-1);
 		if (!last) return;
-		const { lifecycle, settle } = buildFlushIngressLifecycle(entries);
+		const { lifecycle, settle } = fanInChannelIngressLifecycles(entries.map((entry) => entry.turnAdoptionLifecycle));
 		if (entries.length === 1) {
 			await handleSignalInboundMessage(lifecycle ? {
 				...last,
@@ -981,10 +897,7 @@ function createSignalEventHandler(deps) {
 			...lifecycle ? { turnAdoptionLifecycle: lifecycle } : {},
 			isBatched: true,
 			nativeReplyBody: last.nativeReplyBody ?? last.bodyText,
-			mediaPath: void 0,
-			mediaType: void 0,
-			mediaPaths: void 0,
-			mediaTypes: void 0
+			media: entries.flatMap((entry) => entry.media ?? [])
 		});
 		await settle();
 	}
@@ -1041,7 +954,7 @@ function createSignalEventHandler(deps) {
 		shouldDebounce: (entry) => shouldDebounceTextInbound({
 			text: entry.commandBody,
 			cfg: deps.cfg,
-			hasMedia: Boolean(entry.mediaPath || entry.mediaType || entry.mediaPaths?.length)
+			hasMedia: entry.media?.some((media) => Boolean(media.path || media.url)) === true
 		}),
 		onFlush: flushNormalSignalInboundEntries,
 		onError: reportSignalInboundFlushError,
@@ -1282,23 +1195,23 @@ function createSignalEventHandler(deps) {
 				reason: "no mention",
 				target: senderDisplay
 			});
-			const pendingPlaceholder = (() => {
-				if (!dataMessage.attachments?.length) return "";
-				if (deps.ignoreAttachments) return "<media:attachment>";
-				const attachmentTypes = (dataMessage.attachments ?? []).map((attachment) => typeof attachment?.contentType === "string" ? attachment.contentType : void 0);
-				if (attachmentTypes.length > 1) return formatAttachmentSummaryPlaceholder(attachmentTypes);
-				const firstContentType = dataMessage.attachments?.[0]?.contentType;
-				const pendingKind = kindFromMime(firstContentType ?? void 0);
-				return pendingKind ? `<media:${pendingKind}>` : "<media:attachment>";
-			})();
-			const pendingBodyText = messageText || pendingPlaceholder || visibleQuoteText;
+			const pendingMedia = (dataMessage.attachments ?? []).map((attachment) => {
+				const contentType = attachment?.contentType ?? void 0;
+				return {
+					contentType,
+					kind: kindFromMime(contentType) ?? "unknown"
+				};
+			});
+			const pendingMediaText = formatSignalMediaText(pendingMedia);
+			const pendingBodyText = messageText || pendingMediaText || visibleQuoteText;
 			const historyKey = groupId ?? "unknown";
 			createChannelHistoryWindow({ historyMap: deps.groupHistories }).record({
 				historyKey,
 				limit: deps.historyLimit,
 				entry: {
 					sender: envelope.sourceName ?? senderDisplay,
-					body: pendingBodyText,
+					body: messageText || visibleQuoteText,
+					media: toHistoryMediaEntries(pendingMedia),
 					timestamp: envelope.timestamp ?? void 0,
 					messageId: typeof envelope.timestamp === "number" ? String(envelope.timestamp) : void 0
 				}
@@ -1308,7 +1221,8 @@ function createSignalEventHandler(deps) {
 				to: signalTo,
 				replyToId,
 				author: senderRecipient,
-				body: pendingBodyText,
+				body: messageText || visibleQuoteText,
+				media: pendingMedia,
 				sourceTimestamp: inboundTimestamp
 			});
 			const signalGroupPolicy = resolveChannelGroupPolicy({
@@ -1340,14 +1254,16 @@ function createSignalEventHandler(deps) {
 			}
 			return;
 		}
-		let mediaPath;
-		let mediaType;
-		const mediaPaths = [];
-		const mediaTypes = [];
-		let placeholder = "";
 		const attachments = dataMessage.attachments ?? [];
+		const mediaFacts = attachments.map((attachment) => {
+			const contentType = attachment?.contentType ?? void 0;
+			return {
+				contentType,
+				kind: kindFromMime(contentType) ?? "unknown"
+			};
+		});
 		let unavailableAttachmentCount = deps.ignoreAttachments ? attachments.length : 0;
-		if (!deps.ignoreAttachments) for (const attachment of attachments) {
+		if (!deps.ignoreAttachments) for (const [index, attachment] of attachments.entries()) {
 			if (!attachment?.id) {
 				unavailableAttachmentCount += 1;
 				continue;
@@ -1362,25 +1278,20 @@ function createSignalEventHandler(deps) {
 					maxBytes: deps.mediaMaxBytes
 				});
 				if (fetched) {
-					mediaPaths.push(fetched.path);
-					mediaTypes.push(fetched.contentType ?? attachment.contentType ?? "application/octet-stream");
-					if (!mediaPath) {
-						mediaPath = fetched.path;
-						mediaType = fetched.contentType ?? attachment.contentType ?? void 0;
-					}
+					const contentType = fetched.contentType ?? attachment.contentType ?? "application/octet-stream";
+					mediaFacts[index] = {
+						path: fetched.path,
+						url: fetched.path,
+						contentType,
+						kind: kindFromMime(contentType) ?? "unknown"
+					};
 				} else unavailableAttachmentCount += 1;
 			} catch (err) {
 				unavailableAttachmentCount += 1;
 				deps.runtime.error?.(danger(`attachment fetch failed: ${String(err)}`));
 			}
 		}
-		if (mediaPaths.length > 1) placeholder = formatAttachmentSummaryPlaceholder(mediaTypes);
-		else {
-			const kind = kindFromMime(mediaType ?? void 0);
-			if (kind) placeholder = `<media:${kind}>`;
-			else if (mediaPaths.length > 0) placeholder = "<media:attachment>";
-		}
-		let bodyText = messageText || placeholder || visibleQuoteText || "";
+		let bodyText = messageText;
 		if (unavailableAttachmentCount > 0) {
 			const attachmentLabel = unavailableAttachmentCount === 1 ? "attachment" : "attachments";
 			bodyText = formatInboundMediaUnavailableText({
@@ -1388,7 +1299,7 @@ function createSignalEventHandler(deps) {
 				notice: `[signal ${unavailableAttachmentCount > 1 ? `${unavailableAttachmentCount} ` : ""}${attachmentLabel} unavailable]`
 			});
 		}
-		if (!bodyText) return;
+		if (!bodyText && mediaFacts.length === 0 && !visibleQuoteText) return;
 		if (deps.sendReadReceipts && !deps.readReceiptsViaDaemon && !isGroup && inboundTimestamp) try {
 			await sendReadReceiptSignal(`signal:${senderRecipient}`, inboundTimestamp, {
 				cfg: deps.cfg,
@@ -1406,7 +1317,8 @@ function createSignalEventHandler(deps) {
 			to: signalTo,
 			replyToId,
 			author: senderRecipient,
-			body: bodyText,
+			body: messageText,
+			media: mediaFacts,
 			sourceTimestamp: inboundTimestamp
 		});
 		const entry = {
@@ -1418,14 +1330,12 @@ function createSignalEventHandler(deps) {
 			groupName,
 			isGroup,
 			bodyText,
+			nativeReplyBody: [messageText, formatSignalMediaText(mediaFacts)].filter(Boolean).join("\n"),
 			commandBody: messageText,
 			timestamp: inboundTimestamp,
 			messageId,
 			replyToId,
-			mediaPath,
-			mediaType,
-			mediaPaths: mediaPaths.length > 0 ? mediaPaths : void 0,
-			mediaTypes: mediaTypes.length > 0 ? mediaTypes : void 0,
+			media: mediaFacts,
 			commandAuthorized,
 			canDetectMention,
 			requireMention,
@@ -1467,7 +1377,7 @@ var SignalIngressPermanentError = class extends Error {
 		this.name = "SignalIngressPermanentError";
 	}
 };
-function isRecord(value) {
+function isRecord$1(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function normalizeRawString(value) {
@@ -1484,18 +1394,18 @@ function parseReceiveEnvelope(event) {
 	} catch (error) {
 		throw new SignalIngressPermanentError("parse-error", "Signal receive event contains invalid JSON", { cause: error });
 	}
-	if (!isRecord(parsed)) throw new SignalIngressPermanentError("parse-error", "Signal receive event must contain a JSON object");
-	return isRecord(parsed.envelope) ? parsed.envelope : null;
+	if (!isRecord$1(parsed)) throw new SignalIngressPermanentError("parse-error", "Signal receive event must contain a JSON object");
+	return isRecord$1(parsed.envelope) ? parsed.envelope : null;
 }
 function resolveDataMessage(envelope) {
-	if (isRecord(envelope.dataMessage)) return envelope.dataMessage;
-	return isRecord(envelope.editMessage?.dataMessage) ? envelope.editMessage.dataMessage : null;
+	if (isRecord$1(envelope.dataMessage)) return envelope.dataMessage;
+	return isRecord$1(envelope.editMessage?.dataMessage) ? envelope.editMessage.dataMessage : null;
 }
 function inspectSignalIngressEvent(event) {
 	const envelope = parseReceiveEnvelope(event);
 	if (!envelope || "syncMessage" in envelope) return null;
 	const dataMessage = resolveDataMessage(envelope);
-	const reactionMessage = isRecord(envelope.reactionMessage) ? envelope.reactionMessage : null;
+	const reactionMessage = isRecord$1(envelope.reactionMessage) ? envelope.reactionMessage : null;
 	if (!dataMessage && !reactionMessage) return null;
 	const senderUuid = normalizeRawString(envelope.sourceUuid);
 	const senderNumber = normalizeRawString(envelope.sourceNumber);
@@ -1503,57 +1413,20 @@ function inspectSignalIngressEvent(event) {
 	if (!senderKey) throw new SignalIngressPermanentError("missing-sender", "Signal dispatchable envelope is missing sourceUuid/sourceNumber");
 	const timestamp = normalizeTimestamp(envelope.timestamp) ?? normalizeTimestamp(dataMessage?.timestamp);
 	if (timestamp === null) throw new SignalIngressPermanentError("missing-timestamp", "Signal dispatchable envelope is missing a stable timestamp");
-	const dataGroup = isRecord(dataMessage?.groupInfo) ? dataMessage.groupInfo : null;
-	const reactionGroup = isRecord(reactionMessage?.groupInfo) ? reactionMessage.groupInfo : null;
+	const dataGroup = isRecord$1(dataMessage?.groupInfo) ? dataMessage.groupInfo : null;
+	const reactionGroup = isRecord$1(reactionMessage?.groupInfo) ? reactionMessage.groupInfo : null;
 	const groupId = normalizeRawString(dataGroup?.groupId) ?? normalizeRawString(reactionGroup?.groupId);
 	return {
 		eventId: JSON.stringify([senderKey, timestamp]),
 		laneKey: groupId ? `group:${groupId}` : `direct:${senderKey}`
 	};
 }
-/** Durable receive chokepoint. Metadata comes from raw fields; payload stays byte-equivalent JSON. */
-async function enqueueSignalIngressEvent(params) {
-	const facts = inspectSignalIngressEvent(params.event);
-	if (!facts) return { kind: "ignored" };
-	const receivedAt = params.now ?? Date.now();
-	await params.queue.prune({
-		completedTtlMs: SIGNAL_INGRESS_COMPLETED_TTL_MS,
-		completedMaxEntries: SIGNAL_INGRESS_COMPLETED_MAX_ENTRIES,
-		failedTtlMs: SIGNAL_INGRESS_FAILED_TTL_MS,
-		failedMaxEntries: SIGNAL_INGRESS_FAILED_MAX_ENTRIES,
-		...params.now === void 0 ? {} : { now: params.now }
-	});
-	return await params.queue.enqueue(facts.eventId, {
-		version: 1,
-		receivedAt,
-		event: params.event
-	}, {
-		receivedAt,
-		laneKey: facts.laneKey
-	});
-}
 function resolveSignalIngressNonRetryableFailure(error) {
 	return error instanceof SignalIngressPermanentError ? {
 		reason: error.reason,
 		message: error.message
 	} : null;
 }
-function createSignalIngressDrain(params) {
-	return createChannelIngressDrain({
-		queue: params.queue,
-		retryPolicy: {
-			maxAttempts: DEFAULT_INGRESS_RETRY_MAX_ATTEMPTS,
-			deadLetterMinAgeMs: DEFAULT_INGRESS_RETRY_DEAD_LETTER_MIN_AGE_MS
-		},
-		resolveNonRetryableFailure: resolveSignalIngressNonRetryableFailure,
-		...params.abortSignal ? { abortSignal: params.abortSignal } : {},
-		...params.onLog ? { onLog: params.onLog } : {},
-		dispatchClaimedEvent: async (record, lifecycle) => {
-			if (!inspectSignalIngressEvent(record.payload.event)) throw new SignalIngressPermanentError("unsupported-event", "Signal ingress row no longer contains a dispatchable envelope");
-			return await params.dispatch(record.payload.event, lifecycle);
-		}
-	});
-}
 /** Open the account queue, recover it, and keep newly appended rows draining. */
 async function startSignalIngressMonitor(params) {
 	let queue = params.queue;
@@ -1562,51 +1435,50 @@ async function startSignalIngressMonitor(params) {
 		if (!pluginRuntime) throw new Error("Signal runtime not initialized for durable ingress");
 		queue = pluginRuntime.state.openChannelIngressQueue({ accountId: params.accountId });
 	}
-	const drain = createSignalIngressDrain({
+	const monitor = createChannelIngressMonitor({
 		queue,
-		dispatch: params.dispatch,
-		onLog: (message) => params.runtime.log?.(`signal ${message}`)
+		inspect: (event) => inspectSignalIngressEvent(event),
+		payload: {
+			version: 1,
+			serialize: (event, { receivedAt }) => ({
+				receivedAt,
+				event
+			}),
+			deserialize: (body) => body.event,
+			encode: ({ body }) => ({
+				version: 1,
+				...body
+			}),
+			decode: (payload) => ({
+				version: payload.version,
+				body: payload
+			}),
+			createClaimError: (_kind, claim) => new SignalIngressPermanentError("unsupported-event", `Signal ingress row ${claim.id} has an invalid payload`)
+		},
+		deliver: (event, lifecycle) => params.dispatch(event, lifecycle),
+		pollIntervalMs: SIGNAL_INGRESS_DRAIN_INTERVAL_MS,
+		retention: {
+			pruneIntervalMs: 0,
+			completedTtlMs: SIGNAL_INGRESS_COMPLETED_TTL_MS,
+			completedMaxEntries: SIGNAL_INGRESS_COMPLETED_MAX_ENTRIES,
+			failedTtlMs: SIGNAL_INGRESS_FAILED_TTL_MS,
+			failedMaxEntries: SIGNAL_INGRESS_FAILED_MAX_ENTRIES
+		},
+		appendRetryDelaysMs: [0],
+		drain: {
+			resolveNonRetryableFailure: resolveSignalIngressNonRetryableFailure,
+			onLog: (message) => params.runtime.log?.(`signal ${message}`)
+		},
+		onError: (error) => params.runtime.error?.(`signal ingress drain failed: ${String(error)}`)
 	});
-	let drainPass;
-	let drainRequested = false;
-	const requestDrain = () => {
-		drainRequested = true;
-		if (!drainPass) drainPass = (async () => {
-			while (drainRequested) {
-				drainRequested = false;
-				if ((await drain.drainOnce()).started > 0) params.runTrackedTask(async () => {
-					await drain.waitForIdle();
-					await requestDrain();
-				});
-			}
-		})().finally(() => {
-			drainPass = void 0;
-			if (drainRequested) requestDrain().catch((error) => {
-				params.runtime.error?.(`signal ingress drain failed: ${String(error)}`);
-			});
-		});
-		return drainPass;
-	};
-	await requestDrain();
-	const timer = setInterval(() => {
-		requestDrain().catch((error) => {
-			params.runtime.error?.(`signal ingress drain failed: ${String(error)}`);
-		});
-	}, SIGNAL_INGRESS_DRAIN_INTERVAL_MS);
-	timer.unref?.();
+	monitor.start();
 	return {
 		receive: async (event) => {
-			if ((await enqueueSignalIngressEvent({
-				queue,
-				event
-			})).kind !== "ignored") await requestDrain();
+			await monitor.admit(event);
+			await monitor.waitForPumpIdle();
 		},
-		stop: async () => {
-			clearInterval(timer);
-			await drainPass?.catch(() => void 0);
-			await drain.waitForIdle();
-			drain.dispose();
-		}
+		stop: monitor.stop,
+		waitForIdle: monitor.waitForIdle
 	};
 }
 //#endregion
@@ -1617,7 +1489,7 @@ const DEFAULT_RECONNECT_POLICY = {
 	factor: 2,
 	jitter: .2
 };
-async function runSignalSseLoop({ baseUrl, account, abortSignal, runtime, onEvent, timeoutMs, apiMode, policy }) {
+async function runSignalSseLoop({ baseUrl, account, abortSignal, runtime, onEvent, timeoutMs, transportKind, policy }) {
 	const reconnectPolicy = {
 		...DEFAULT_RECONNECT_POLICY,
 		...policy
@@ -1635,7 +1507,7 @@ async function runSignalSseLoop({ baseUrl, account, abortSignal, runtime, onEven
 				account,
 				abortSignal,
 				timeoutMs,
-				apiMode,
+				transportKind,
 				onEvent: async (event) => {
 					reconnectAttempts = 0;
 					await onEvent(event);
@@ -1804,7 +1676,7 @@ async function fetchAttachment(params) {
 	const result = await signalRpcRequest("getAttachment", rpcParams, {
 		baseUrl: params.baseUrl,
 		maxResponseBytes: deriveSignalAttachmentRpcMaxResponseBytes(params.maxBytes),
-		apiMode: params.apiMode
+		transportKind: params.transportKind
 	});
 	if (!result?.data) return null;
 	if (estimateBase64DecodedBytes(result.data) > params.maxBytes) throw new Error(`Signal attachment ${attachment.id} exceeds ${(params.maxBytes / (1024 * 1024)).toFixed(0)}MB limit`);
@@ -1966,32 +1838,32 @@ async function monitorSignalProvider(opts = {}) {
 	const reactionMode = accountInfo.config.reactionNotifications ?? "own";
 	const reactionAllowlist = normalizeStringEntries(accountInfo.config.reactionAllowlist);
 	const mediaMaxBytes = (opts.mediaMaxMb ?? accountInfo.config.mediaMaxMb ?? 8) * 1024 * 1024;
+	const transportKind = accountInfo.transport.kind;
+	const managedTransport = accountInfo.transport.kind === "managed-native" ? accountInfo.transport : void 0;
 	const ignoreAttachments = opts.ignoreAttachments ?? accountInfo.config.ignoreAttachments ?? false;
 	const sendReadReceipts = Boolean(opts.sendReadReceipts ?? accountInfo.config.sendReadReceipts);
 	const waitForTransportReadyFn = opts.waitForTransportReady ?? waitForTransportReady;
-	const autoStart = opts.autoStart ?? accountInfo.config.autoStart ?? !accountInfo.config.httpUrl;
-	const configuredApiMode = cfg.channels?.signal?.apiMode ?? "auto";
-	const startupTimeoutMs = Math.min(12e4, Math.max(1e3, opts.startupTimeoutMs ?? accountInfo.config.startupTimeoutMs ?? 3e4));
+	const autoStart = Boolean(managedTransport) && (opts.autoStart ?? true);
+	const startupTimeoutMs = Math.min(12e4, Math.max(1e3, opts.startupTimeoutMs ?? managedTransport?.startupTimeoutMs ?? 3e4));
 	const readReceiptsViaDaemon = autoStart && sendReadReceipts;
 	const daemonLifecycle = createSignalDaemonLifecycle({ abortSignal: opts.abortSignal });
 	const monitorTaskRunner = createSignalMonitorTaskRunner(runtime);
 	let daemonHandle = null;
 	let ingressMonitor;
-	if (autoStart && configuredApiMode === "container") throw new Error("channels.signal.autoStart=true is incompatible with channels.signal.apiMode=container");
 	if (autoStart) {
-		const cliPath = opts.cliPath ?? accountInfo.config.cliPath ?? "signal-cli";
-		const configPath = normalizeOptionalString(opts.configPath) ?? normalizeOptionalString(accountInfo.config.configPath);
-		const httpHost = opts.httpHost ?? accountInfo.config.httpHost ?? "127.0.0.1";
-		const httpPort = opts.httpPort ?? accountInfo.config.httpPort ?? 8080;
+		const cliPath = opts.cliPath ?? managedTransport?.cliPath ?? "signal-cli";
+		const configPath = normalizeOptionalString(opts.configPath) ?? normalizeOptionalString(managedTransport?.configPath);
+		const httpHost = opts.httpHost ?? managedTransport?.httpHost ?? "127.0.0.1";
+		const httpPort = opts.httpPort ?? managedTransport?.httpPort ?? 8080;
 		daemonHandle = spawnSignalDaemon({
 			cliPath,
 			...configPath ? { configPath } : {},
 			account,
 			httpHost,
 			httpPort,
-			receiveMode: opts.receiveMode ?? accountInfo.config.receiveMode,
+			receiveMode: opts.receiveMode ?? managedTransport?.receiveMode,
 			ignoreAttachments: opts.ignoreAttachments ?? accountInfo.config.ignoreAttachments,
-			ignoreStories: opts.ignoreStories ?? accountInfo.config.ignoreStories,
+			ignoreStories: opts.ignoreStories ?? managedTransport?.ignoreStories,
 			sendReadReceipts,
 			runtime
 		});
@@ -2056,7 +1928,7 @@ async function monitorSignalProvider(opts = {}) {
 			readReceiptsViaDaemon,
 			fetchAttachment: (params) => fetchAttachment({
 				...params,
-				apiMode: configuredApiMode
+				transportKind
 			}),
 			deliverReplies: (params) => deliverReplies({
 				...params,
@@ -2071,10 +1943,7 @@ async function monitorSignalProvider(opts = {}) {
 		ingressMonitor = await startSignalIngressMonitor({
 			accountId: accountInfo.accountId,
 			dispatch: handleEvent,
-			runtime,
-			runTrackedTask: (task) => {
-				monitorTaskRunner.runTask(task);
-			}
+			runtime
 		});
 		await runSignalSseLoop({
 			baseUrl,
@@ -2082,7 +1951,7 @@ async function monitorSignalProvider(opts = {}) {
 			abortSignal: daemonLifecycle.abortSignal,
 			runtime,
 			timeoutMs: 0,
-			apiMode: configuredApiMode,
+			transportKind,
 			policy: opts.reconnectPolicy,
 			onEvent: (event) => monitorTaskRunner.runTask(async () => await ingressMonitor?.receive(event))
 		});