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

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

@@ -1,26 +1,25 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { i as resolveSignalAccount, o as resolveSignalReplyToMode } from "./accounts-DrStJjiK.js";
+import { l as normalizeSignalTransportHost } from "./transport-policy-DxvSMHp9.js";
+import { i as resolveSignalAccount, o as resolveSignalReplyToMode } from "./accounts-DO4HMqaK.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 { c as resolveSignalReactionLevel, f as isSignalNativeApprovalHandlerConfigured, i as getOptionalSignalRuntime, l as formatSignalMediaText, n as registerSignalReplyContext, o as materializeSignalPresentationFallback } from "./transport-detection-D_M79R5f.js";
+import { n as signalRpcRequest, r as streamSignalEvents, t as signalCheck } from "./client-adapter-D9SNPaNx.js";
+import { n as sendReactionSignal } from "./reaction-runtime-api-YGD6hhDh.js";
+import { i as maybeResolveSignalApprovalReaction, o as registerSignalApprovalReactionTargetForDeliveredPayload, s as resolveSignalApprovalConversationKey, t as addSignalApprovalReactionHintToStructuredPayload } from "./approval-reactions-cs3Ox9Ow.js";
+import { r as registerSignalQuestionReactionTargetForDeliveredPayload, t as maybeResolveSignalQuestionReaction } from "./question-reactions-BaatFqJ7.js";
+import { n as sendReadReceiptSignal, r as sendTypingSignal, t as sendMessageSignal } from "./send-BNl5folj.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 { ensurePortAvailable, extractErrorCode, formatErrorMessage as formatErrorMessage$1, 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";
@@ -45,11 +44,53 @@ 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) {
 	return `signal daemon exited (source=${exit.source} code=${exit.code ?? "null"} signal=${exit.signal ?? "null"})`;
 }
+function formatSignalDaemonEndpoint(httpHost, httpPort) {
+	return `${httpHost.includes(":") ? `[${httpHost}]` : httpHost}:${httpPort}`;
+}
+async function assertSignalDaemonEndpointAvailable(params) {
+	try {
+		await ensurePortAvailable(params.httpPort, params.httpHost, params.abortSignal);
+	} catch (error) {
+		if (params.abortSignal?.aborted) throw params.abortSignal.reason;
+		if (!(extractErrorCode(error) === "EADDRINUSE" || error instanceof Error && error.name === "PortInUseError")) return;
+		const endpoint = formatSignalDaemonEndpoint(params.httpHost, params.httpPort);
+		throw new Error(`Signal managed native endpoint ${endpoint} is unavailable: ${formatErrorMessage$1(error)} Stop the conflicting service, configure this Signal account with a different transport.httpPort, or use external-native for an intentionally operator-managed daemon.`, { cause: error });
+	}
+}
+async function waitForSignalDaemonReady(params) {
+	await (params.waitForTransportReadyFn ?? waitForTransportReady)({
+		label: "signal daemon",
+		timeoutMs: Math.max(0, params.startupDeadlineMs - Date.now()),
+		logAfterMs: params.logAfterMs,
+		logIntervalMs: params.logIntervalMs,
+		pollIntervalMs: 150,
+		abortSignal: params.abortSignal,
+		runtime: params.runtime,
+		check: async () => {
+			const remainingMs = params.startupDeadlineMs - Date.now();
+			if (remainingMs <= 0) return {
+				ok: false,
+				error: "startup deadline exceeded"
+			};
+			const res = await signalCheck(params.baseUrl, Math.min(1e3, remainingMs));
+			if (Date.now() >= params.startupDeadlineMs) return {
+				ok: false,
+				error: "startup deadline exceeded"
+			};
+			if (res.ok) return { ok: true };
+			return {
+				ok: false,
+				error: res.error ?? (res.status ? `HTTP ${res.status}` : "unreachable")
+			};
+		}
+	});
+}
 function isRecoverableSignalCliReceiveException(line) {
 	return /\breceive exception:\s+.*\binvalid PreKey message:\s+decryption failed\b/i.test(line);
 }
