@openclaw/signal 2026.7.2-beta.7 → 2026.7.34

package/dist/{monitor-BvIzkrYW.js → .setup/monitor-CZUTeDiv.mjs}

@@ -1,52 +1,44 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.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-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, createChannelIngressError, createChannelIngressMonitor, createChannelMessageReplyPipeline, resolveChannelStreamingBlockEnabled } from "openclaw/plugin-sdk/channel-outbound";
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { a as resolveSignalReplyToMode, i as resolveSignalAccount } from "./accounts-Bz4HtP0g.mjs";
+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-C8-yk4J9.mjs";
+import { a as isSignalNativeApprovalHandlerConfigured, n as resolveSignalReactionLevel } from "./message-actions-Cplx3XNC.mjs";
+import { n as signalRpcRequest, r as streamSignalEvents, t as signalCheck } from "./client-adapter-BiGMiCr4.mjs";
+import { n as sendReactionSignal, t as removeReactionSignal } from "./reaction-runtime-api-CAxalUfb.mjs";
+import { a as maybeResolveSignalApprovalReaction, l as resolveSignalApprovalConversationKey, s as registerSignalApprovalReactionTargetForDeliveredPayload, t as addSignalApprovalReactionHintToStructuredPayload } from "./approval-reactions-DoY1BVpl.mjs";
+import { n as sendReadReceiptSignal, r as sendTypingSignal, t as sendMessageSignal } from "./send-CF_VPaZJ.mjs";
+import { createChannelMessageReplyPipeline } from "openclaw/plugin-sdk/channel-outbound";
 import { createChannelPairingChallengeIssuer } from "openclaw/plugin-sdk/channel-pairing";
-import { canonicalizeBase64, detectMime, estimateBase64DecodedBytes, kindFromMime, saveMediaBuffer } from "openclaw/plugin-sdk/media-runtime";
+import { detectMime, estimateBase64DecodedBytes, kindFromMime, saveMediaBuffer } from "openclaw/plugin-sdk/media-runtime";
 import { resolveAgentRoute, resolveInboundLastRouteSessionKey } from "openclaw/plugin-sdk/routing";
-import { normalizeNullableString, normalizeOptionalString, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
+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, toInboundMediaFactsWithMetadata } from "openclaw/plugin-sdk/channel-inbound";
 import nodePath from "node:path";
