@openclaw/signal 2026.7.2-beta.5 → 2026.8.1-beta.2

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

@@ -2,24 +2,24 @@ 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, createChannelIngressMonitor, createChannelMessageReplyPipeline, resolveChannelStreamingBlockEnabled } from "openclaw/plugin-sdk/channel-outbound";
+import { i as materializeSignalPresentationFallback, n as registerSignalReplyContext, o as resolveSignalReactionLevel, s as formatSignalMediaText, u as isSignalNativeApprovalHandlerConfigured } from "./transport-detection-BItHawMq.js";
+import { n as signalRpcRequest, r as streamSignalEvents, t as signalCheck } from "./client-adapter-D9SNPaNx.js";
+import { n as sendReactionSignal } from "./reaction-runtime-api-Cf6QHcE5.js";
+import { a as maybeResolveSignalApprovalReaction, l as resolveSignalApprovalConversationKey, s as registerSignalApprovalReactionTargetForDeliveredPayload, t as addSignalApprovalReactionHintToStructuredPayload } from "./approval-reactions-BulCzhdB.js";
+import { r as registerSignalQuestionReactionTargetForDeliveredPayload, t as maybeResolveSignalQuestionReaction } from "./question-reactions-ByjH5qST.js";
+import { n as sendReadReceiptSignal, r as sendTypingSignal, t as sendMessageSignal } from "./send-BvGgByMd.js";
+import { bindIngressLifecycleToReplyOptions, createChannelIngressError, createChannelIngressMonitor, createChannelMessageReplyPipeline, resolveChannelStreamingBlockEnabled } from "openclaw/plugin-sdk/channel-outbound";
 import { createChannelPairingChallengeIssuer } from "openclaw/plugin-sdk/channel-pairing";
-import { detectMime, estimateBase64DecodedBytes, kindFromMime, saveMediaBuffer } from "openclaw/plugin-sdk/media-runtime";
+import { canonicalizeBase64, detectMime, estimateBase64DecodedBytes, kindFromMime, saveMediaBuffer } from "openclaw/plugin-sdk/media-runtime";
 import { resolveAgentRoute, resolveInboundLastRouteSessionKey } from "openclaw/plugin-sdk/routing";
