@openclaw/signal 2026.7.2-beta.2 → 2026.7.2-beta.4

package/dist/{monitor-BdzH3U64.js → monitor-C0aBYlJ0.js}

@@ -1,18 +1,21 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { a as resolveSignalReplyToMode, i as resolveSignalAccount } from "./accounts-Bz4HtP0g.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-BF8taj7g.js";
-import { a as resolveSignalReactionLevel, c as isSignalNativeApprovalHandlerConfigured, r as materializeSignalPresentationFallback, t as registerSignalReplyContext } from "./reply-authors-osU_SY4J.js";
-import { n as signalRpcRequest, r as streamSignalEvents, t as signalCheck } from "./client-adapter-aEM0kGhC.js";
-import { n as sendReactionSignal, t as removeReactionSignal } from "./reaction-runtime-api-DifyinAU.js";
-import { a as maybeResolveSignalApprovalReaction, l as resolveSignalApprovalConversationKey, s as registerSignalApprovalReactionTargetForDeliveredPayload, t as addSignalApprovalReactionHintToStructuredPayload } from "./approval-reactions-ChcS2rQN.js";
-import { n as sendReadReceiptSignal, r as sendTypingSignal, t as sendMessageSignal } from "./send-BWtA6h3J.js";
-import { createChannelMessageReplyPipeline, resolveChannelStreamingBlockEnabled } from "openclaw/plugin-sdk/channel-outbound";
+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-JPrGlV7h.js";
+import { i as materializeSignalPresentationFallback, n as registerSignalReplyContext, o as resolveSignalReactionLevel, s as formatSignalMediaText, u as isSignalNativeApprovalHandlerConfigured } from "./transport-detection-CiZWiMYa.js";
+import { n as signalRpcRequest, r as streamSignalEvents, t as signalCheck } from "./client-adapter-Bm0ZRqJn.js";
+import { n as sendReactionSignal } from "./reaction-runtime-api-Bka61qO9.js";
+import { a as maybeResolveSignalApprovalReaction, l as resolveSignalApprovalConversationKey, s as registerSignalApprovalReactionTargetForDeliveredPayload, t as addSignalApprovalReactionHintToStructuredPayload } from "./approval-reactions-5uyOazxW.js";
+import { r as registerSignalQuestionReactionTargetForDeliveredPayload, t as maybeResolveSignalQuestionReaction } from "./question-reactions-DJ1xQzVF.js";
+import { n as sendReadReceiptSignal, r as sendTypingSignal, t as sendMessageSignal } from "./send-BZAqAa8p.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";
@@ -20,9 +23,9 @@ import { resolveChannelGroupPolicy, resolveChannelGroupRequireMention } from "op
 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, createReplyDispatcherWithTyping, createReplyReferencePlanner, dispatchInboundMessage, resolveChunkMode, resolveTextChunkLimit, settleReplyDispatcher } from "openclaw/plugin-sdk/reply-runtime";
+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";
@@ -31,14 +34,13 @@ 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, runChannelInboundEvent, shouldDebounceTextInbound } from "openclaw/plugin-sdk/channel-inbound";
 import { isControlCommandMessage } from "openclaw/plugin-sdk/command-detection";
-import { recordInboundSession, upsertChannelPairingRequest } from "openclaw/plugin-sdk/conversation-runtime";
 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";
 import { resolveChannelContextVisibilityMode } from "openclaw/plugin-sdk/context-visibility-runtime";
@@ -412,7 +414,12 @@ function resolveSignalQuoteContext(params) {
 		sourceNumber: params.dataMessage?.quote?.author ?? null,
 		sourceUuid: params.dataMessage?.quote?.authorUuid ?? null
 	});
