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

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

@@ -2,25 +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 { 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 { canonicalizeBase64, 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 { 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, toInboundMediaFactsWithMetadata } 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 { isRecord as isRecord$1 } from "openclaw/plugin-sdk/channel-secret-basic-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";
@@ -45,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) {
@@ -72,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) {
@@ -180,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";
@@ -274,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,
@@ -606,7 +638,7 @@ function createSignalEventHandler(deps) {
 		});
 		const replyThreading = resolveBatchedReplyThreadingPolicy(replyToMode, entry.isBatched === true);
 		const media = await toInboundMediaFactsWithMetadata(entry.media);
-		const ctxPayload = buildChannelInboundEventContext({
+		const ctxPayload = (deps.channelRuntime?.inbound.buildContext ?? buildChannelInboundEventContext)({
 			channel: "signal",
 			supplemental: { quote: entry.replyToBody ? {
 				body: entry.replyToBody,
@@ -650,6 +682,7 @@ function createSignalEventHandler(deps) {
 				} } : {},
 				commands: { authorized: entry.commandAuthorized }
 			},
+			channelIngress: entry.channelIngress,
 			media,
 			extra: {
 				GroupSubject: entry.isGroup ? entry.groupName ?? void 0 : void 0,
@@ -838,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
@@ -854,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)}`);
 					});
@@ -867,9 +904,16 @@ function createSignalEventHandler(deps) {
 	async function flushSignalInboundEntries(entries, lifecycle, settle) {
 		const last = entries.at(-1);
 		if (!last) return;
+		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({
 				...last,
+				channelIngress,
 				turnAdoptionLifecycle: lifecycle
 			});
 			await settle();
@@ -888,10 +932,30 @@ function createSignalEventHandler(deps) {
 			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 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()) {
@@ -1017,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
@@ -1077,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,
@@ -1087,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,
@@ -1218,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({
@@ -1349,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;
@@ -1374,7 +1442,7 @@ function registerSignalReactionTargetsForDeliveredPayload(params) {
 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;
+	return asPositiveSafeInteger(value) ?? null;
 }
 function parseReceiveEnvelope(event) {
 	if (event.event !== "receive" || !event.data) return null;
@@ -1384,18 +1452,18 @@ 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 = normalizeNullableString(envelope.sourceUuid);
 	const senderNumber = normalizeNullableString(envelope.sourceNumber);
@@ -1403,12 +1471,13 @@ function inspectSignalIngressEvent(event) {
 	if (!senderKey) throw new SignalIngressPermanentError("missing-sender", "Signal dispatchable envelope is missing sourceUuid/sourceNumber");
 	const timestamp = normalizeTimestamp(envelope.timestamp) ?? normalizeTimestamp(dataMessage?.timestamp);
 	if (timestamp === null) throw new SignalIngressPermanentError("missing-timestamp", "Signal dispatchable envelope is missing a stable timestamp");
-	const dataGroup = isRecord$1(dataMessage?.groupInfo) ? dataMessage.groupInfo : null;
-	const reactionGroup = isRecord$1(reactionMessage?.groupInfo) ? reactionMessage.groupInfo : null;
+	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) {
@@ -1425,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,
@@ -1446,10 +1516,15 @@ 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,
-			completedMaxEntries: 1e3,
+			completedMaxEntries: 2e3,
 			failedMaxEntries: 1e3
 		},
 		appendRetryDelaysMs: [0],
@@ -1477,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
@@ -1496,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);
@@ -1506,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...`);
@@ -1513,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...`);
@@ -1546,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();
@@ -1603,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") {
@@ -1893,6 +1951,7 @@ async function monitorSignalProvider(opts = {}) {
 		});
 		const handleEvent = createSignalEventHandler({
 			runtime,
+			channelRuntime: opts.channelRuntime,
 			abortSignal: daemonLifecycle.abortSignal,
 			runTrackedTask: (task) => {
 				monitorTaskRunner.runTask(task);
@@ -1943,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();
@@ -1950,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";

package/dist/question-reactions-ByjH5qST.js

@@ -0,0 +1,80 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { o as resolveSignalTarget } from "./runtime-JPrGlV7h.js";
+import { l as resolveSignalApprovalConversationKey, u as resolveSignalApprovalTargetAuthorKeys } from "./approval-reactions-BulCzhdB.js";
+import { createQuestionReactionTargetStore, questionGatewayRuntime } from "openclaw/plugin-sdk/question-gateway-runtime";
+import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
+//#region extensions/signal/src/question-reactions.ts
+var question_reactions_exports = /* @__PURE__ */ __exportAll({
+	maybeResolveSignalQuestionReaction: () => maybeResolveSignalQuestionReaction,
+	registerSignalQuestionReactionTargetForDeliveredPayload: () => registerSignalQuestionReactionTargetForDeliveredPayload
+});
+function buildKey(identity) {
+	const values = [
+		identity.accountId,
+		identity.conversationKey,
+		identity.messageId
+	].map((value) => value.trim());
+	return values.every(Boolean) ? values.join(":") : null;
+}
+const questionReactionTargets = createQuestionReactionTargetStore({
+	channel: "signal",
+	channelDisplayName: "Signal",
+	buildKey,
+	identityMatches: (stored, incoming) => Boolean(stored && incoming?.some((authorKey) => stored.includes(authorKey))),
+	registerChannelDelivery: questionGatewayRuntime.registerChannelDelivery,
+	resolveReaction: questionGatewayRuntime.resolveReaction
+});
+function resolveConversationKey(params) {
+	try {
+		return resolveSignalTarget({
+			cfg: params.cfg,
+			accountId: params.accountId,
+			input: params.to
+		})?.to ?? resolveSignalApprovalConversationKey(params.to);
+	} catch {
+		return resolveSignalApprovalConversationKey(params.to);
+	}
+}
+function registerSignalQuestionReactionTargetForDeliveredPayload(params) {
+	const binding = questionGatewayRuntime.readReactionBinding(params.payload);
+	if (params.target.channel !== "signal" || !binding) return false;
+	const conversationKey = resolveConversationKey({
+		cfg: params.cfg,
+		...params.target
+	});
+	const targetAuthorKeys = resolveSignalApprovalTargetAuthorKeys(params);
+	if (!conversationKey || targetAuthorKeys.length === 0) return false;
+	const accountId = normalizeAccountId(params.target.accountId ?? void 0);
+	let registered = false;
+	for (const result of params.results) {
+		const messageId = result.channel === "signal" ? result.messageId.trim() : "";
+		if (!messageId || messageId === "unknown") continue;
+		registered = questionReactionTargets.register(binding, {
+			accountId,
+			conversationKey,
+			messageId
+		}, targetAuthorKeys) || registered;
+	}
+	return registered;
+}
+async function maybeResolveSignalQuestionReaction(params) {
+	if (params.isRemove) return false;
+	const optionIndex = questionGatewayRuntime.resolveReactionIndex(params.reactionKey);
+	if (optionIndex === void 0) return false;
+	const authorKeys = resolveSignalApprovalTargetAuthorKeys(params);
+	return await questionReactionTargets.resolve({
+		identities: [{
+			accountId: params.accountId,
+			conversationKey: params.conversationKey,
+			messageId: params.messageId
+		}],
+		optionIndex,
+		cfg: params.cfg,
+		senderId: params.actorId,
+		gatewayUrl: params.gatewayUrl,
+		metadata: authorKeys,
+		logDebug: params.logDebug
+	});
+}
+//#endregion
+export { question_reactions_exports as n, registerSignalQuestionReactionTargetForDeliveredPayload as r, maybeResolveSignalQuestionReaction as t };

package/dist/{reaction-runtime-api-BjeDyKcz.js → reaction-runtime-api-Cf6QHcE5.js}

@@ -1,5 +1,5 @@
 import { i as resolveSignalAccount } from "./accounts-DrStJjiK.js";
-import { n as signalRpcRequest } from "./client-adapter-mXGeEHQJ.js";
+import { n as signalRpcRequest } from "./client-adapter-D9SNPaNx.js";
 import { t as resolveSignalRpcContext } from "./rpc-context-CZUoE0-A.js";
 import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
@@ -37,16 +37,17 @@ async function sendReactionSignalCore(params) {
 	const { baseUrl, account } = resolveSignalRpcContext(params.opts, accountInfo);
 	const normalizedRecipient = normalizeSignalUuid(params.recipient);
 	const groupId = params.opts.groupId?.trim();
-	if (!normalizedRecipient && !groupId) throw new Error(params.errors.missingRecipient);
-	if (!Number.isFinite(params.targetTimestamp) || params.targetTimestamp <= 0) throw new Error(params.errors.invalidTargetTimestamp);
+	const operation = `Signal reaction${params.remove ? " removal" : ""}`;
+	if (!normalizedRecipient && !groupId) throw new Error(`Recipient or groupId is required for ${operation}`);
+	if (!Number.isFinite(params.targetTimestamp) || params.targetTimestamp <= 0) throw new Error(`Valid targetTimestamp is required for ${operation}`);
 	const normalizedEmoji = params.emoji?.trim();
-	if (!normalizedEmoji) throw new Error(params.errors.missingEmoji);
+	if (!normalizedEmoji) throw new Error(`Emoji is required for ${operation}`);
 	const targetAuthorParams = resolveTargetAuthorParams({
 		targetAuthor: params.opts.targetAuthor,
 		targetAuthorUuid: params.opts.targetAuthorUuid,
 		fallback: normalizedRecipient
 	});
-	if (groupId && !targetAuthorParams.targetAuthor) throw new Error(params.errors.missingTargetAuthor);
+	if (groupId && !targetAuthorParams.targetAuthor) throw new Error(`targetAuthor is required for group reaction${params.remove ? " removal" : "s"}`);
 	const requestParams = {
 		emoji: normalizedEmoji,
 		targetTimestamp: params.targetTimestamp,
@@ -78,13 +79,7 @@ async function sendReactionSignal(recipient, targetTimestamp, emoji, opts) {
 		targetTimestamp,
 		emoji,
 		remove: false,
-		opts,
-		errors: {
-			missingRecipient: "Recipient or groupId is required for Signal reaction",
-			invalidTargetTimestamp: "Valid targetTimestamp is required for Signal reaction",
-			missingEmoji: "Emoji is required for Signal reaction",
-			missingTargetAuthor: "targetAuthor is required for group reactions"
-		}
+		opts
 	});
 }
 /**
@@ -100,13 +95,7 @@ async function removeReactionSignal(recipient, targetTimestamp, emoji, opts) {
 		targetTimestamp,
 		emoji,
 		remove: true,
-		opts,
-		errors: {
-			missingRecipient: "Recipient or groupId is required for Signal reaction removal",
-			invalidTargetTimestamp: "Valid targetTimestamp is required for Signal reaction removal",
-			missingEmoji: "Emoji is required for Signal reaction removal",
-			missingTargetAuthor: "targetAuthor is required for group reaction removal"
-		}
+		opts
 	});
 }
 //#endregion

package/dist/reaction-runtime-api.js

@@ -1,2 +1,2 @@
-import { n as sendReactionSignal, t as removeReactionSignal } from "./reaction-runtime-api-BjeDyKcz.js";
+import { n as sendReactionSignal, t as removeReactionSignal } from "./reaction-runtime-api-Cf6QHcE5.js";
 export { removeReactionSignal, sendReactionSignal };