@@ -72,7 +113,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 +221,99 @@ 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/native-reply.ts
+function resolveSignalNativeReplyId(params) {
+	if (params.payload.replyToCurrent === false) return;
+	const payloadReplyToId = normalizeOptionalString(params.payload.replyToId);
+	const isExplicitCurrentReply = params.payload.replyToTag === true || params.payload.replyToCurrent === true;
+	if (!payloadReplyToId && !isExplicitCurrentReply && params.replyContext?.allowImplicitCurrentMessage === false) return;
+	const contextReplyToId = normalizeOptionalString(params.replyContext?.replyToId);
+	if (!contextReplyToId || payloadReplyToId && payloadReplyToId !== contextReplyToId) return;
+	return payloadReplyToId ?? contextReplyToId;
+}
+function isSignalStatusNoticePayload(payload) {
+	return Boolean(payload.isCompactionNotice || payload.isFallbackNotice || payload.isStatusNotice);
+}
+function createSignalNativeReplyIdPlan(params) {
+	const replyToId = resolveSignalNativeReplyId(params);
+	if (!replyToId) return {
+		peek: () => void 0,
+		use: () => void 0,
+		markSent: () => void 0
+	};
+	const isExplicitReply = params.payload.replyToTag === true || params.payload.replyToCurrent === true;
+	if (isSignalStatusNoticePayload(params.payload)) {
+		const resolve = params.replyToMode === "off" ? () => void 0 : () => replyToId;
+		return {
+			peek: resolve,
+			use: resolve,
+			markSent: () => void 0
+		};
+	}
+	if (isExplicitReply) {
+		const resolve = () => replyToId;
+		return {
+			peek: resolve,
+			use: resolve,
+			markSent: () => void 0
+		};
+	}
+	const planner = createReplyReferencePlanner({
+		replyToMode: params.replyToMode,
+		existingId: replyToId,
+		hasReplied: params.replyContext?.state?.hasReplied
+	});
+	const syncState = () => {
+		if (params.replyContext?.state) params.replyContext.state.hasReplied = planner.hasReplied();
+	};
+	return {
+		peek: () => planner.peek(),
+		use: () => {
+			const nextReplyToId = planner.use();
+			syncState();
+			return nextReplyToId;
+		},
+		markSent: () => {
+			planner.markSent();
+			syncState();
+		}
+	};
+}
+function createSignalNativeReplyIdResolver(params) {
+	return createSignalNativeReplyIdPlan(params).use;
+}
+//#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 +408,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,
@@ -524,8 +659,7 @@ function resolveSignalStatusReactionTimestamp(params) {
 	return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
 }
 function hasSignalStatusReplyDeliveryFailure(result) {
-	const failedCounts = result.failedCounts;
-	return (failedCounts?.tool ?? 0) > 0 || (failedCounts?.block ?? 0) > 0 || (failedCounts?.final ?? 0) > 0;
+	return Object.values(result.settledReceipt?.counts ?? {}).some((counts) => counts.failedBeforeSend > 0 || counts.failedAfterSend > 0);
 }
 function resolveSignalStatusReactionEmojis(emojis) {
 	if (emojis?.stallHard !== void 0) return emojis;
@@ -606,7 +740,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 +784,7 @@ function createSignalEventHandler(deps) {
 				} } : {},
 				commands: { authorized: entry.commandAuthorized }
 			},
+			channelIngress: entry.channelIngress,
 			media,
 			extra: {
 				GroupSubject: entry.isGroup ? entry.groupName ?? void 0 : void 0,
@@ -742,6 +877,7 @@ function createSignalEventHandler(deps) {
 		};
 		const dispatcherOptions = {
 			...replyPipeline,
+			propagateRetryableNoSendFailure: true,
 			humanDelay: resolveHumanDelayConfig(deps.cfg, route.agentId),
 			typingCallbacks
 		};
@@ -762,6 +898,32 @@ function createSignalEventHandler(deps) {
 					chatType: entry.isGroup ? "group" : "direct"
 				});
 			},
+			durable: (payload, info) => {
+				if (info.kind !== "final") return false;
+				const replyPlan = createSignalNativeReplyIdPlan({
+					payload,
+					replyContext: nativeReplyContext,
+					replyToMode
+				});
+				const send = async (to, text, options) => {
+					entry.turnAdoptionLifecycle?.abortSignal.throwIfAborted();
+					deps.abortSignal?.throwIfAborted();
+					const result = await sendMessageSignal(to, text, {
+						...options,
+						baseUrl: deps.baseUrl,
+						account: deps.account,
+						maxBytes: deps.mediaMaxBytes,
+						accountId: deps.accountId
+					});
+					replyPlan.markSent();
+					return result;
+				};
+				return {
+					deps: { signal: send },
+					replyToId: replyPlan.peek() ?? null,
+					replyToMode
+				};
+			},
 			onError: (err, info) => {
 				deps.runtime.error?.(danger(`signal ${info.kind} reply failed: ${String(err)}`));
 			}
@@ -790,6 +952,7 @@ function createSignalEventHandler(deps) {
 						sessionKey: route.sessionKey
 					},
 					ctxPayload,
+					dispatchReplyFromConfig: deps.channelRuntime?.reply?.dispatchReplyFromConfig,
 					record: {
 						updateLastRoute: !entry.isGroup ? {
 							sessionKey: inboundLastRouteSessionKey,
@@ -838,13 +1001,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 +1020,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 +1034,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 +1062,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()) {
@@ -930,7 +1124,7 @@ function createSignalEventHandler(deps) {
 					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())));