-import { normalizeOptionalString, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { asPositiveSafeInteger, isRecord, normalizeNullableString, normalizeOptionalString, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { CHANNEL_APPROVAL_NATIVE_RUNTIME_CONTEXT_CAPABILITY } from "openclaw/plugin-sdk/approval-handler-adapter-runtime";
 import { normalizeE164, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
-import { buildChannelInboundEventContext, buildMentionRegexes, createChannelInboundDebouncer, filterChannelInboundQuoteContext, formatInboundEnvelope, formatInboundFromLabel, formatInboundMediaUnavailableText, hasVisibleInboundReplyDispatch, logInboundDrop, matchesMentionPatterns, resolveEnvelopeFormatOptions, resolveInboundMentionDecision, resolveInboundSupplementalSenderAllowed, runChannelInboundEvent, shouldDebounceTextInbound, toHistoryMediaEntries, toInboundMediaFacts } from "openclaw/plugin-sdk/channel-inbound";
-import nodePath from "node:path";
+import { buildChannelInboundEventContext, buildMentionRegexes, createChannelInboundDebouncer, filterChannelInboundQuoteContext, formatInboundEnvelope, formatInboundFromLabel, formatInboundMediaUnavailableText, hasVisibleInboundReplyDispatch, logInboundDrop, matchesMentionPatterns, readAgentRunTerminalOutcome, resolveEnvelopeFormatOptions, resolveInboundMentionDecision, resolveInboundSupplementalSenderAllowed, runChannelInboundEvent, shouldDebounceTextInbound, toHistoryMediaEntries, toInboundMediaFactsWithMetadata } from "openclaw/plugin-sdk/channel-inbound";
 import { collectErrorGraphCandidates, formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { resolvePinnedMainDmOwnerFromAllowlist } from "openclaw/plugin-sdk/security-runtime";
 import { resolveChannelGroupPolicy, resolveChannelGroupRequireMention } from "openclaw/plugin-sdk/channel-policy";
+import path from "node:path";
 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";
@@ -44,6 +44,7 @@ import { upsertChannelPairingRequest } from "openclaw/plugin-sdk/conversation-ru
 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";
+import { channelReadyPatch } from "openclaw/plugin-sdk/gateway-runtime";
 //#region extensions/signal/src/daemon.ts
 const SIGNAL_DAEMON_STOP_KILL_TIMEOUT_MS = 1500;
 function formatSignalDaemonExit(exit) {
@@ -71,7 +72,7 @@ function bindSignalCliOutput(params) {
 function resolveSignalCliConfigPath(raw) {
 	const value = raw.trim();
 	if (value === "~") return os.homedir();
-	if (value.startsWith("~/") || value.startsWith("~\\")) return nodePath.join(os.homedir(), value.slice(2));
+	if (value.startsWith("~/") || value.startsWith("~\\")) return path.join(os.homedir(), value.slice(2));
 	return value;
 }
 function buildDaemonArgs(opts) {
@@ -179,6 +180,37 @@ function spawnSignalDaemon(opts) {
 	};
 }
 //#endregion
+//#region extensions/signal/src/daemon-lifecycle.ts
+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"));
+		daemonStopPromise = daemonHandle?.stop() ?? Promise.resolve();
+		return daemonStopPromise;
+	};
+	const attach = (handle) => {
+		daemonHandle = handle;
+		handle.exited.then((exit) => {
+			if (daemonStopRequested || params.abortSignal?.aborted) return;
+			daemonExitError = new Error(formatSignalDaemonExit(exit));
+			if (!daemonAbortController.signal.aborted) daemonAbortController.abort(daemonExitError);
+		});
+	};
+	return {
+		attach,
+		stop,
+		getExitError: () => daemonExitError,
+		abortSignal
+	};
+}
+//#endregion
 //#region extensions/signal/src/monitor/access-policy.ts
 const SIGNAL_UUID_KIND = "plugin:signal-uuid";
 const SIGNAL_GROUP_KIND = "plugin:signal-group";
@@ -273,6 +305,7 @@ async function resolveSignalAccessState(params) {
 			kind: isGroup ? "group" : "direct",
 			id: isGroup ? params.groupId ?? "unknown" : params.sender.raw
 		},
+		contextBinding: params.contextBinding,
 		...isGroup ? { event: { mayPair: false } } : {},
 		dmPolicy: params.dmPolicy,
 		groupPolicy: params.groupPolicy,
@@ -387,17 +420,9 @@ function createSignalPendingInboundRegistry(accountId) {
 		if (!conversationKey) return;
 		for (const inboundKey of countsByConversation.get(conversationKey)?.keys() ?? []) cancelKey(inboundKey);
 	};
-	const completeAfter = (flush) => async (entries) => {
-		try {
-			await flush(entries);
-		} finally {
-			complete(entries);
-		}
-	};
 	return {
 		track,
 		complete,
-		completeAfter,
 		cancelPendingOnAbort
 	};
 }
@@ -612,8 +637,8 @@ function createSignalEventHandler(deps) {
 			chatType: entry.isGroup ? "group" : "direct"
 		});
 		const replyThreading = resolveBatchedReplyThreadingPolicy(replyToMode, entry.isBatched === true);
-		const media = toInboundMediaFacts(entry.media);
-		const ctxPayload = buildChannelInboundEventContext({
+		const media = await toInboundMediaFactsWithMetadata(entry.media);
+		const ctxPayload = (deps.channelRuntime?.inbound.buildContext ?? buildChannelInboundEventContext)({
 			channel: "signal",
 			supplemental: { quote: entry.replyToBody ? {
 				body: entry.replyToBody,
@@ -657,6 +682,7 @@ function createSignalEventHandler(deps) {
 				} } : {},
 				commands: { authorized: entry.commandAuthorized }
 			},
+			channelIngress: entry.channelIngress,
 			media,
 			extra: {
 				GroupSubject: entry.isGroup ? entry.groupName ?? void 0 : void 0,
@@ -664,7 +690,7 @@ function createSignalEventHandler(deps) {
 			}
 		});
 		if (shouldLogVerbose()) {
-			const preview = truncateUtf16Safe(body, 200).replace(/\\n/g, "\\\\n");
+			const preview = truncateUtf16Safe(body, 200).replace(/\r/g, "\\r").replace(/\n/g, "\\n");
 			logVerbose(`signal inbound: from=${ctxPayload.From} len=${body.length} preview="${preview}"`);
 		}
 		const statusReactionTimestamp = resolveSignalStatusReactionTimestamp(entry);
@@ -682,7 +708,6 @@ function createSignalEventHandler(deps) {
 			isDirect: !entry.isGroup,
 			isGroup: entry.isGroup,
 			isMentionableGroup: entry.isGroup,
-			requireMention: entry.requireMention === true,
 			canDetectMention: entry.canDetectMention === true,
 			effectiveWasMentioned: entry.wasMentioned === true
 		}));
@@ -846,13 +871,16 @@ function createSignalEventHandler(deps) {
 							onToolStart: async (payload) => {
 								const toolName = payload.name?.trim();
 								if (toolName) await statusReactionController.setTool(toolName);
+								return false;
 							},
 							onCompactionStart: async () => {
 								await statusReactionController.setCompacting();
+								return false;
 							},
 							onCompactionEnd: async () => {
 								statusReactionController.cancelPending();
 								await statusReactionController.setThinking();
+								return false;
 							}
 						} : {},
 						onModelSelected
@@ -862,9 +890,10 @@ function createSignalEventHandler(deps) {
 					if (!statusReactionController) return;
 					const hasFinalResponse = result.dispatched && hasVisibleInboundReplyDispatch(result.dispatchResult);
 					const hasDeliveryFailure = result.dispatched && hasSignalStatusReplyDeliveryFailure(result.dispatchResult);
+					const hasAgentRunFailure = result.dispatched && readAgentRunTerminalOutcome(result.dispatchResult) === "failed";
 					finalizeSignalStatusReaction({
 						controller: statusReactionController,
-						outcome: hasFinalResponse && !hasDeliveryFailure ? "done" : "error"
+						outcome: hasFinalResponse && !hasDeliveryFailure && !hasAgentRunFailure ? "done" : "error"
 					}).catch((err) => {
 						logVerbose(`signal: status reaction finalize failed: ${String(err)}`);
 					});
@@ -872,15 +901,21 @@ function createSignalEventHandler(deps) {
 			}
 		});
 	}
-	async function flushSignalInboundEntries(entries) {
+	async function flushSignalInboundEntries(entries, lifecycle, settle) {
 		const last = entries.at(-1);
 		if (!last) return;
-		const { lifecycle, settle } = fanInChannelIngressLifecycles(entries.map((entry) => entry.turnAdoptionLifecycle));
+		const channelIngress = await resolveSignalBatchChannelIngress(entries, last);
+		if (channelIngress.some((entry) => !entry.senderAccess.allowed)) {
+			logVerbose("signal: authorization changed before dispatch");
+			await settle();
+			return;
+		}
 		if (entries.length === 1) {
-			await handleSignalInboundMessage(lifecycle ? {
+			await handleSignalInboundMessage({
 				...last,
+				channelIngress,
 				turnAdoptionLifecycle: lifecycle
-			} : last);
+			});
 			await settle();
 			return;
 		}
@@ -894,14 +929,34 @@ function createSignalEventHandler(deps) {
 			...last,
 			bodyText: combinedText,
 			commandBody: combinedCommandBody,
-			...lifecycle ? { turnAdoptionLifecycle: lifecycle } : {},
+			turnAdoptionLifecycle: lifecycle,
 			isBatched: true,
 			nativeReplyBody: last.nativeReplyBody ?? last.bodyText,
-			media: entries.flatMap((entry) => entry.media ?? [])
+			media: entries.flatMap((entry) => entry.media ?? []),
+			channelIngress
 		});
 		await settle();
 	}
-	async function retrySignalInboundFlush(entries, initialError) {
+	async function resolveSignalBatchChannelIngress(entries, last) {
+		if (last.boundChannelIngress) return last.boundChannelIngress;
+		const route = resolveSignalInboundRoute({
+			cfg: deps.cfg,
+			accountId: deps.accountId,
+			isGroup: last.isGroup,
+			groupId: last.groupId,
+			senderPeerId: last.senderPeerId
+		});
+		const contextBinding = {
+			agentId: route.agentId,
+			sessionKey: route.sessionKey,
+			...last.messageId ? { messageId: last.messageId } : {},
+			inboundEventKind: "user_request"
+		};
+		const resolved = await Promise.all(entries.flatMap((entry) => entry.resolveChannelIngress ? [entry.resolveChannelIngress(contextBinding)] : (entry.channelIngress ?? []).map(async (ingress) => ingress)));
+		last.boundChannelIngress = resolved;
+		return resolved;
+	}
+	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;
@@ -917,7 +972,7 @@ function createSignalEventHandler(deps) {
 			}
 			if (deps.abortSignal?.aborted) return;
 			try {
-				await flushSignalInboundEntries(entries);
+				await flushSignalInboundEntries(entries, lifecycle, settle);
 				return;
 			} catch (err) {
 				if (deps.abortSignal?.aborted) return;
@@ -927,26 +982,41 @@ function createSignalEventHandler(deps) {
 		}
 		throw lastError;
 	}
-	const flushDebouncedSignalInboundEntries = async (entries) => {
-		if (!entries.some((entry) => activeEnqueueEntries.has(entry)) && deps.abortSignal?.aborted) return;
-		try {
-			await flushSignalInboundEntries(entries);
-		} catch (err) {
-			if (!isSignalReplySessionInitConflictError(err)) throw err;
-			if (deps.abortSignal?.aborted) return;
-			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;
-		}
+	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 flushNormalSignalInboundEntries = pendingInboundRegistry.completeAfter(flushDebouncedSignalInboundEntries);
+	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",
@@ -966,7 +1036,7 @@ function createSignalEventHandler(deps) {
 		serializeImmediate: true,
 		buildKey: (entry) => resolveSignalControlLaneKey(deps.accountId, entry),
 		shouldDebounce: () => false,
-		onFlush: flushDebouncedSignalInboundEntries,
+		onFlush: (entries, createFlush) => trackSignalInboundFlush(flushDebouncedSignalInboundEntries(entries, createFlush)),
 		onError: reportSignalInboundFlushError
 	});
 	async function handleReactionOnlyInbound(params) {
@@ -1011,6 +1081,7 @@ function createSignalEventHandler(deps) {
 		if (!deps.shouldEmitSignalReactionNotification({
 			mode: deps.reactionMode,
 			account: deps.account,
+			accountUuid: deps.accountUuid,
 			targets,
 			sender: params.sender,
 			allowlist: deps.reactionAllowlist
@@ -1071,7 +1142,7 @@ function createSignalEventHandler(deps) {
 		const isGroup = Boolean(groupId);
 		const hasControlCommandInMessage = isControlCommandMessage(messageText, deps.cfg);
 		const senderDisplay = formatSignalSenderDisplay(sender);
-		const { senderAccess, commandAccess } = await resolveSignalAccessState({
+		const resolveChannelIngress = async (contextBinding) => await resolveSignalAccessState({
 			accountId: deps.accountId,
 			dmPolicy: deps.dmPolicy,
 			groupPolicy: deps.groupPolicy,
@@ -1081,8 +1152,10 @@ function createSignalEventHandler(deps) {
 			groupId,
 			isGroup,
 			cfg: deps.cfg,
-			hasControlCommand: hasControlCommandInMessage
+			hasControlCommand: hasControlCommandInMessage,
+			contextBinding
 		});
+		const { senderAccess, commandAccess } = await resolveChannelIngress();
 		const quoteText = normalizeOptionalString(dataMessage?.quote?.text) ?? "";
 		const { contextVisibilityMode, quoteSenderAllowed, visibleQuoteText, visibleQuoteSender } = resolveSignalQuoteContext({
 			cfg: deps.cfg,
@@ -1212,8 +1285,8 @@ function createSignalEventHandler(deps) {
 					sender: envelope.sourceName ?? senderDisplay,
 					body: messageText || visibleQuoteText,
 					media: toHistoryMediaEntries(pendingMedia),
-					timestamp: envelope.timestamp ?? void 0,
-					messageId: typeof envelope.timestamp === "number" ? String(envelope.timestamp) : void 0
+					timestamp: inboundTimestamp,
+					messageId
 				}
 			});
 			await registerSignalReplyContext({
@@ -1343,7 +1416,8 @@ function createSignalEventHandler(deps) {
 			replyToBody: visibleQuoteText || void 0,
 			replyToSender: visibleQuoteSender,
 			replyToIsQuote: visibleQuoteText ? true : void 0,
-			turnAdoptionLifecycle
+			turnAdoptionLifecycle,
+			resolveChannelIngress
 		};
 		pendingInboundRegistry.cancelPendingOnAbort(entry, debouncer.cancelKey);
 		const inboundLane = resolveSignalControlLaneKey(deps.accountId, entry) ? controlDebouncer : debouncer;
@@ -1365,26 +1439,10 @@ function registerSignalReactionTargetsForDeliveredPayload(params) {
 }
 //#endregion
 //#region extensions/signal/src/signal-ingress.ts
-const SIGNAL_INGRESS_COMPLETED_TTL_MS = 720 * 60 * 60 * 1e3;
-const SIGNAL_INGRESS_COMPLETED_MAX_ENTRIES = 1e3;
-const SIGNAL_INGRESS_FAILED_TTL_MS = 720 * 60 * 60 * 1e3;
-const SIGNAL_INGRESS_FAILED_MAX_ENTRIES = 1e3;
 const SIGNAL_INGRESS_DRAIN_INTERVAL_MS = 1e3;
-var SignalIngressPermanentError = class extends Error {
-	constructor(reason, message, options) {
-		super(message, options);
-		this.reason = reason;
-		this.name = "SignalIngressPermanentError";
-	}
-};
-function isRecord$1(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function normalizeRawString(value) {
-	return typeof value === "string" && value.trim() ? value.trim() : null;
-}
+const SignalIngressPermanentError = createChannelIngressError("SignalIngressPermanentError", { withReason: true });
 function normalizeTimestamp(value) {
-	return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : null;
+	return asPositiveSafeInteger(value) ?? null;
 }
 function parseReceiveEnvelope(event) {
 	if (event.event !== "receive" || !event.data) return null;
@@ -1394,31 +1452,32 @@ function parseReceiveEnvelope(event) {
 	} 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;
+	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$1(envelope.dataMessage)) return envelope.dataMessage;
-	return isRecord$1(envelope.editMessage?.dataMessage) ? envelope.editMessage.dataMessage : null;
+	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$1(envelope.reactionMessage) ? envelope.reactionMessage : null;
+	const reactionMessage = isRecord(envelope.reactionMessage) ? envelope.reactionMessage : null;
 	if (!dataMessage && !reactionMessage) return null;
-	const senderUuid = normalizeRawString(envelope.sourceUuid);
-	const senderNumber = normalizeRawString(envelope.sourceNumber);
+	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 = normalizeRawString(dataGroup?.groupId) ?? normalizeRawString(reactionGroup?.groupId);
+	const dataGroup = isRecord(dataMessage?.groupInfo) ? dataMessage.groupInfo : null;
+	const reactionGroup = isRecord(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}`
+		laneKey: groupId ? `group:${groupId}` : `direct:${senderKey}`,
+		...senderUuid && senderNumber ? { numberAliasEventId: JSON.stringify([`number:${senderNumber}`, timestamp]) } : {}
 	};
 }
 function resolveSignalIngressNonRetryableFailure(error) {
@@ -1435,8 +1494,9 @@ async function startSignalIngressMonitor(params) {
 		if (!pluginRuntime) throw new Error("Signal runtime not initialized for durable ingress");
 		queue = pluginRuntime.state.openChannelIngressQueue({ accountId: params.accountId });
 	}
+	const ingressQueue = queue;
 	const monitor = createChannelIngressMonitor({
-		queue,
+		queue: ingressQueue,
 		inspect: (event) => inspectSignalIngressEvent(event),
 		payload: {
 			version: 1,
@@ -1456,13 +1516,16 @@ async function startSignalIngressMonitor(params) {
 			createClaimError: (_kind, claim) => new SignalIngressPermanentError("unsupported-event", `Signal ingress row ${claim.id} has an invalid payload`)
 		},
 		deliver: (event, lifecycle) => params.dispatch(event, lifecycle),
+		onDurableAdmission: async (_event, { facts }) => {
+			const { numberAliasEventId } = facts;
+			if (!numberAliasEventId) return;
+			if (!await ingressQueue.complete(numberAliasEventId)) await ingressQueue.complete(facts.eventId);
+		},
 		pollIntervalMs: SIGNAL_INGRESS_DRAIN_INTERVAL_MS,
 		retention: {
 			pruneIntervalMs: 0,
-			completedTtlMs: SIGNAL_INGRESS_COMPLETED_TTL_MS,
-			completedMaxEntries: SIGNAL_INGRESS_COMPLETED_MAX_ENTRIES,
-			failedTtlMs: SIGNAL_INGRESS_FAILED_TTL_MS,
-			failedMaxEntries: SIGNAL_INGRESS_FAILED_MAX_ENTRIES
+			completedMaxEntries: 2e3,
+			failedMaxEntries: 1e3
 		},
 		appendRetryDelaysMs: [0],
 		drain: {
@@ -1489,7 +1552,14 @@ const DEFAULT_RECONNECT_POLICY = {
 	factor: 2,
 	jitter: .2
 };
-async function runSignalSseLoop({ baseUrl, account, abortSignal, runtime, onEvent, timeoutMs, transportKind, policy }) {
+function publishSignalRecovering(statusSink, lastError) {
+	statusSink?.({
+		connected: false,
+		lifecycle: "recovering",
+		...lastError ? { lastError } : {}
+	});
+}
+async function runSignalSseLoop({ baseUrl, account, abortSignal, runtime, onEvent, timeoutMs, transportKind, policy, statusSink }) {
 	const reconnectPolicy = {
 		...DEFAULT_RECONNECT_POLICY,
 		...policy
@@ -1508,6 +1578,9 @@ async function runSignalSseLoop({ baseUrl, account, abortSignal, runtime, onEven
 				abortSignal,
 				timeoutMs,
 				transportKind,
+				onStreamOpen: () => {
+					statusSink?.(channelReadyPatch());
+				},
 				onEvent: async (event) => {
 					reconnectAttempts = 0;
 					await onEvent(event);
@@ -1518,6 +1591,7 @@ async function runSignalSseLoop({ baseUrl, account, abortSignal, runtime, onEven
 				}
 			});
 			if (abortSignal?.aborted) return;
+			publishSignalRecovering(statusSink);
 			reconnectAttempts += 1;
 			const delayMs = computeBackoff(reconnectPolicy, reconnectAttempts);
 			logReconnectVerbose(`Signal stream ended, reconnecting in ${delayMs / 1e3}s...`);
@@ -1525,6 +1599,7 @@ async function runSignalSseLoop({ baseUrl, account, abortSignal, runtime, onEven
 		} catch (err) {
 			if (abortSignal?.aborted) return;
 			runtime.error?.(`Signal stream error: ${String(err)}`);
+			publishSignalRecovering(statusSink, String(err));
 			reconnectAttempts += 1;
 			const delayMs = computeBackoff(reconnectPolicy, reconnectAttempts);
 			runtime.log?.(`Signal connection lost, reconnecting in ${delayMs / 1e3}s...`);
@@ -1558,36 +1633,6 @@ 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"));
-		daemonStopPromise = daemonHandle?.stop() ?? Promise.resolve();
-		return daemonStopPromise;
-	};
-	const attach = (handle) => {
-		daemonHandle = handle;
-		handle.exited.then((exit) => {
-			if (daemonStopRequested || params.abortSignal?.aborted) return;
-			daemonExitError = new Error(formatSignalDaemonExit(exit));
-			if (!daemonAbortController.signal.aborted) daemonAbortController.abort(daemonExitError);
-		});
-	};
-	const getExitError = () => daemonExitError;
-	return {
-		attach,
-		stop,
-		getExitError,
-		abortSignal
-	};
-}
 function resolveSignalReactionTargets(reaction) {
 	const targets = [];
 	const uuid = reaction.targetAuthorUuid?.trim();
@@ -1615,16 +1660,17 @@ function isSignalReactionMessage(reaction) {
 	return Boolean(emoji && typeof timestamp === "number" && timestamp > 0 && hasTarget);
 }
 function shouldEmitSignalReactionNotification(params) {
-	const { mode, account, targets, sender, allowlist } = params;
+	const { mode, account, accountUuid, targets, sender, allowlist } = params;
 	const effectiveMode = mode ?? "own";
 	if (effectiveMode === "off") return false;
 	if (effectiveMode === "own") {
-		const accountId = account?.trim();
-		if (!accountId || !targets || targets.length === 0) return false;
-		const normalizedAccount = normalizeE164(accountId);
+		const accountId = normalizeOptionalString(account);
+		const normalizedAccountUuid = normalizeOptionalString(accountUuid);
+		if (!accountId && !normalizedAccountUuid || !targets || targets.length === 0) return false;
+		const normalizedAccount = accountId ? normalizeE164(accountId) : void 0;
 		return targets.some((target) => {
-			if (target.kind === "uuid") return accountId === target.id || accountId === `uuid:${target.id}`;
-			return normalizedAccount === target.id;
+			if (target.kind === "uuid") return [accountId, normalizedAccountUuid].some((candidate) => candidate === target.id || candidate === `uuid:${target.id}`);
+			return Boolean(normalizedAccount) && normalizedAccount === target.id;
 		});
 	}
 	if (effectiveMode === "allowlist") {
@@ -1680,7 +1726,9 @@ async function fetchAttachment(params) {
 	});
 	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 buffer = Buffer.from(result.data, "base64");
+	const canonicalData = canonicalizeBase64(result.data);
+	if (!canonicalData) throw new Error(`Signal attachment ${attachment.id} returned malformed base64 data`);
+	const buffer = Buffer.from(canonicalData, "base64");
 	const originalFilename = normalizeOptionalString(attachment.filename ?? void 0);
 	const saved = await saveMediaBuffer(buffer, normalizeOptionalString(attachment.contentType ?? void 0) ?? await detectMime({
 		buffer,
@@ -1903,6 +1951,7 @@ async function monitorSignalProvider(opts = {}) {
 		});
 		const handleEvent = createSignalEventHandler({
 			runtime,
+			channelRuntime: opts.channelRuntime,
 			abortSignal: daemonLifecycle.abortSignal,
 			runTrackedTask: (task) => {
 				monitorTaskRunner.runTask(task);
@@ -1953,6 +2002,7 @@ async function monitorSignalProvider(opts = {}) {
 			timeoutMs: 0,
 			transportKind,
 			policy: opts.reconnectPolicy,
+			statusSink: opts.statusSink,
 			onEvent: (event) => monitorTaskRunner.runTask(async () => await ingressMonitor?.receive(event))
 		});
 		const daemonExitError = daemonLifecycle.getExitError();
@@ -1960,6 +2010,7 @@ async function monitorSignalProvider(opts = {}) {
 	} catch (err) {
 		const daemonExitError = daemonLifecycle.getExitError();
 		if (opts.abortSignal?.aborted && !daemonExitError) return;
+		if (daemonExitError) publishSignalRecovering(opts.statusSink, daemonExitError.message);
 		throw err;
 	} finally {
 		await ingressMonitor?.stop();

package/dist/{probe-Br9abaGp.js → probe-C_THuQzn.js}

@@ -1,19 +1,26 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { t as detectSignalTransport } from "./transport-detection-Da06-LOL.js";
-import { n as signalRpcRequest, t as signalCheck } from "./client-adapter-mXGeEHQJ.js";
+import { t as detectSignalTransport } from "./transport-detection-BItHawMq.js";
+import { n as signalRpcRequest, t as signalCheck } from "./client-adapter-D9SNPaNx.js";
 import { runChannelProbe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 //#region extensions/signal/src/probe.ts
-var probe_exports = /* @__PURE__ */ __exportAll({ probeSignal: () => probeSignal });
+var probe_exports = /* @__PURE__ */ __exportAll({
+	probeSignal: () => probeSignal,
+	probeSignalAccount: () => probeSignalAccount
+});
 function parseSignalVersion(value) {
 	if (typeof value === "string" && value.trim()) return value.trim();
 	if (typeof value === "object" && value !== null) {
-		const version = value.version;
+		const { version, versions } = value;
 		if (typeof version === "string" && version.trim()) return version.trim();
+		if (Array.isArray(versions)) {
+			const normalizedVersions = versions.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter(Boolean);
+			if (normalizedVersions.length > 0) return normalizedVersions.join(", ");
+		}
 	}
 	return null;
 }
-async function probeSignal(baseUrl, timeoutMs, options = {}) {
+async function probeSignalTransport(baseUrl, timeoutMs, options, account) {
 	return await runChannelProbe(void 0, async () => {
 		const result = {
 			ok: false,
@@ -30,7 +37,10 @@ async function probeSignal(baseUrl, timeoutMs, options = {}) {
 				error: formatErrorMessage(error)
 			};
 		}
-		const check = await signalCheck(baseUrl, timeoutMs, { transportKind });
+		const check = await signalCheck(baseUrl, timeoutMs, {
+			transportKind,
+			...account && transportKind === "container" ? { account } : {}
+		});
 		if (!check.ok) return {
 			...result,
 			status: check.status ?? null,
@@ -47,11 +57,17 @@ async function probeSignal(baseUrl, timeoutMs, options = {}) {
 		}
 		return {
 			...result,
-			ok: true,
+			ok: result.error === null,
 			status: check.status ?? null
 		};
 	});
 }
+async function probeSignal(baseUrl, timeoutMs, options = {}) {
+	return await probeSignalTransport(baseUrl, timeoutMs, options);
+}
+async function probeSignalAccount(params) {
+	return await probeSignalTransport(params.baseUrl, params.timeoutMs, { transportKind: params.transportKind }, params.account);
+}
 async function resolveProbeTransportKind(baseUrl, timeoutMs, options) {
 	if (options.transportKind) return options.transportKind;
 	if (options.apiMode === "container") return "container";