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

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

@@ -1,12 +1,14 @@
 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 { a as normalizeSignalAllowRecipient, c as resolveSignalSender, d as normalizeSignalMessagingTarget, i as isSignalSenderAllowed, l as looksLikeUuid, n as formatSignalSenderDisplay, o as resolveSignalPeerId, r as formatSignalSenderId, s as resolveSignalRecipient, t as formatSignalPairingIdLine } from "./identity-BQ4OzXXk.js";
+import { t as getOptionalSignalRuntime } from "./runtime-B900w6lc.js";
+import { a as resolveSignalReactionLevel, c as isSignalNativeApprovalHandlerConfigured, r as materializeSignalPresentationFallback, t as registerSignalReplyContext } from "./reply-authors-DcNqGpX-.js";
+import { n as signalRpcRequest, r as streamSignalEvents, t as signalCheck } from "./client-adapter-DZD8DCai.js";
+import { n as sendReactionSignal, t as removeReactionSignal } from "./reaction-runtime-api-tPkUVRoL.js";
+import { a as maybeResolveSignalApprovalReaction, l as resolveSignalApprovalConversationKey, s as registerSignalApprovalReactionTargetForDeliveredPayload, t as addSignalApprovalReactionHintToStructuredPayload } from "./approval-reactions-DcpZRS5-.js";
+import { r as registerSignalQuestionReactionTargetForDeliveredPayload, t as maybeResolveSignalQuestionReaction } from "./question-reactions-BFFJNQsu.js";
+import { n as sendReadReceiptSignal, r as sendTypingSignal, t as sendMessageSignal } from "./send-f6JLstd2.js";
+import { DEFAULT_INGRESS_RETRY_DEAD_LETTER_MIN_AGE_MS, DEFAULT_INGRESS_RETRY_MAX_ATTEMPTS, bindIngressLifecycleToReplyOptions, createChannelIngressDrain, createChannelMessageReplyPipeline, resolveChannelStreamingBlockEnabled } from "openclaw/plugin-sdk/channel-outbound";
 import { 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";
@@ -20,7 +22,7 @@ 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 { resolveAllowlistProviderRuntimeGroupPolicy, resolveDefaultGroupPolicy, warnMissingProviderGroupPolicyFallbackOnce } from "openclaw/plugin-sdk/runtime-group-policy";
@@ -31,14 +33,14 @@ 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 { buildChannelInboundEventContext, buildMentionRegexes, createChannelInboundDebouncer, filterChannelInboundQuoteContext, formatInboundEnvelope, formatInboundFromLabel, formatInboundMediaUnavailableText, hasVisibleInboundReplyDispatch, logInboundDrop, matchesMentionPatterns, resolveEnvelopeFormatOptions, resolveInboundMentionDecision, resolveInboundSupplementalSenderAllowed, 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,
@@ -661,6 +668,7 @@ function createSignalEventHandler(deps) {
 			},
 			route: {
 				agentId: route.agentId,
+				dmScope: route.dmScope,
 				accountId: route.accountId,
 				routeSessionKey: route.sessionKey
 			},
@@ -786,10 +794,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 +819,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 +836,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 +877,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) => {
@@ -919,20 +921,64 @@ 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,
@@ -940,6 +986,7 @@ function createSignalEventHandler(deps) {
 			mediaPaths: void 0,
 			mediaTypes: void 0
 		});
+		await settle();
 	}
 	async function retrySignalInboundFlush(entries, initialError) {
 		let lastError = initialError;
@@ -974,7 +1021,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 +1038,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: Boolean(entry.mediaPath || entry.mediaType || entry.mediaPaths?.length)
+		}),
 		onFlush: flushNormalSignalInboundEntries,
 		onError: reportSignalInboundFlushError,
 		onCancel: pendingInboundRegistry.complete
@@ -1034,6 +1082,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 +1133,7 @@ function createSignalEventHandler(deps) {
 		});
 		return true;
 	}