+						await lifecycle?.onAbandoned();
 						throw terminalError;
 					});
 				}
@@ -1017,6 +1211,7 @@ function createSignalEventHandler(deps) {
 		if (!deps.shouldEmitSignalReactionNotification({
 			mode: deps.reactionMode,
 			account: deps.account,
+			accountUuid: deps.accountUuid,
 			targets,
 			sender: params.sender,
 			allowlist: deps.reactionAllowlist
@@ -1052,10 +1247,10 @@ function createSignalEventHandler(deps) {
 		});
 		return true;
 	}
-	return async (event, turnAdoptionLifecycle) => {
+	return async (event, turnAdoptionLifecycle, preparedPayload) => {
 		if (event.event !== "receive" || !event.data) return;
-		let payload;
-		try {
+		let payload = preparedPayload ?? null;
+		if (!preparedPayload) try {
 			payload = JSON.parse(event.data);
 		} catch (err) {
 			deps.runtime.error?.(`failed to parse event: ${String(err)}`);
@@ -1077,7 +1272,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 +1282,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 +1415,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 +1546,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,9 +1572,9 @@ 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) {
+function parseReceivePayload(event) {
 	if (event.event !== "receive" || !event.data) return null;
 	let parsed;
 	try {
@@ -1384,18 +1582,19 @@ 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 parsed;
 }
 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);
+function inspectSignalIngressEvent(prepared) {
+	const payload = prepared[1] ??= parseReceivePayload(prepared[0]);
+	const envelope = isRecord(payload?.envelope) ? payload.envelope : null;
 	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 +1602,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,16 +1625,17 @@ 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,
-		inspect: (event) => inspectSignalIngressEvent(event),
+		queue: ingressQueue,
+		inspect: (prepared) => inspectSignalIngressEvent(prepared),
 		payload: {
 			version: 1,
-			serialize: (event, { receivedAt }) => ({
+			serialize: ([event], { receivedAt }) => ({
 				receivedAt,
 				event
 			}),
-			deserialize: (body) => body.event,
+			deserialize: (body) => [body.event, void 0],
 			encode: ({ body }) => ({
 				version: 1,
 				...body
@@ -1445,11 +1646,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),
+		deliver: ([event, parsedPayload], lifecycle) => parsedPayload ? params.dispatch(event, lifecycle, parsedPayload) : void 0,
+		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],
@@ -1462,7 +1668,7 @@ async function startSignalIngressMonitor(params) {
 	monitor.start();
 	return {
 		receive: async (event) => {
-			await monitor.admit(event);
+			await monitor.admit([event, void 0]);
 			await monitor.waitForPumpIdle();
 		},
 		stop: monitor.stop,
@@ -1477,7 +1683,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 +1709,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 +1722,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 +1730,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 +1764,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 +1791,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") {
@@ -1626,25 +1815,6 @@ function buildSignalReactionSystemEventText(params) {
 	const withTarget = params.targetLabel ? `${base} from ${params.targetLabel}` : base;
 	return params.groupLabel ? `${withTarget} in ${params.groupLabel}` : withTarget;
 }
-async function waitForSignalDaemonReady(params) {
-	await (params.waitForTransportReadyFn ?? waitForTransportReady)({
-		label: "signal daemon",
-		timeoutMs: params.timeoutMs,
-		logAfterMs: params.logAfterMs,
-		logIntervalMs: params.logIntervalMs,
-		pollIntervalMs: 150,
-		abortSignal: params.abortSignal,
-		runtime: params.runtime,
-		check: async () => {
-			const res = await signalCheck(params.baseUrl, 1e3);
-			if (res.ok) return { ok: true };
-			return {
-				ok: false,
-				error: res.error ?? (res.status ? `HTTP ${res.status}` : "unreachable")
-			};
-		}
-	});
-}
 const SIGNAL_ATTACHMENT_RPC_RESPONSE_HEADROOM_BYTES = 64 * 1024;
 const SIGNAL_BASE64_OVERHEAD_NUMERATOR = 4;
 const SIGNAL_BASE64_OVERHEAD_DENOMINATOR = 3;
@@ -1756,45 +1926,19 @@ async function deliverReplies(params) {
 		}
 	}
 }
-function resolveSignalNativeReplyOptions(params) {
-	if (params.payload.replyToCurrent === false) return {};
-	const payloadReplyToId = normalizeOptionalString(params.payload.replyToId);
-	const isExplicitCurrentReply = params.payload.replyToTag === true || params.payload.replyToCurrent === true;
-	if (!payloadReplyToId && !isExplicitCurrentReply && params.replyContext?.allowImplicitCurrentMessage === false) return {};
-	const contextReplyToId = normalizeOptionalString(params.replyContext?.replyToId);
-	if (!contextReplyToId || payloadReplyToId && payloadReplyToId !== contextReplyToId) return {};
-	const replyToId = payloadReplyToId ?? contextReplyToId;
-	const replyToAuthor = normalizeOptionalString(params.replyContext?.author);
-	if (!replyToAuthor) return { replyToId };
-	return {
-		replyToId,
-		replyToAuthor,
-		replyToBody: params.replyContext?.body ?? ""
-	};
-}
-function isSignalStatusNoticePayload(payload) {
-	return Boolean(payload.isCompactionNotice || payload.isFallbackNotice || payload.isStatusNotice);
-}
 function createSignalNativeReplyResolver(params) {
-	const nativeReply = resolveSignalNativeReplyOptions(params);
-	if (!nativeReply.replyToId) return () => ({});
-	const isExplicitReply = params.payload.replyToTag === true || params.payload.replyToCurrent === true;
-	const isStatusNotice = isSignalStatusNoticePayload(params.payload);
-	if (isStatusNotice && params.replyToMode === "off") return () => ({});
-	if (isExplicitReply) return () => nativeReply;
-	if (isStatusNotice) return () => nativeReply;
-	const planner = createReplyReferencePlanner({
-		replyToMode: params.replyToMode,
-		existingId: nativeReply.replyToId,
-		hasReplied: params.replyContext?.state?.hasReplied
-	});
+	const nextReplyToId = createSignalNativeReplyIdResolver(params);
 	return () => {
-		const replyToId = planner.use();
-		if (params.replyContext?.state && !isStatusNotice) params.replyContext.state.hasReplied = planner.hasReplied();
-		return replyToId ? {
-			...nativeReply,
-			replyToId
-		} : {};
+		const replyToId = nextReplyToId();
+		if (!replyToId) return {};
+		const replyToAuthor = normalizeOptionalString(params.replyContext?.author);
+		return {
+			replyToId,
+			...replyToAuthor ? {
+				replyToAuthor,
+				replyToBody: params.replyContext?.body ?? ""
+			} : {}
+		};
 	};
 }
 async function monitorSignalProvider(opts = {}) {
@@ -1840,11 +1984,27 @@ async function monitorSignalProvider(opts = {}) {
 	const monitorTaskRunner = createSignalMonitorTaskRunner(runtime);
 	let daemonHandle = null;
 	let ingressMonitor;
+	const startupDeadline = Date.now() + startupTimeoutMs;
 	if (autoStart) {
 		const cliPath = opts.cliPath ?? managedTransport?.cliPath ?? "signal-cli";
 		const configPath = normalizeOptionalString(opts.configPath) ?? normalizeOptionalString(managedTransport?.configPath);
-		const httpHost = opts.httpHost ?? managedTransport?.httpHost ?? "127.0.0.1";
+		const httpHost = normalizeSignalTransportHost(opts.httpHost ?? managedTransport?.httpHost ?? "127.0.0.1");
 		const httpPort = opts.httpPort ?? managedTransport?.httpPort ?? 8080;
+		const startupTimeoutSignal = AbortSignal.timeout(startupTimeoutMs);
+		const endpointProbeSignal = opts.abortSignal ? AbortSignal.any([opts.abortSignal, startupTimeoutSignal]) : startupTimeoutSignal;
+		try {
+			await assertSignalDaemonEndpointAvailable({
+				httpHost,
+				httpPort,
+				abortSignal: endpointProbeSignal
+			});
+		} catch (error) {
+			if (opts.abortSignal?.aborted) return;
+			if (startupTimeoutSignal.aborted || Date.now() >= startupDeadline) throw new Error(`signal daemon startup timed out after ${startupTimeoutMs}ms while checking its endpoint`, { cause: error });
+			throw error;
+		}
+		if (opts.abortSignal?.aborted) return;
+		if (Date.now() >= startupDeadline) throw new Error(`signal daemon startup timed out after ${startupTimeoutMs}ms before starting`);
 		daemonHandle = spawnSignalDaemon({
 			cliPath,
 			...configPath ? { configPath } : {},
@@ -1866,7 +2026,7 @@ async function monitorSignalProvider(opts = {}) {
 			await waitForSignalDaemonReady({
 				baseUrl,
 				abortSignal: daemonLifecycle.abortSignal,
-				timeoutMs: startupTimeoutMs,
+				startupDeadlineMs: startupDeadline,
 				logAfterMs: 1e4,
 				logIntervalMs: 1e4,
 				runtime,
@@ -1893,6 +2053,7 @@ async function monitorSignalProvider(opts = {}) {
 		});
 		const handleEvent = createSignalEventHandler({
 			runtime,
+			channelRuntime: opts.channelRuntime,
 			abortSignal: daemonLifecycle.abortSignal,
 			runTrackedTask: (task) => {
 				monitorTaskRunner.runTask(task);
@@ -1943,6 +2104,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 +2112,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();