-import { collectErrorGraphCandidates, formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { resolvePinnedMainDmOwnerFromAllowlist } from "openclaw/plugin-sdk/security-runtime";
-import { isRecord as isRecord$1 } from "openclaw/plugin-sdk/channel-secret-basic-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 { chunkTextWithMode, createReplyDispatcherWithTyping, createReplyReferencePlanner, dispatchInboundMessage, resolveChunkMode, resolveTextChunkLimit, settleReplyDispatcher } from "openclaw/plugin-sdk/reply-runtime";
 import { getRuntimeConfig } from "openclaw/plugin-sdk/runtime-config-snapshot";
-import { computeBackoff, createNonExitingRuntime, danger, logVerbose, shouldLogVerbose, sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
+import { computeBackoff, createNonExitingRuntime, danger, logVerbose, shouldLogVerbose, sleep, 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";
 import os from "node:os";
 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 { createChannelIngressResolver, defineStableChannelIngressIdentity, fanInChannelIngressLifecycles } from "openclaw/plugin-sdk/channel-ingress-runtime";
-import { isControlCommandMessage } from "openclaw/plugin-sdk/command-detection";
+import { buildChannelInboundEventContext, buildMentionRegexes, createChannelInboundDebouncer, filterChannelInboundQuoteContext, formatInboundEnvelope, formatInboundFromLabel, formatInboundMediaUnavailableText, hasVisibleInboundReplyDispatch, logInboundDrop, matchesMentionPatterns, resolveEnvelopeFormatOptions, resolveInboundMentionDecision, runChannelInboundEvent, shouldDebounceTextInbound } from "openclaw/plugin-sdk/channel-inbound";
+import { hasControlCommand } from "openclaw/plugin-sdk/command-auth-native";
+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 { 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 { createChannelIngressResolver, defineStableChannelIngressIdentity } from "openclaw/plugin-sdk/channel-ingress-runtime";
 import { resolveChannelContextVisibilityMode } from "openclaw/plugin-sdk/context-visibility-runtime";
 //#region extensions/signal/src/daemon.ts
-const SIGNAL_DAEMON_STOP_KILL_TIMEOUT_MS = 1500;
 function formatSignalDaemonExit(exit) {
 	return `signal daemon exited (source=${exit.source} code=${exit.code ?? "null"} signal=${exit.signal ?? "null"})`;
 }
@@ -99,7 +91,6 @@ function spawnSignalDaemon(opts) {
 	const error = opts.runtime?.error ?? (() => {});
 	let exited = false;
 	let settledExit = false;
-	let stopPromise;
 	let resolveExit;
 	const exitedPromise = new Promise((resolve) => {
 		resolveExit = resolve;
@@ -140,42 +131,19 @@ function spawnSignalDaemon(opts) {
 		});
 	});
 	child.on("error", (err) => {
-		if (child.pid === void 0) {
-			error(`signal-cli spawn error: ${String(err)}`);
-			settleExit({
-				source: "spawn-error",
-				code: null,
-				signal: null
-			});
-		} else error(`signal-cli process error: ${String(err)}`);
+		error(`signal-cli spawn error: ${String(err)}`);
+		settleExit({
+			source: "spawn-error",
+			code: null,
+			signal: null
+		});
 	});
 	return {
 		pid: child.pid ?? void 0,
 		exited: exitedPromise,
 		isExited: () => exited,
 		stop: () => {
-			if (exited) return Promise.resolve();
-			if (stopPromise) return stopPromise;
-			if (!child.killed) try {
-				child.kill("SIGTERM");
-			} catch (err) {
-				error(`signal-cli stop error: ${String(err)}`);
-			}
-			stopPromise = new Promise((resolve) => {
-				const timeout = setTimeout(() => {
-					if (!exited) try {
-						child.kill("SIGKILL");
-					} catch (err) {
-						error(`signal-cli force-stop error: ${String(err)}`);
-					}
-				}, SIGNAL_DAEMON_STOP_KILL_TIMEOUT_MS);
-				timeout.unref?.();
-				exitedPromise.then(() => {
-					clearTimeout(timeout);
-					resolve();
-				});
-			});
-			return stopPromise;
+			if (!child.killed && !exited) child.kill("SIGTERM");
 		}
 	};
 }
@@ -246,8 +214,8 @@ function signalSubjectInput(params) {
 	return {
 		stableId: formatSignalSenderId(params.sender),
 		aliases: {
-			phone: params.sender.kind === "phone" ? params.sender.e164 : params.sender.aliases?.e164,
-			uuid: params.sender.kind === "uuid" ? params.sender.raw : params.sender.aliases?.uuid,
+			phone: params.sender.kind === "phone" ? params.sender.e164 : void 0,
+			uuid: params.sender.kind === "uuid" ? params.sender.raw : void 0,
 			group: params.groupId
 		}
 	};
@@ -313,88 +281,6 @@ async function handleSignalDirectMessageAccess(params) {
 	return false;
 }
 //#endregion
-//#region extensions/signal/src/monitor/event-handler.control-lane.ts
-const SIGNAL_ACTIVE_RUN_CONTROL_COMMAND_KEYS = /* @__PURE__ */ new Set([
-	"approve",
-	"commands",
-	"context",
-	"help",
-	"status",
-	"steer",
-	"tasks",
-	"tools",
-	"whoami"
-]);
-function resolveSignalConversationId(entry) {
-	return (entry.isGroup ? entry.groupId : entry.senderPeerId)?.trim() || null;
-}
-function resolveSignalInboundDebounceKey(accountId, entry) {
-	const conversationId = resolveSignalConversationId(entry);
-	if (!conversationId || !entry.senderPeerId) return null;
-	return `signal:${accountId}:${conversationId}:${entry.senderPeerId}`;
-}
-function resolveSignalInboundConversationKey(accountId, entry) {
-	const conversationId = resolveSignalConversationId(entry);
-	return conversationId ? `signal:${accountId}:${conversationId}` : null;
-}
-function isSignalActiveRunControlText(text) {
-	if (isAbortRequestText(text)) return true;
-	const normalizedBody = normalizeCommandBody(text.trim());
-	const alias = maybeResolveTextAlias(normalizedBody);
-	if (!alias) return false;
-	const command = listChatCommands().find((entry) => entry.textAliases.some((candidate) => candidate.trim().toLowerCase() === alias));
-	if (command?.key === "queue") return normalizedBody.slice(alias.length).trim() === "";
-	return command ? SIGNAL_ACTIVE_RUN_CONTROL_COMMAND_KEYS.has(command.key) : false;
-}
-function resolveSignalControlLaneKey(accountId, entry) {
-	if (!entry.commandAuthorized || !isSignalActiveRunControlText(entry.commandBody)) return null;
-	const conversationId = resolveSignalConversationId(entry);
-	return conversationId ? `signal:${accountId}:${conversationId}:control` : null;
-}
-function createSignalPendingInboundRegistry(accountId) {
-	const trackedEntries = /* @__PURE__ */ new WeakMap();
-	const countsByConversation = /* @__PURE__ */ new Map();
-	const track = (entry) => {
-		if (trackedEntries.has(entry)) return;
-		const conversationKey = resolveSignalInboundConversationKey(accountId, entry);
-		const inboundKey = resolveSignalInboundDebounceKey(accountId, entry);
-		if (!conversationKey || !inboundKey) return;
-		const counts = countsByConversation.get(conversationKey) ?? /* @__PURE__ */ new Map();
-		counts.set(inboundKey, (counts.get(inboundKey) ?? 0) + 1);
-		countsByConversation.set(conversationKey, counts);
-		trackedEntries.set(entry, {
-			conversationKey,
-			inboundKey
-		});
-	};
-	const complete = (entries) => {
-		for (const entry of entries) {
-			const tracked = trackedEntries.get(entry);
-			if (!tracked) continue;
-			trackedEntries.delete(entry);
-			const counts = countsByConversation.get(tracked.conversationKey);
-			const nextCount = (counts?.get(tracked.inboundKey) ?? 0) - 1;
-			if (nextCount > 0) {
-				counts?.set(tracked.inboundKey, nextCount);
-				continue;
-			}
-			counts?.delete(tracked.inboundKey);
-			if (counts?.size === 0) countsByConversation.delete(tracked.conversationKey);
-		}
-	};
-	const cancelPendingOnAbort = (entry, cancelKey) => {
-		if (!entry.commandAuthorized || !isAbortRequestText(entry.commandBody)) return;
-		const conversationKey = resolveSignalInboundConversationKey(accountId, entry);
-		if (!conversationKey) return;
-		for (const inboundKey of countsByConversation.get(conversationKey)?.keys() ?? []) cancelKey(inboundKey);
-	};
-	return {
-		track,
-		complete,
-		cancelPendingOnAbort
-	};
-}
-//#endregion
 //#region extensions/signal/src/monitor/inbound-context.ts
 function resolveSignalQuoteContext(params) {
 	const contextVisibilityMode = resolveChannelContextVisibilityMode({
@@ -407,12 +293,7 @@ function resolveSignalQuoteContext(params) {
 		sourceNumber: params.dataMessage?.quote?.author ?? null,
 		sourceUuid: params.dataMessage?.quote?.authorUuid ?? null
 	});
-	const quoteSenderAllowed = resolveInboundSupplementalSenderAllowed({
-		isGroup: params.isGroup,
-		groupPolicy: params.effectiveGroupAllow.length === 0 ? "open" : "allowlist",
-		allowFrom: params.effectiveGroupAllow,
-		isSenderAllowed: (allowFrom) => quoteSender ? isSignalSenderAllowed(quoteSender, allowFrom) : false
-	});
+	const quoteSenderAllowed = !params.isGroup || params.effectiveGroupAllow.length === 0 ? true : quoteSender ? isSignalSenderAllowed(quoteSender, params.effectiveGroupAllow) : false;
 	const visibleQuote = filterChannelInboundQuoteContext(contextVisibilityMode, {
 		body: quoteText,
 		sender: quoteSender ? formatSignalSenderDisplay(quoteSender) : void 0,
@@ -447,41 +328,6 @@ function clampBounds(start, length, textLength) {
 		end: Math.min(textLength, safeStart + Math.max(0, Math.trunc(length)))
 	};
 }
-function isValidStructuredMention(message, mention) {
-	if (!mention || !(mention.uuid || mention.number)) return false;
-	const { start, length } = mention;
-	if (typeof start !== "number" || typeof length !== "number") return false;
-	return Number.isInteger(start) && Number.isInteger(length) && start >= 0 && length > 0 && start + length <= message.length;
-}
-function normalizeAccountPhone(account) {
-	const trimmed = account?.trim();
-	return trimmed ? normalizeE164(trimmed) : void 0;
-}
-function resolveSignalNativeMentionFacts(params) {
-	const validMentions = (params.mentions ?? []).filter((mention) => isValidStructuredMention(params.message, mention));
-	const botUuid = params.accountUuid?.trim();
-	const botPhone = normalizeAccountPhone(params.account);
-	const canDetectBotMention = Boolean(botUuid || botPhone);
-	const mentionsBot = validMentions.some((mention) => {
-		const mentionUuid = mention.uuid?.trim();
-		if (botUuid && mentionUuid === botUuid) return true;
-		const mentionNumber = mention.number?.trim();
-		return Boolean(botPhone && mentionNumber && normalizeE164(mentionNumber) === botPhone);
-	});
-	return {
-		canDetectBotMention,
-		hasAnyMention: validMentions.length > 0,
-		mentionsBot
-	};
-}
-function resolveSignalMentionFacts(identity, message, mentions) {
-	return resolveSignalNativeMentionFacts({
-		message,
-		mentions,
-		account: identity.account,
-		accountUuid: identity.accountUuid
-	});
-}
 function renderSignalMentions(message, mentions) {
 	if (!message || !mentions?.length) return message;
 	let normalized = message;
@@ -498,14 +344,17 @@ function renderSignalMentions(message, mentions) {
 }
 //#endregion
 //#region extensions/signal/src/monitor/event-handler.ts
-const REPLY_SESSION_INIT_CONFLICT_MESSAGE_RE = /reply session initialization conflicted for \S+/u;
-const RETRYABLE_FLUSH_RETRY_DELAYS_MS = [
-	1e3,
-	2e3,
-	4e3
-];
-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({
@@ -535,13 +384,26 @@ function resolveSignalStatusReactionEmojis(emojis) {
 	};
 }
 async function finalizeSignalStatusReaction(params) {
-	if (params.outcome === "done") await params.controller.setDone();
-	else await params.controller.setError();
+	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);
 	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({
 			isGroup: entry.isGroup,
@@ -587,7 +449,7 @@ function createSignalEventHandler(deps) {
 				channel: "Signal",
 				from: fromLabel,
 				timestamp: historyEntry.timestamp,
-				body: `${[historyEntry.body, formatSignalMediaText(historyEntry.media ?? [])].filter(Boolean).join("\n")}${historyEntry.messageId ? ` [id:${historyEntry.messageId}]` : ""}`,
+				body: `${historyEntry.body}${historyEntry.messageId ? ` [id:${historyEntry.messageId}]` : ""}`,
 				chatType: "group",
 				senderLabel: historyEntry.sender,
 				envelope: envelopeOptions
@@ -599,13 +461,20 @@ function createSignalEventHandler(deps) {
 			historyKey,
 			limit: deps.historyLimit
 		}) : void 0;
-		const replyToMode = resolveSignalReplyToMode({
+		const replyThreading = resolveBatchedReplyThreadingPolicy(resolveSignalReplyToMode({
 			cfg: deps.cfg,
 			accountId: deps.accountId,
 			chatType: entry.isGroup ? "group" : "direct"
-		});
-		const replyThreading = resolveBatchedReplyThreadingPolicy(replyToMode, entry.isBatched === true);
-		const media = await toInboundMediaFactsWithMetadata(entry.media);
+		}), 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 ctxPayload = buildChannelInboundEventContext({
 			channel: "signal",
 			supplemental: { quote: entry.replyToBody ? {
@@ -627,7 +496,6 @@ function createSignalEventHandler(deps) {
 			},
 			route: {
 				agentId: route.agentId,
-				dmScope: route.dmScope,
 				accountId: route.accountId,
 				routeSessionKey: route.sessionKey
 			},
@@ -642,7 +510,6 @@ function createSignalEventHandler(deps) {
 				rawBody: entry.commandBody,
 				commandBody: entry.commandBody
 			},
-			sessionTranscript: { historyLimit: entry.isGroup ? deps.historyLimit : 0 },
 			access: {
 				...entry.isGroup ? { mentions: {
 					canDetectMention: true,
@@ -657,7 +524,7 @@ function createSignalEventHandler(deps) {
 			}
 		});
 		if (shouldLogVerbose()) {
-			const preview = truncateUtf16Safe(body, 200).replace(/\r/g, "\\r").replace(/\n/g, "\\n");
+			const preview = truncateUtf16Safe(body, 200).replace(/\\n/g, "\\\\n");
 			logVerbose(`signal inbound: from=${ctxPayload.From} len=${body.length} preview="${preview}"`);
 		}
 		const statusReactionTimestamp = resolveSignalStatusReactionTimestamp(entry);
@@ -675,6 +542,7 @@ function createSignalEventHandler(deps) {
 			isDirect: !entry.isGroup,
 			isGroup: entry.isGroup,
 			isMentionableGroup: entry.isGroup,
+			requireMention: entry.requireMention === true,
 			canDetectMention: entry.canDetectMention === true,
 			effectiveWasMentioned: entry.wasMentioned === true
 		}));
@@ -690,14 +558,23 @@ 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);
-			} },
+			adapter: {
+				setReaction: async (emoji) => {
+					await sendReactionSignal(statusReactionRecipient, statusReactionTimestamp, emoji, signalReactionOpts);
+					currentStatusReactionEmoji = emoji;
+				},
+				clearReaction: async () => {
+					if (!currentStatusReactionEmoji) return;
+					await removeReactionSignal(statusReactionRecipient, statusReactionTimestamp, currentStatusReactionEmoji, signalReactionOpts);
+					currentStatusReactionEmoji = "";
+				}
+			},
 			initialEmoji: ackReaction,
-			emojis: resolveSignalStatusReactionEmojis(void 0),
-			timing: statusReactionTiming,
+			emojis: resolveSignalStatusReactionEmojis(statusReactionsConfig.emojis),
+			timing: statusReactionsConfig.timing,
 			onError: (err) => {
 				logAckFailure({
 					log: logVerbose,
@@ -707,6 +584,10 @@ function createSignalEventHandler(deps) {
 				});
 			}
 		}) : null;
+		const statusReactionTiming = {
+			...DEFAULT_TIMING,
+			...statusReactionsConfig?.timing
+		};
 		if (statusReactionController) statusReactionController.setQueued();
 		const { onModelSelected, typingCallbacks, ...replyPipeline } = createChannelMessageReplyPipeline({
 			cfg: deps.cfg,
@@ -737,15 +618,12 @@ function createSignalEventHandler(deps) {
 			replyToId: ctxPayload.ReplyToId,
 			author: entry.senderRecipient,
 			body: entry.nativeReplyBody ?? entry.bodyText,
-			allowImplicitCurrentMessage: replyToMode !== "off" && replyThreading?.implicitCurrentMessage !== "deny",
 			state: { hasReplied: false }
 		};
-		const dispatcherOptions = {
+		const { dispatcher, replyOptions, markDispatchIdle } = createReplyDispatcherWithTyping({
 			...replyPipeline,
 			humanDelay: resolveHumanDelayConfig(deps.cfg, route.agentId),
-			typingCallbacks
-		};
-		const delivery = {
+			typingCallbacks,
 			deliver: async (payload, _info) => {
 				await deps.deliverReplies({
 					cfg: deps.cfg,
@@ -765,7 +643,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
@@ -782,14 +660,12 @@ function createSignalEventHandler(deps) {
 					raw: entry
 				}),
 				resolveTurn: () => ({
-					cfg: deps.cfg,
 					channel: "signal",
 					accountId: route.accountId,
-					route: {
-						agentId: route.agentId,
-						sessionKey: route.sessionKey
-					},
+					routeSessionKey: route.sessionKey,
+					storePath,
 					ctxPayload,
+					recordInboundSession,
 					record: {
 						updateLastRoute: !entry.isGroup ? {
 							sessionKey: inboundLastRouteSessionKey,
@@ -823,31 +699,41 @@ function createSignalEventHandler(deps) {
 						historyMap: deps.groupHistories,
 						limit: deps.historyLimit
 					},
-					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
+					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();
+						}
 					}
 				}),
 				onFinalize: (result) => {
@@ -856,7 +742,10 @@ function createSignalEventHandler(deps) {
 					const hasDeliveryFailure = result.dispatched && hasSignalStatusReplyDeliveryFailure(result.dispatchResult);
 					finalizeSignalStatusReaction({
 						controller: statusReactionController,
-						outcome: hasFinalResponse && !hasDeliveryFailure ? "done" : "error"
+						outcome: hasFinalResponse && !hasDeliveryFailure ? "done" : "error",
+						hasFinalResponse,
+						removeAckAfterReply: deps.cfg.messages?.removeAckAfterReply ?? false,
+						timing: statusReactionTiming
 					}).catch((err) => {
 						logVerbose(`signal: status reaction finalize failed: ${String(err)}`);
 					});
@@ -864,116 +753,46 @@ function createSignalEventHandler(deps) {
 			}
 		});
 	}
-	async function flushSignalInboundEntries(entries, lifecycle, settle) {
-		const last = entries.at(-1);
-		if (!last) return;
-		if (entries.length === 1) {
-			await handleSignalInboundMessage({
-				...last,
-				turnAdoptionLifecycle: lifecycle
+	const { debouncer: inboundDebouncer } = createChannelInboundDebouncer({
+		cfg: deps.cfg,
+		channel: "signal",
+		buildKey: (entry) => {
+			const conversationId = entry.isGroup ? entry.groupId ?? "unknown" : entry.senderPeerId;
+			if (!conversationId || !entry.senderPeerId) return null;
+			return `signal:${deps.accountId}:${conversationId}:${entry.senderPeerId}`;
+		},
+		shouldDebounce: (entry) => {
+			return shouldDebounceTextInbound({
+				text: entry.commandBody,
+				cfg: deps.cfg,
+				hasMedia: Boolean(entry.mediaPath || entry.mediaType || entry.mediaPaths?.length)
 			});
-			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;
-		}
-		await handleSignalInboundMessage({
-			...last,
-			bodyText: combinedText,
-			commandBody: combinedCommandBody,
-			turnAdoptionLifecycle: lifecycle,
-			isBatched: true,
-			nativeReplyBody: last.nativeReplyBody ?? last.bodyText,
-			media: entries.flatMap((entry) => entry.media ?? [])
-		});
-		await settle();
-	}
-	async function retrySignalInboundFlush(entries, lifecycle, settle, initialError) {
-		let lastError = initialError;
-		for (const [attemptIndex, delayMs] of RETRYABLE_FLUSH_RETRY_DELAYS_MS.entries()) {
-			const attempt = attemptIndex + 1;
-			logVerbose(`signal: reply session init conflict, retrying ${entries.length} inbound message(s) in ${delayMs}ms (attempt ${attempt}/${RETRYABLE_FLUSH_RETRY_DELAYS_MS.length})`);
-			try {
-				await setTimeout$1(delayMs, void 0, {
-					ref: false,
-					signal: deps.abortSignal
-				});
-			} catch (err) {
-				if (deps.abortSignal?.aborted) return;
-				throw err;
-			}
-			if (deps.abortSignal?.aborted) return;
-			try {
-				await flushSignalInboundEntries(entries, lifecycle, settle);
+		},
+		onFlush: async (entries) => {
+			const last = entries.at(-1);
+			if (!last) return;
+			if (entries.length === 1) {
+				await handleSignalInboundMessage(last);
 				return;
-			} catch (err) {
-				if (deps.abortSignal?.aborted) return;
-				lastError = err;
-				if (!isSignalReplySessionInitConflictError(err)) throw err;
 			}
+			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,
+				isBatched: true,
+				nativeReplyBody: last.nativeReplyBody ?? last.bodyText,
+				mediaPath: void 0,
+				mediaType: void 0,
+				mediaPaths: void 0,
+				mediaTypes: void 0
+			});
+		},
+		onError: (err) => {
+			deps.runtime.error?.(`signal debounce flush failed: ${String(err)}`);
 		}
-		throw lastError;
-	}
-	const flushDebouncedSignalInboundEntries = (entries, createFlush) => {
-		const { lifecycle, settle } = fanInChannelIngressLifecycles(entries.map((entry) => entry.turnAdoptionLifecycle));
-		return createFlush({
-			lifecycle,
-			dispatch: async (admissionLifecycle) => {
-				if (!entries.some((entry) => activeEnqueueEntries.has(entry)) && deps.abortSignal?.aborted) return;
-				try {
-					await flushSignalInboundEntries(entries, admissionLifecycle, settle);
-				} catch (err) {
-					if (!isSignalReplySessionInitConflictError(err)) throw err;
-					if (deps.abortSignal?.aborted) return;
-					await retrySignalInboundFlush(entries, admissionLifecycle, settle, err).catch(async (terminalError) => {
-						await Promise.all(entries.map((entry) => Promise.resolve(entry.turnAdoptionLifecycle?.onAbandoned())));
-						throw terminalError;
-					});
-				}
-			}
-		});
-	};
-	const reportSignalInboundFlushError = (err) => {
-		deps.runtime.error?.(`signal debounce flush failed: ${String(err)}`);
-	};
-	const pendingInboundRegistry = createSignalPendingInboundRegistry(deps.accountId);
-	const trackSignalInboundFlush = (flush) => {
-		deps.runTrackedTask?.(() => flush.completion.catch(() => void 0));
-		return flush;
-	};
-	const flushNormalSignalInboundEntries = (entries, createFlush) => {
-		const flush = flushDebouncedSignalInboundEntries(entries, createFlush);
-		const completion = flush.completion.finally(() => pendingInboundRegistry.complete(entries));
-		return trackSignalInboundFlush({
-			admission: flush.admission,
-			completion
-		});
-	};
-	const { debouncer } = createChannelInboundDebouncer({
-		cfg: deps.cfg,
-		channel: "signal",
-		buildKey: (entry) => resolveSignalInboundDebounceKey(deps.accountId, entry),
-		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
-	});
-	const { debouncer: controlDebouncer } = createChannelInboundDebouncer({
-		cfg: deps.cfg,
-		channel: "signal",
-		serializeImmediate: true,
-		buildKey: (entry) => resolveSignalControlLaneKey(deps.accountId, entry),
-		shouldDebounce: () => false,
-		onFlush: (entries, createFlush) => trackSignalInboundFlush(flushDebouncedSignalInboundEntries(entries, createFlush)),
-		onError: reportSignalInboundFlushError
 	});
 	async function handleReactionOnlyInbound(params) {
 		if (params.hasBodyContent) return false;
@@ -1001,18 +820,6 @@ 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,
@@ -1052,7 +859,7 @@ function createSignalEventHandler(deps) {
 		});
 		return true;
 	}
-	return async (event, turnAdoptionLifecycle) => {
+	return async (event) => {
 		if (event.event !== "receive" || !event.data) return;
 		let payload;
 		try {
@@ -1071,11 +878,10 @@ function createSignalEventHandler(deps) {
 		if ("syncMessage" in envelope) return;
 		const dataMessage = envelope.dataMessage ?? envelope.editMessage?.dataMessage;
 		const reaction = deps.isSignalReactionMessage(envelope.reactionMessage) ? envelope.reactionMessage : deps.isSignalReactionMessage(dataMessage?.reaction) ? dataMessage?.reaction : null;
-		const rawMessage = dataMessage?.message ?? "";
-		const messageText = renderSignalMentions(rawMessage, dataMessage?.mentions).trim();
+		const messageText = renderSignalMentions(dataMessage?.message ?? "", dataMessage?.mentions).trim();
 		const groupId = dataMessage?.groupInfo?.groupId ?? reaction?.groupInfo?.groupId ?? void 0;
 		const isGroup = Boolean(groupId);
-		const hasControlCommandInMessage = isControlCommandMessage(messageText, deps.cfg);
+		const hasControlCommandInMessage = hasControlCommand(messageText, deps.cfg);
 		const senderDisplay = formatSignalSenderDisplay(sender);
 		const { senderAccess, commandAccess } = await resolveSignalAccessState({
 			accountId: deps.accountId,
@@ -1160,16 +966,8 @@ function createSignalEventHandler(deps) {
 			groupId,
 			senderPeerId
 		});
-		const inboundTimestamp = typeof envelope.timestamp === "number" ? envelope.timestamp : typeof dataMessage.timestamp === "number" ? dataMessage.timestamp : void 0;
-		const nativeReplyTargetTimestamp = typeof envelope.editMessage?.targetSentTimestamp === "number" ? envelope.editMessage.targetSentTimestamp : inboundTimestamp;
-		const messageId = typeof inboundTimestamp === "number" ? String(inboundTimestamp) : void 0;
-		const replyToId = typeof nativeReplyTargetTimestamp === "number" ? String(nativeReplyTargetTimestamp) : void 0;
-		const signalToRaw = isGroup ? `group:${groupId}` : `signal:${senderRecipient}`;
-		const signalTo = normalizeSignalMessagingTarget(signalToRaw) ?? signalToRaw;
 		const mentionRegexes = buildMentionRegexes(deps.cfg, route.agentId);
-		const textWasMentioned = isGroup && matchesMentionPatterns(messageText, mentionRegexes);
-		const nativeMentionFacts = resolveSignalMentionFacts(deps, rawMessage, dataMessage?.mentions);
-		const wasMentioned = isGroup && (textWasMentioned || nativeMentionFacts.mentionsBot);
+		const wasMentioned = isGroup && matchesMentionPatterns(messageText, mentionRegexes);
 		const requireMention = isGroup && resolveChannelGroupRequireMention({
 			cfg: deps.cfg,
 			channel: "signal",
@@ -1177,12 +975,12 @@ function createSignalEventHandler(deps) {
 			accountId: deps.accountId,
 			configuredGroupDefaultsToNoMention: true
 		});
-		const canDetectMention = mentionRegexes.length > 0 || nativeMentionFacts.canDetectBotMention;
+		const canDetectMention = mentionRegexes.length > 0;
 		const mentionDecision = resolveInboundMentionDecision({
 			facts: {
 				canDetectMention,
 				wasMentioned,
-				hasAnyMention: nativeMentionFacts.hasAnyMention,
+				hasAnyMention: false,
 				implicitMentionKinds: []
 			},
 			policy: {
@@ -1201,36 +999,27 @@ function createSignalEventHandler(deps) {
 				reason: "no mention",
 				target: senderDisplay
 			});
-			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 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 historyKey = groupId ?? "unknown";
 			createChannelHistoryWindow({ historyMap: deps.groupHistories }).record({
 				historyKey,
 				limit: deps.historyLimit,
 				entry: {
 					sender: envelope.sourceName ?? senderDisplay,
-					body: messageText || visibleQuoteText,
-					media: toHistoryMediaEntries(pendingMedia),
+					body: pendingBodyText,
 					timestamp: envelope.timestamp ?? void 0,
 					messageId: typeof envelope.timestamp === "number" ? String(envelope.timestamp) : void 0
 				}
 			});
-			await registerSignalReplyContext({
-				accountId: deps.accountId,
-				to: signalTo,
-				replyToId,
-				author: senderRecipient,
-				body: messageText || visibleQuoteText,
-				media: pendingMedia,
-				sourceTimestamp: inboundTimestamp
-			});
 			const signalGroupPolicy = resolveChannelGroupPolicy({
 				cfg: deps.cfg,
 				channel: "signal",
@@ -1260,16 +1049,14 @@ 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 [index, attachment] of attachments.entries()) {
+		if (!deps.ignoreAttachments) for (const attachment of attachments) {
 			if (!attachment?.id) {
 				unavailableAttachmentCount += 1;
 				continue;
@@ -1284,20 +1071,25 @@ function createSignalEventHandler(deps) {
 					maxBytes: deps.mediaMaxBytes
 				});
 				if (fetched) {
-					const contentType = fetched.contentType ?? attachment.contentType ?? "application/octet-stream";
-					mediaFacts[index] = {
-						path: fetched.path,
-						url: fetched.path,
-						contentType,
-						kind: kindFromMime(contentType) ?? "unknown"
-					};
+					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;
+					}
 				} else unavailableAttachmentCount += 1;
 			} catch (err) {
 				unavailableAttachmentCount += 1;
 				deps.runtime.error?.(danger(`attachment fetch failed: ${String(err)}`));
 			}
 		}
-		let bodyText = messageText;
+		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 || "";
 		if (unavailableAttachmentCount > 0) {
 			const attachmentLabel = unavailableAttachmentCount === 1 ? "attachment" : "attachments";
 			bodyText = formatInboundMediaUnavailableText({
@@ -1305,7 +1097,9 @@ function createSignalEventHandler(deps) {
 				notice: `[signal ${unavailableAttachmentCount > 1 ? `${unavailableAttachmentCount} ` : ""}${attachmentLabel} unavailable]`
 			});
 		}
-		if (!bodyText && mediaFacts.length === 0 && !visibleQuoteText) return;
+		if (!bodyText) return;
+		const inboundTimestamp = typeof envelope.timestamp === "number" ? envelope.timestamp : typeof dataMessage.timestamp === "number" ? dataMessage.timestamp : void 0;
+		const nativeReplyTargetTimestamp = typeof envelope.editMessage?.targetSentTimestamp === "number" ? envelope.editMessage.targetSentTimestamp : inboundTimestamp;
 		if (deps.sendReadReceipts && !deps.readReceiptsViaDaemon && !isGroup && inboundTimestamp) try {
 			await sendReadReceiptSignal(`signal:${senderRecipient}`, inboundTimestamp, {
 				cfg: deps.cfg,
@@ -1318,16 +1112,9 @@ function createSignalEventHandler(deps) {
 		}
 		else if (deps.sendReadReceipts && !deps.readReceiptsViaDaemon && !isGroup && !inboundTimestamp) logVerbose(`signal read receipt skipped (missing timestamp) for ${senderDisplay}`);
 		const senderName = envelope.sourceName ?? senderDisplay;
-		await registerSignalReplyContext({
-			accountId: deps.accountId,
-			to: signalTo,
-			replyToId,
-			author: senderRecipient,
-			body: messageText,
-			media: mediaFacts,
-			sourceTimestamp: inboundTimestamp
-		});
-		const entry = {
+		const messageId = typeof inboundTimestamp === "number" ? String(inboundTimestamp) : void 0;
+		const replyToId = typeof nativeReplyTargetTimestamp === "number" ? String(nativeReplyTargetTimestamp) : void 0;
+		await inboundDebouncer.enqueue({
 			senderName,
 			senderDisplay,
 			senderRecipient,
@@ -1336,137 +1123,22 @@ function createSignalEventHandler(deps) {
 			groupName,
 			isGroup,
 			bodyText,
-			nativeReplyBody: [messageText, formatSignalMediaText(mediaFacts)].filter(Boolean).join("\n"),
 			commandBody: messageText,
 			timestamp: inboundTimestamp,
 			messageId,
 			replyToId,
-			media: mediaFacts,
+			mediaPath,
+			mediaType,
+			mediaPaths: mediaPaths.length > 0 ? mediaPaths : void 0,
+			mediaTypes: mediaTypes.length > 0 ? mediaTypes : void 0,
 			commandAuthorized,
 			canDetectMention,
 			requireMention,
 			wasMentioned: effectiveWasMentioned,
 			replyToBody: visibleQuoteText || void 0,
 			replyToSender: visibleQuoteSender,
-			replyToIsQuote: visibleQuoteText ? true : void 0,
-			turnAdoptionLifecycle
-		};
-		pendingInboundRegistry.cancelPendingOnAbort(entry, debouncer.cancelKey);
-		const inboundLane = resolveSignalControlLaneKey(deps.accountId, entry) ? controlDebouncer : debouncer;
-		if (inboundLane === debouncer) pendingInboundRegistry.track(entry);
-		activeEnqueueEntries.add(entry);
-		try {
-			await inboundLane.enqueue(entry);
-		} 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_DRAIN_INTERVAL_MS = 1e3;
-const SignalIngressPermanentError = createChannelIngressError("SignalIngressPermanentError", { withReason: true });
-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 = normalizeNullableString(envelope.sourceUuid);
-	const senderNumber = normalizeNullableString(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 = normalizeNullableString(dataGroup?.groupId) ?? normalizeNullableString(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,
-			completedMaxEntries: 1e3,
-			failedMaxEntries: 1e3
-		},
-		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
+			replyToIsQuote: visibleQuoteText ? true : void 0
+		});
 	};
 }
 //#endregion
@@ -1477,7 +1149,7 @@ const DEFAULT_RECONNECT_POLICY = {
 	factor: 2,
 	jitter: .2
 };
-async function runSignalSseLoop({ baseUrl, account, abortSignal, runtime, onEvent, timeoutMs, transportKind, policy }) {
+async function runSignalSseLoop({ baseUrl, account, abortSignal, runtime, onEvent, timeoutMs, apiMode, policy }) {
 	const reconnectPolicy = {
 		...DEFAULT_RECONNECT_POLICY,
 		...policy
@@ -1495,10 +1167,10 @@ async function runSignalSseLoop({ baseUrl, account, abortSignal, runtime, onEven
 				account,
 				abortSignal,
 				timeoutMs,
-				transportKind,
-				onEvent: async (event) => {
+				apiMode,
+				onEvent: (event) => {
 					reconnectAttempts = 0;
-					await onEvent(event);
+					onEvent(event);
 				},
 				logger: {
 					log: runtime.log,
@@ -1531,34 +1203,73 @@ 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);
+		runEventTask(task) {
+			const trackedTask = Promise.resolve().then(task).catch((err) => runtime.error?.(`event handler failed: ${String(err)}`)).finally(() => inFlight.delete(trackedTask));
 			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);
 		}
 	};
 }
+function mergeAbortSignals(a, b) {
+	if (!a && !b) return {
+		signal: void 0,
+		dispose: () => {}
+	};
+	if (!a) return {
+		signal: b,
+		dispose: () => {}
+	};
+	if (!b) return {
+		signal: a,
+		dispose: () => {}
+	};
+	const controller = new AbortController();
+	const abortFrom = (source) => {
+		if (!controller.signal.aborted) controller.abort(source.reason);
+	};
+	if (a.aborted) {
+		abortFrom(a);
+		return {
+			signal: controller.signal,
+			dispose: () => {}
+		};
+	}
+	if (b.aborted) {
+		abortFrom(b);
+		return {
+			signal: controller.signal,
+			dispose: () => {}
+		};
+	}
+	const onAbortA = () => abortFrom(a);
+	const onAbortB = () => abortFrom(b);
+	a.addEventListener("abort", onAbortA, { once: true });
+	b.addEventListener("abort", onAbortB, { once: true });
+	return {
+		signal: controller.signal,
+		dispose: () => {
+			a.removeEventListener("abort", onAbortA);
+			b.removeEventListener("abort", onAbortB);
+		}
+	};
+}
 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 mergedAbort = mergeAbortSignals(params.abortSignal, 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"));
-		daemonStopPromise = daemonHandle?.stop() ?? Promise.resolve();
-		return daemonStopPromise;
+		daemonHandle?.stop();
 	};
 	const attach = (handle) => {
 		daemonHandle = handle;
@@ -1573,9 +1284,13 @@ function createSignalDaemonLifecycle(params) {
 		attach,
 		stop,
 		getExitError,
-		abortSignal
+		abortSignal: mergedAbort.signal,
+		dispose: mergedAbort.dispose
 	};
 }
+function normalizeAllowList(raw) {
+	return normalizeStringEntries(raw);
+}
 function resolveSignalReactionTargets(reaction) {
 	const targets = [];
 	const uuid = reaction.targetAuthorUuid?.trim();
@@ -1645,7 +1360,7 @@ async function waitForSignalDaemonReady(params) {
 		}
 	});
 }
-const SIGNAL_ATTACHMENT_RPC_RESPONSE_HEADROOM_BYTES = 64 * 1024;
+const SIGNAL_ATTACHMENT_RPC_RESPONSE_HEADROOM_BYTES = 65536;
 const SIGNAL_BASE64_OVERHEAD_NUMERATOR = 4;
 const SIGNAL_BASE64_OVERHEAD_DENOMINATOR = 3;
 function deriveSignalAttachmentRpcMaxResponseBytes(maxBytes) {
@@ -1655,7 +1370,7 @@ function deriveSignalAttachmentRpcMaxResponseBytes(maxBytes) {
 async function fetchAttachment(params) {
 	const { attachment } = params;
 	if (!attachment?.id) return null;
-	if (typeof attachment.size === "number" && attachment.size > params.maxBytes) throw new Error(`Signal attachment ${attachment.id} exceeds ${(params.maxBytes / (1024 * 1024)).toFixed(0)}MB limit`);
+	if (typeof attachment.size === "number" && attachment.size > params.maxBytes) throw new Error(`Signal attachment ${attachment.id} exceeds ${(params.maxBytes / 1048576).toFixed(0)}MB limit`);
 	const rpcParams = { id: attachment.id };
 	if (params.account) rpcParams.account = params.account;
 	if (params.groupId) rpcParams.groupId = params.groupId;
@@ -1664,18 +1379,17 @@ async function fetchAttachment(params) {
 	const result = await signalRpcRequest("getAttachment", rpcParams, {
 		baseUrl: params.baseUrl,
 		maxResponseBytes: deriveSignalAttachmentRpcMaxResponseBytes(params.maxBytes),
-		transportKind: params.transportKind
+		apiMode: params.apiMode
 	});
 	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`);
-	const canonicalData = canonicalizeBase64(result.data);
-	if (!canonicalData) throw new Error(`Signal attachment ${attachment.id} returned malformed base64 data`);
-	const buffer = Buffer.from(canonicalData, "base64");
+	if (estimateBase64DecodedBytes(result.data) > params.maxBytes) throw new Error(`Signal attachment ${attachment.id} exceeds ${(params.maxBytes / 1048576).toFixed(0)}MB limit`);
+	const buffer = Buffer.from(result.data, "base64");
 	const originalFilename = normalizeOptionalString(attachment.filename ?? void 0);
-	const saved = await saveMediaBuffer(buffer, normalizeOptionalString(attachment.contentType ?? void 0) ?? await detectMime({
+	const contentType = normalizeOptionalString(attachment.contentType ?? void 0) ?? await detectMime({
 		buffer,
 		filePath: originalFilename
-	}), "inbound", params.maxBytes, originalFilename);
+	});
+	const saved = await saveMediaBuffer(buffer, contentType, "inbound", params.maxBytes, originalFilename);
 	return {
 		path: saved.path,
 		contentType: saved.contentType
@@ -1690,15 +1404,14 @@ async function deliverReplies(params) {
 	});
 	for (const payload of replies) {
 		const deliveryResults = [];
-		const presentationPayload = materializeSignalPresentationFallback(payload);
 		const deliveredPayload = addSignalApprovalReactionHintToStructuredPayload({
 			cfg: params.cfg,
 			accountId,
 			to: target,
-			payload: presentationPayload,
+			payload,
 			targetAuthor: account,
 			targetAuthorUuid: accountUuid
-		}) ?? presentationPayload;
+		}) ?? payload;
 		const reply = resolveSendableOutboundReplyParts(deliveredPayload);
 		const nextNativeReply = createSignalNativeReplyResolver({
 			payload: deliveredPayload,
@@ -1740,7 +1453,7 @@ async function deliverReplies(params) {
 				}), visibleText);
 			}
 		}) !== "empty") {
-			registerSignalReactionTargetsForDeliveredPayload({
+			registerSignalApprovalReactionTargetForDeliveredPayload({
 				cfg: params.cfg,
 				target: {
 					channel: "signal",
@@ -1759,15 +1472,12 @@ async function deliverReplies(params) {
 function resolveSignalNativeReplyOptions(params) {
 	if (params.payload.replyToCurrent === false) return {};
 	const payloadReplyToId = normalizeOptionalString(params.payload.replyToId);
-	const isExplicitCurrentReply = params.payload.replyToTag === true || params.payload.replyToCurrent === true;
-	if (!payloadReplyToId && !isExplicitCurrentReply && params.replyContext?.allowImplicitCurrentMessage === false) return {};
 	const contextReplyToId = normalizeOptionalString(params.replyContext?.replyToId);
-	if (!contextReplyToId || payloadReplyToId && payloadReplyToId !== contextReplyToId) return {};
-	const replyToId = payloadReplyToId ?? contextReplyToId;
+	if (!payloadReplyToId || !contextReplyToId || payloadReplyToId !== contextReplyToId) return {};
 	const replyToAuthor = normalizeOptionalString(params.replyContext?.author);
-	if (!replyToAuthor) return { replyToId };
+	if (!replyToAuthor) return { replyToId: payloadReplyToId };
 	return {
-		replyToId,
+		replyToId: payloadReplyToId,
 		replyToAuthor,
 		replyToBody: params.replyContext?.body ?? ""
 	};
@@ -1798,7 +1508,7 @@ function createSignalNativeReplyResolver(params) {
 	};
 }
 async function monitorSignalProvider(opts = {}) {
-	const runtime = opts.runtime ?? createNonExitingRuntime();
+	const runtime = resolveRuntime(opts);
 	const cfg = opts.config ?? getRuntimeConfig();
 	const accountInfo = resolveSignalAccount({
 		cfg,
@@ -1811,8 +1521,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 = 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 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 defaultGroupPolicy = resolveDefaultGroupPolicy(cfg);
 	const { groupPolicy, providerMissingFallbackApplied } = resolveAllowlistProviderRuntimeGroupPolicy({
 		providerConfigPresent: cfg.channels?.signal !== void 0,
@@ -1826,40 +1536,41 @@ async function monitorSignalProvider(opts = {}) {
 		log: (message) => runtime.log?.(message)
 	});
 	const reactionMode = accountInfo.config.reactionNotifications ?? "own";
-	const reactionAllowlist = normalizeStringEntries(accountInfo.config.reactionAllowlist);
+	const reactionAllowlist = normalizeAllowList(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 = Boolean(managedTransport) && (opts.autoStart ?? true);
-	const startupTimeoutMs = Math.min(12e4, Math.max(1e3, opts.startupTimeoutMs ?? managedTransport?.startupTimeoutMs ?? 3e4));
+	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 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 ?? 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;
+		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;
 		daemonHandle = spawnSignalDaemon({
 			cliPath,
 			...configPath ? { configPath } : {},
 			account,
 			httpHost,
 			httpPort,
-			receiveMode: opts.receiveMode ?? managedTransport?.receiveMode,
+			receiveMode: opts.receiveMode ?? accountInfo.config.receiveMode,
 			ignoreAttachments: opts.ignoreAttachments ?? accountInfo.config.ignoreAttachments,
-			ignoreStories: opts.ignoreStories ?? managedTransport?.ignoreStories,
+			ignoreStories: opts.ignoreStories ?? accountInfo.config.ignoreStories,
 			sendReadReceipts,
 			runtime
 		});
 		daemonLifecycle.attach(daemonHandle);
 	}
-	const onAbort = () => void daemonLifecycle.stop();
+	const onAbort = () => {
+		daemonLifecycle.stop();
+	};
 	opts.abortSignal?.addEventListener("abort", onAbort, { once: true });
 	try {
 		if (daemonHandle) {
@@ -1893,16 +1604,12 @@ async function monitorSignalProvider(opts = {}) {
 		});
 		const handleEvent = createSignalEventHandler({
 			runtime,
-			abortSignal: daemonLifecycle.abortSignal,
-			runTrackedTask: (task) => {
-				monitorTaskRunner.runTask(task);
-			},
 			cfg,
 			baseUrl,
 			account,
 			accountUuid: accountInfo.config.accountUuid,
 			accountId: accountInfo.accountId,
-			blockStreaming: resolveChannelStreamingBlockEnabled(accountInfo.config),
+			blockStreaming: accountInfo.config.blockStreaming,
 			historyLimit,
 			groupHistories,
 			textLimit,
@@ -1918,7 +1625,7 @@ async function monitorSignalProvider(opts = {}) {
 			readReceiptsViaDaemon,
 			fetchAttachment: (params) => fetchAttachment({
 				...params,
-				transportKind
+				apiMode: configuredApiMode
 			}),
 			deliverReplies: (params) => deliverReplies({
 				...params,
@@ -1930,20 +1637,17 @@ 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,
-			transportKind,
+			apiMode: configuredApiMode,
 			policy: opts.reconnectPolicy,
-			onEvent: (event) => monitorTaskRunner.runTask(async () => await ingressMonitor?.receive(event))
+			onEvent: (event) => {
+				monitorTaskRunner.runEventTask(() => handleEvent(event));
+			}
 		});
 		const daemonExitError = daemonLifecycle.getExitError();
 		if (daemonExitError) throw daemonExitError;
@@ -1952,9 +1656,10 @@ async function monitorSignalProvider(opts = {}) {
 		if (opts.abortSignal?.aborted && !daemonExitError) return;
 		throw err;
 	} finally {
-		await ingressMonitor?.stop();
-		await Promise.all([daemonLifecycle.stop(), monitorTaskRunner.waitForIdle()]);
+		await monitorTaskRunner.waitForIdle();
+		daemonLifecycle.dispose();
 		opts.abortSignal?.removeEventListener("abort", onAbort);
+		daemonLifecycle.stop();
 	}
 }
 //#endregion