-	return async (event) => {
+	return async (event, turnAdoptionLifecycle) => {
 		if (event.event !== "receive" || !event.data) return;
 		let payload;
 		try {
@@ -1372,7 +1432,8 @@ function createSignalEventHandler(deps) {
 			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 +1444,169 @@ 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(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(parsed)) throw new SignalIngressPermanentError("parse-error", "Signal receive event must contain a JSON object");
+	return isRecord(parsed.envelope) ? parsed.envelope : null;
+}
+function resolveDataMessage(envelope) {
+	if (isRecord(envelope.dataMessage)) return envelope.dataMessage;
+	return isRecord(envelope.editMessage?.dataMessage) ? envelope.editMessage.dataMessage : null;
+}
+function inspectSignalIngressEvent(event) {
+	const envelope = parseReceiveEnvelope(event);
+	if (!envelope || "syncMessage" in envelope) return null;
+	const dataMessage = resolveDataMessage(envelope);
+	const reactionMessage = isRecord(envelope.reactionMessage) ? envelope.reactionMessage : null;
+	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(dataMessage?.groupInfo) ? dataMessage.groupInfo : null;
+	const reactionGroup = isRecord(reactionMessage?.groupInfo) ? reactionMessage.groupInfo : null;
+	const groupId = normalizeRawString(dataGroup?.groupId) ?? normalizeRawString(reactionGroup?.groupId);
+	return {
+		eventId: JSON.stringify([senderKey, timestamp]),
+		laneKey: groupId ? `group:${groupId}` : `direct:${senderKey}`
+	};
+}
+/** Durable receive chokepoint. Metadata comes from raw fields; payload stays byte-equivalent JSON. */
+async function enqueueSignalIngressEvent(params) {
+	const facts = inspectSignalIngressEvent(params.event);
+	if (!facts) return { kind: "ignored" };
+	const receivedAt = params.now ?? Date.now();
+	await params.queue.prune({
+		completedTtlMs: SIGNAL_INGRESS_COMPLETED_TTL_MS,
+		completedMaxEntries: SIGNAL_INGRESS_COMPLETED_MAX_ENTRIES,
+		failedTtlMs: SIGNAL_INGRESS_FAILED_TTL_MS,
+		failedMaxEntries: SIGNAL_INGRESS_FAILED_MAX_ENTRIES,
+		...params.now === void 0 ? {} : { now: params.now }
+	});
+	return await params.queue.enqueue(facts.eventId, {
+		version: 1,
+		receivedAt,
+		event: params.event
+	}, {
+		receivedAt,
+		laneKey: facts.laneKey
+	});
+}
+function resolveSignalIngressNonRetryableFailure(error) {
+	return error instanceof SignalIngressPermanentError ? {
+		reason: error.reason,
+		message: error.message
+	} : null;
+}
+function createSignalIngressDrain(params) {
+	return createChannelIngressDrain({
+		queue: params.queue,
+		retryPolicy: {
+			maxAttempts: DEFAULT_INGRESS_RETRY_MAX_ATTEMPTS,
+			deadLetterMinAgeMs: DEFAULT_INGRESS_RETRY_DEAD_LETTER_MIN_AGE_MS
+		},
+		resolveNonRetryableFailure: resolveSignalIngressNonRetryableFailure,
+		...params.abortSignal ? { abortSignal: params.abortSignal } : {},
+		...params.onLog ? { onLog: params.onLog } : {},
+		dispatchClaimedEvent: async (record, lifecycle) => {
+			if (!inspectSignalIngressEvent(record.payload.event)) throw new SignalIngressPermanentError("unsupported-event", "Signal ingress row no longer contains a dispatchable envelope");
+			return await params.dispatch(record.payload.event, lifecycle);
+		}
+	});
+}
+/** Open the account queue, recover it, and keep newly appended rows draining. */
+async function startSignalIngressMonitor(params) {
+	let queue = params.queue;
+	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 drain = createSignalIngressDrain({
+		queue,
+		dispatch: params.dispatch,
+		onLog: (message) => params.runtime.log?.(`signal ${message}`)
+	});
+	let drainPass;
+	let drainRequested = false;
+	const requestDrain = () => {
+		drainRequested = true;
+		if (!drainPass) drainPass = (async () => {
+			while (drainRequested) {
+				drainRequested = false;
+				if ((await drain.drainOnce()).started > 0) params.runTrackedTask(async () => {
+					await drain.waitForIdle();
+					await requestDrain();
+				});
+			}
+		})().finally(() => {
+			drainPass = void 0;
+			if (drainRequested) requestDrain().catch((error) => {
+				params.runtime.error?.(`signal ingress drain failed: ${String(error)}`);
+			});
+		});
+		return drainPass;
+	};
+	await requestDrain();
+	const timer = setInterval(() => {
+		requestDrain().catch((error) => {
+			params.runtime.error?.(`signal ingress drain failed: ${String(error)}`);
+		});
+	}, SIGNAL_INGRESS_DRAIN_INTERVAL_MS);
+	timer.unref?.();
+	return {
+		receive: async (event) => {
+			if ((await enqueueSignalIngressEvent({
+				queue,
+				event
+			})).kind !== "ignored") await requestDrain();
+		},
+		stop: async () => {
+			clearInterval(timer);
+			await drainPass?.catch(() => void 0);
+			await drain.waitForIdle();
+			drain.dispose();
+		}
 	};
 }
 //#endregion
@@ -1412,9 +1636,9 @@ async function runSignalSseLoop({ baseUrl, account, abortSignal, runtime, onEven
 				abortSignal,
 				timeoutMs,
 				apiMode,
-				onEvent: (event) => {
+				onEvent: async (event) => {
 					reconnectAttempts = 0;
-					onEvent(event);
+					await onEvent(event);
 				},
 				logger: {
 					log: runtime.log,
@@ -1447,15 +1671,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 +1689,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 +1716,6 @@ function createSignalDaemonLifecycle(params) {
 		abortSignal
 	};
 }
-function normalizeAllowList(raw) {
-	return normalizeStringEntries(raw);
-}
 function resolveSignalReactionTargets(reaction) {
 	const targets = [];
 	const uuid = reaction.targetAuthorUuid?.trim();
@@ -1654,7 +1878,7 @@ async function deliverReplies(params) {
 				}), visibleText);
 			}
 		}) !== "empty") {
-			registerSignalApprovalReactionTargetForDeliveredPayload({
+			registerSignalReactionTargetsForDeliveredPayload({
 				cfg: params.cfg,
 				target: {
 					channel: "signal",
@@ -1712,7 +1936,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 +1949,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,7 +1964,7 @@ 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 ignoreAttachments = opts.ignoreAttachments ?? accountInfo.config.ignoreAttachments ?? false;
 	const sendReadReceipts = Boolean(opts.sendReadReceipts ?? accountInfo.config.sendReadReceipts);
@@ -1752,6 +1976,7 @@ async function monitorSignalProvider(opts = {}) {
 	const daemonLifecycle = createSignalDaemonLifecycle({ abortSignal: opts.abortSignal });
 	const monitorTaskRunner = createSignalMonitorTaskRunner(runtime);
 	let daemonHandle = null;
+	let ingressMonitor;
 	if (autoStart && configuredApiMode === "container") throw new Error("channels.signal.autoStart=true is incompatible with channels.signal.apiMode=container");
 	if (autoStart) {
 		const cliPath = opts.cliPath ?? accountInfo.config.cliPath ?? "signal-cli";
@@ -1772,9 +1997,7 @@ async function monitorSignalProvider(opts = {}) {
 		});
 		daemonLifecycle.attach(daemonHandle);
 	}
-	const onAbort = () => {
-		daemonLifecycle.stop();
-	};
+	const onAbort = () => void daemonLifecycle.stop();
 	opts.abortSignal?.addEventListener("abort", onAbort, { once: true });
 	try {
 		if (daemonHandle) {
@@ -1809,7 +2032,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,
@@ -1843,6 +2068,14 @@ async function monitorSignalProvider(opts = {}) {
 			shouldEmitSignalReactionNotification,
 			buildSignalReactionSystemEventText
 		});
+		ingressMonitor = await startSignalIngressMonitor({
+			accountId: accountInfo.accountId,
+			dispatch: handleEvent,
+			runtime,
+			runTrackedTask: (task) => {
+				monitorTaskRunner.runTask(task);
+			}
+		});
 		await runSignalSseLoop({
 			baseUrl,
 			account,
@@ -1851,9 +2084,7 @@ async function monitorSignalProvider(opts = {}) {
 			timeoutMs: 0,
 			apiMode: configuredApiMode,
 			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 +2093,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);
 	}

package/dist/{probe-CbWkI24J.js → probe-sSH6ggyy.js}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { n as signalRpcRequest, t as signalCheck } from "./client-adapter-aEM0kGhC.js";
+import { n as signalRpcRequest, t as signalCheck } from "./client-adapter-DZD8DCai.js";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 //#region extensions/signal/src/probe.ts
 var probe_exports = /* @__PURE__ */ __exportAll({ probeSignal: () => probeSignal });