-	const quoteSenderAllowed = !params.isGroup || params.effectiveGroupAllow.length === 0 ? true : quoteSender ? isSignalSenderAllowed(quoteSender, params.effectiveGroupAllow) : false;
+	const quoteSenderAllowed = resolveInboundSupplementalSenderAllowed({
+		isGroup: params.isGroup,
+		groupPolicy: params.effectiveGroupAllow.length === 0 ? "open" : "allowlist",
+		allowFrom: params.effectiveGroupAllow,
+		isSenderAllowed: (allowFrom) => quoteSender ? isSignalSenderAllowed(quoteSender, allowFrom) : false
+	});
 	const visibleQuote = filterChannelInboundQuoteContext(contextVisibilityMode, {
 		body: quoteText,
 		sender: quoteSender ? formatSignalSenderDisplay(quoteSender) : void 0,
@@ -507,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,
@@ -547,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({
@@ -613,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
@@ -631,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 ? {
@@ -661,6 +634,7 @@ function createSignalEventHandler(deps) {
 			},
 			route: {
 				agentId: route.agentId,
+				dmScope: route.dmScope,
 				accountId: route.accountId,
 				routeSessionKey: route.sessionKey
 			},
@@ -675,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,
@@ -723,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,
@@ -749,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,
@@ -786,10 +748,12 @@ function createSignalEventHandler(deps) {
 			allowImplicitCurrentMessage: replyToMode !== "off" && replyThreading?.implicitCurrentMessage !== "deny",
 			state: { hasReplied: false }
 		};
-		const { dispatcher, replyOptions, markDispatchIdle } = createReplyDispatcherWithTyping({
+		const dispatcherOptions = {
 			...replyPipeline,
 			humanDelay: resolveHumanDelayConfig(deps.cfg, route.agentId),
-			typingCallbacks,
+			typingCallbacks
+		};
+		const delivery = {
 			deliver: async (payload, _info) => {
 				await deps.deliverReplies({
 					cfg: deps.cfg,
@@ -809,7 +773,7 @@ function createSignalEventHandler(deps) {
 			onError: (err, info) => {
 				deps.runtime.error?.(danger(`signal ${info.kind} reply failed: ${String(err)}`));
 			}
-		});
+		};
 		const inboundLastRouteSessionKey = resolveInboundLastRouteSessionKey({
 			route,
 			sessionKey: route.sessionKey
@@ -826,12 +790,14 @@ function createSignalEventHandler(deps) {
 					raw: entry
 				}),
 				resolveTurn: () => ({
+					cfg: deps.cfg,
 					channel: "signal",
 					accountId: route.accountId,
-					routeSessionKey: route.sessionKey,
-					storePath,
+					route: {
+						agentId: route.agentId,
+						sessionKey: route.sessionKey
+					},
 					ctxPayload,
-					recordInboundSession,
 					record: {
 						updateLastRoute: !entry.isGroup ? {
 							sessionKey: inboundLastRouteSessionKey,
@@ -865,41 +831,31 @@ function createSignalEventHandler(deps) {
 						historyMap: deps.groupHistories,
 						limit: deps.historyLimit
 					},
-					onPreDispatchFailure: () => settleReplyDispatcher({
-						dispatcher,
-						onSettled: () => markDispatchIdle()
-					}),
-					runDispatch: async () => {
-						try {
-							if (statusReactionController) statusReactionController.setThinking();
-							return await dispatchInboundMessage({
-								ctx: ctxPayload,
-								cfg: deps.cfg,
-								dispatcher,
-								replyOptions: {
-									...replyOptions,
-									disableBlockStreaming: typeof deps.blockStreaming === "boolean" ? !deps.blockStreaming : void 0,
-									...statusReactionController ? {
-										allowProgressCallbacksWhenSourceDeliverySuppressed: true,
-										allowToolLifecycleWhenProgressHidden: true,
-										onToolStart: async (payload) => {
-											const toolName = payload.name?.trim();
-											if (toolName) await statusReactionController.setTool(toolName);
-										},
-										onCompactionStart: async () => {
-											await statusReactionController.setCompacting();
-										},
-										onCompactionEnd: async () => {
-											statusReactionController.cancelPending();
-											await statusReactionController.setThinking();
-										}
-									} : {},
-									onModelSelected
-								}
-							});
-						} finally {
-							markDispatchIdle();
-						}
+					afterRecord: () => {
+						if (statusReactionController) statusReactionController.setThinking();
+					},
+					dispatcherOptions,
+					delivery,
+					sessionInitRetry: { delaysMs: [] },
+					replyOptions: {
+						...entry.turnAdoptionLifecycle ? bindIngressLifecycleToReplyOptions(entry.turnAdoptionLifecycle) : {},
+						disableBlockStreaming: typeof deps.blockStreaming === "boolean" ? !deps.blockStreaming : void 0,
+						...statusReactionController ? {
+							allowProgressCallbacksWhenSourceDeliverySuppressed: true,
+							allowToolLifecycleWhenProgressHidden: true,
+							onToolStart: async (payload) => {
+								const toolName = payload.name?.trim();
+								if (toolName) await statusReactionController.setTool(toolName);
+							},
+							onCompactionStart: async () => {
+								await statusReactionController.setCompacting();
+							},
+							onCompactionEnd: async () => {
+								statusReactionController.cancelPending();
+								await statusReactionController.setThinking();
+							}
+						} : {},
+						onModelSelected
 					}
 				}),
 				onFinalize: (result) => {
@@ -908,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)}`);
 					});
@@ -919,27 +872,69 @@ 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);
 		if (entries.length === 1) {
-			await handleSignalInboundMessage(last);
+			await handleSignalInboundMessage(lifecycle ? {
+				...last,
+				turnAdoptionLifecycle: lifecycle
+			} : last);
+			await settle();
+			return;
+		}
+		const combinedText = entries.map((entry) => entry.bodyText).filter(Boolean).join("\n");
+		const combinedCommandBody = entries.map((entry) => entry.commandBody).filter(Boolean).join("\n");
+		if (!combinedText.trim()) {
+			await settle();
 			return;
 		}
-		const combinedText = entries.map((entry) => entry.bodyText).filter(Boolean).join("\\n");
-		const combinedCommandBody = entries.map((entry) => entry.commandBody).filter(Boolean).join("\\n");
-		if (!combinedText.trim()) return;
 		await handleSignalInboundMessage({
 			...last,
 			bodyText: combinedText,
 			commandBody: combinedCommandBody,
+			...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();
 	}
 	async function retrySignalInboundFlush(entries, initialError) {
 		let lastError = initialError;
@@ -974,7 +969,10 @@ function createSignalEventHandler(deps) {
 		} catch (err) {
 			if (!isSignalReplySessionInitConflictError(err)) throw err;
 			if (deps.abortSignal?.aborted) return;
-			const retryTask = retrySignalInboundFlush(entries, err);
+			const retryTask = retrySignalInboundFlush(entries, err).catch(async (terminalError) => {
+				await Promise.all(entries.map((entry) => Promise.resolve(entry.turnAdoptionLifecycle?.onAbandoned())));
+				throw terminalError;
+			});
 			deps.runTrackedTask?.(() => retryTask.catch(() => void 0));
 			await retryTask;
 		}
@@ -988,13 +986,11 @@ function createSignalEventHandler(deps) {
 		cfg: deps.cfg,
 		channel: "signal",
 		buildKey: (entry) => resolveSignalInboundDebounceKey(deps.accountId, entry),
-		shouldDebounce: (entry) => {
-			return shouldDebounceTextInbound({
-				text: entry.commandBody,
-				cfg: deps.cfg,
-				hasMedia: Boolean(entry.mediaPath || entry.mediaType || entry.mediaPaths?.length)
-			});
-		},
+		shouldDebounce: (entry) => shouldDebounceTextInbound({
+			text: entry.commandBody,
+			cfg: deps.cfg,
+			hasMedia: entry.media?.some((media) => Boolean(media.path || media.url)) === true
+		}),
 		onFlush: flushNormalSignalInboundEntries,
 		onError: reportSignalInboundFlushError,
 		onCancel: pendingInboundRegistry.complete
@@ -1034,6 +1030,18 @@ function createSignalEventHandler(deps) {
 			logVerbose(`Blocked signal reaction sender ${params.senderDisplay} (${params.accessDecision.reasonCode})`);
 			return true;
 		}
+		if (conversationKey && await maybeResolveSignalQuestionReaction({
+			cfg: deps.cfg,
+			accountId: deps.accountId,
+			conversationKey,
+			messageId,
+			reactionKey: emojiLabel,
+			isRemove: Boolean(params.reaction.isRemove),
+			actorId: formatSignalSenderId(params.sender),
+			targetAuthor: params.reaction.targetAuthor,
+			targetAuthorUuid: params.reaction.targetAuthorUuid,
+			logDebug: logVerbose
+		})) return true;
 		const targets = deps.resolveSignalReactionTargets(params.reaction);
 		if (!deps.shouldEmitSignalReactionNotification({
 			mode: deps.reactionMode,
@@ -1073,7 +1081,7 @@ function createSignalEventHandler(deps) {
 		});
 		return true;
 	}
-	return async (event) => {
+	return async (event, turnAdoptionLifecycle) => {
 		if (event.event !== "receive" || !event.data) return;
 		let payload;
 		try {
@@ -1222,23 +1230,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
 				}
@@ -1248,7 +1256,8 @@ function createSignalEventHandler(deps) {
 				to: signalTo,
 				replyToId,
 				author: senderRecipient,
-				body: pendingBodyText,
+				body: messageText || visibleQuoteText,
+				media: pendingMedia,
 				sourceTimestamp: inboundTimestamp
 			});
 			const signalGroupPolicy = resolveChannelGroupPolicy({
@@ -1280,14 +1289,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;
@@ -1302,25 +1313,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({
@@ -1328,7 +1334,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,
@@ -1346,7 +1352,8 @@ function createSignalEventHandler(deps) {
 			to: signalTo,
 			replyToId,
 			author: senderRecipient,
-			body: bodyText,
+			body: messageText,
+			media: mediaFacts,
 			sourceTimestamp: inboundTimestamp
 		});
 		const entry = {
@@ -1358,21 +1365,20 @@ 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,
 			wasMentioned: effectiveWasMentioned,
 			replyToBody: visibleQuoteText || void 0,
 			replyToSender: visibleQuoteSender,
-			replyToIsQuote: visibleQuoteText ? true : void 0
+			replyToIsQuote: visibleQuoteText ? true : void 0,
+			turnAdoptionLifecycle
 		};
 		pendingInboundRegistry.cancelPendingOnAbort(entry, debouncer.cancelKey);
 		const inboundLane = resolveSignalControlLaneKey(deps.accountId, entry) ? controlDebouncer : debouncer;
@@ -1383,6 +1389,131 @@ function createSignalEventHandler(deps) {
 		} finally {
 			activeEnqueueEntries.delete(entry);
 		}
+		if (turnAdoptionLifecycle) return { kind: "deferred" };
+	};
+}
+//#endregion
+//#region extensions/signal/src/reaction-targets.ts
+function registerSignalReactionTargetsForDeliveredPayload(params) {
+	registerSignalQuestionReactionTargetForDeliveredPayload(params);
+	registerSignalApprovalReactionTargetForDeliveredPayload(params);
+}
+//#endregion
+//#region extensions/signal/src/signal-ingress.ts
+const SIGNAL_INGRESS_COMPLETED_TTL_MS = 720 * 60 * 60 * 1e3;
+const SIGNAL_INGRESS_COMPLETED_MAX_ENTRIES = 1e3;
+const SIGNAL_INGRESS_FAILED_TTL_MS = 720 * 60 * 60 * 1e3;
+const SIGNAL_INGRESS_FAILED_MAX_ENTRIES = 1e3;
+const SIGNAL_INGRESS_DRAIN_INTERVAL_MS = 1e3;
+var SignalIngressPermanentError = class extends Error {
+	constructor(reason, message, options) {
+		super(message, options);
+		this.reason = reason;
+		this.name = "SignalIngressPermanentError";
+	}
+};
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeRawString(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function normalizeTimestamp(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : null;
+}
+function parseReceiveEnvelope(event) {
+	if (event.event !== "receive" || !event.data) return null;
+	let parsed;
+	try {
+		parsed = JSON.parse(event.data);
+	} catch (error) {
+		throw new SignalIngressPermanentError("parse-error", "Signal receive event contains invalid JSON", { cause: error });
+	}
+	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$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$1(envelope.reactionMessage) ? envelope.reactionMessage : null;
+	if (!dataMessage && !reactionMessage) return null;
+	const senderUuid = normalizeRawString(envelope.sourceUuid);
+	const senderNumber = normalizeRawString(envelope.sourceNumber);
+	const senderKey = senderUuid ? `uuid:${senderUuid}` : senderNumber ? `number:${senderNumber}` : null;
+	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$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}`
+	};
+}
+function resolveSignalIngressNonRetryableFailure(error) {
+	return error instanceof SignalIngressPermanentError ? {
+		reason: error.reason,
+		message: error.message
+	} : null;
+}
+/** Open the account queue, recover it, and keep newly appended rows draining. */
+async function startSignalIngressMonitor(params) {
+	let queue = params.queue;
+	if (!queue) {
+		const pluginRuntime = getOptionalSignalRuntime();
+		if (!pluginRuntime) throw new Error("Signal runtime not initialized for durable ingress");
+		queue = pluginRuntime.state.openChannelIngressQueue({ accountId: params.accountId });
+	}
+	const monitor = createChannelIngressMonitor({
+		queue,
+		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)}`)
+	});
+	monitor.start();
+	return {
+		receive: async (event) => {
+			await monitor.admit(event);
+			await monitor.waitForPumpIdle();
+		},
+		stop: monitor.stop,
+		waitForIdle: monitor.waitForIdle
 	};
 }
 //#endregion
@@ -1393,7 +1524,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
@@ -1411,10 +1542,10 @@ async function runSignalSseLoop({ baseUrl, account, abortSignal, runtime, onEven
 				account,
 				abortSignal,
 				timeoutMs,
-				apiMode,
-				onEvent: (event) => {
+				transportKind,
+				onEvent: async (event) => {
 					reconnectAttempts = 0;
-					onEvent(event);
+					await onEvent(event);
 				},
 				logger: {
 					log: runtime.log,
@@ -1447,15 +1578,15 @@ var monitor_exports = /* @__PURE__ */ __exportAll({
 	deliverReplies: () => deliverReplies,
 	monitorSignalProvider: () => monitorSignalProvider
 });
-function resolveRuntime(opts) {
-	return opts.runtime ?? createNonExitingRuntime();
-}
 function createSignalMonitorTaskRunner(runtime) {
 	const inFlight = /* @__PURE__ */ new Set();
 	return {
 		runTask(task) {
-			const trackedTask = Promise.resolve().then(task).catch((err) => runtime.error?.(`signal monitor task failed: ${String(err)}`)).finally(() => inFlight.delete(trackedTask));
+			const trackedTask = Promise.resolve().then(task);
 			inFlight.add(trackedTask);
+			trackedTask.catch((err) => runtime.error?.(`signal monitor task failed: ${String(err)}`));
+			trackedTask.finally(() => inFlight.delete(trackedTask)).catch(() => void 0);
+			return trackedTask;
 		},
 		async waitForIdle() {
 			while (inFlight.size > 0) await Promise.allSettled(inFlight);
@@ -1465,13 +1596,16 @@ function createSignalMonitorTaskRunner(runtime) {
 function createSignalDaemonLifecycle(params) {
 	let daemonHandle = null;
 	let daemonStopRequested = false;
+	let daemonStopPromise;
 	let daemonExitError;
 	const daemonAbortController = new AbortController();
 	const abortSignal = params.abortSignal ? AbortSignal.any([params.abortSignal, daemonAbortController.signal]) : daemonAbortController.signal;
 	const stop = () => {
+		if (daemonStopPromise) return daemonStopPromise;
 		daemonStopRequested = true;
 		if (!daemonAbortController.signal.aborted) daemonAbortController.abort(params.abortSignal?.reason ?? /* @__PURE__ */ new Error("Signal monitor stopped"));
-		return daemonHandle?.stop() ?? Promise.resolve();
+		daemonStopPromise = daemonHandle?.stop() ?? Promise.resolve();
+		return daemonStopPromise;
 	};
 	const attach = (handle) => {
 		daemonHandle = handle;
@@ -1489,9 +1623,6 @@ function createSignalDaemonLifecycle(params) {
 		abortSignal
 	};
 }
-function normalizeAllowList(raw) {
-	return normalizeStringEntries(raw);
-}
 function resolveSignalReactionTargets(reaction) {
 	const targets = [];
 	const uuid = reaction.targetAuthorUuid?.trim();
@@ -1580,7 +1711,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`);
@@ -1654,7 +1785,7 @@ async function deliverReplies(params) {
 				}), visibleText);
 			}
 		}) !== "empty") {
-			registerSignalApprovalReactionTargetForDeliveredPayload({
+			registerSignalReactionTargetsForDeliveredPayload({
 				cfg: params.cfg,
 				target: {
 					channel: "signal",
@@ -1712,7 +1843,7 @@ function createSignalNativeReplyResolver(params) {
 	};
 }
 async function monitorSignalProvider(opts = {}) {
-	const runtime = resolveRuntime(opts);
+	const runtime = opts.runtime ?? createNonExitingRuntime();
 	const cfg = opts.config ?? getRuntimeConfig();
 	const accountInfo = resolveSignalAccount({
 		cfg,
@@ -1725,8 +1856,8 @@ async function monitorSignalProvider(opts = {}) {
 	const baseUrl = normalizeOptionalString(opts.baseUrl) ?? accountInfo.baseUrl;
 	const account = normalizeOptionalString(opts.account) ?? normalizeOptionalString(accountInfo.config.account);
 	const dmPolicy = accountInfo.config.dmPolicy ?? "pairing";
-	const allowFrom = normalizeAllowList(opts.allowFrom ?? accountInfo.config.allowFrom);
-	const groupAllowFrom = normalizeAllowList(opts.groupAllowFrom ?? accountInfo.config.groupAllowFrom ?? (accountInfo.config.allowFrom && accountInfo.config.allowFrom.length > 0 ? accountInfo.config.allowFrom : []));
+	const allowFrom = normalizeStringEntries(opts.allowFrom ?? accountInfo.config.allowFrom);
+	const groupAllowFrom = normalizeStringEntries(opts.groupAllowFrom ?? accountInfo.config.groupAllowFrom ?? (accountInfo.config.allowFrom && accountInfo.config.allowFrom.length > 0 ? accountInfo.config.allowFrom : []));
 	const defaultGroupPolicy = resolveDefaultGroupPolicy(cfg);
 	const { groupPolicy, providerMissingFallbackApplied } = resolveAllowlistProviderRuntimeGroupPolicy({
 		providerConfigPresent: cfg.channels?.signal !== void 0,
@@ -1740,41 +1871,40 @@ async function monitorSignalProvider(opts = {}) {
 		log: (message) => runtime.log?.(message)
 	});
 	const reactionMode = accountInfo.config.reactionNotifications ?? "own";
-	const reactionAllowlist = normalizeAllowList(accountInfo.config.reactionAllowlist);
+	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;
-	if (autoStart && configuredApiMode === "container") throw new Error("channels.signal.autoStart=true is incompatible with channels.signal.apiMode=container");
+	let ingressMonitor;
 	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
 		});
 		daemonLifecycle.attach(daemonHandle);
 	}
-	const onAbort = () => {
-		daemonLifecycle.stop();
-	};
+	const onAbort = () => void daemonLifecycle.stop();
 	opts.abortSignal?.addEventListener("abort", onAbort, { once: true });
 	try {
 		if (daemonHandle) {
@@ -1809,7 +1939,9 @@ async function monitorSignalProvider(opts = {}) {
 		const handleEvent = createSignalEventHandler({
 			runtime,
 			abortSignal: daemonLifecycle.abortSignal,
-			runTrackedTask: (task) => monitorTaskRunner.runTask(task),
+			runTrackedTask: (task) => {
+				monitorTaskRunner.runTask(task);
+			},
 			cfg,
 			baseUrl,
 			account,
@@ -1831,7 +1963,7 @@ async function monitorSignalProvider(opts = {}) {
 			readReceiptsViaDaemon,
 			fetchAttachment: (params) => fetchAttachment({
 				...params,
-				apiMode: configuredApiMode
+				transportKind
 			}),
 			deliverReplies: (params) => deliverReplies({
 				...params,
@@ -1843,17 +1975,20 @@ async function monitorSignalProvider(opts = {}) {
 			shouldEmitSignalReactionNotification,
 			buildSignalReactionSystemEventText
 		});
+		ingressMonitor = await startSignalIngressMonitor({
+			accountId: accountInfo.accountId,
+			dispatch: handleEvent,
+			runtime
+		});
 		await runSignalSseLoop({
 			baseUrl,
 			account,
 			abortSignal: daemonLifecycle.abortSignal,
 			runtime,
 			timeoutMs: 0,
-			apiMode: configuredApiMode,
+			transportKind,
 			policy: opts.reconnectPolicy,
-			onEvent: (event) => {
-				monitorTaskRunner.runTask(() => handleEvent(event));
-			}
+			onEvent: (event) => monitorTaskRunner.runTask(async () => await ingressMonitor?.receive(event))
 		});
 		const daemonExitError = daemonLifecycle.getExitError();
 		if (daemonExitError) throw daemonExitError;
@@ -1862,6 +1997,7 @@ async function monitorSignalProvider(opts = {}) {
 		if (opts.abortSignal?.aborted && !daemonExitError) return;
 		throw err;
 	} finally {
+		await ingressMonitor?.stop();
 		await Promise.all([daemonLifecycle.stop(), monitorTaskRunner.waitForIdle()]);
 		opts.abortSignal?.removeEventListener("abort", onAbort);
 	}