@openclaw/signal 2026.7.1-beta.6 → 2026.7.2-beta.1

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

@@ -1,12 +1,12 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
 import { a as resolveSignalReplyToMode, i as resolveSignalAccount } from "./accounts-Bz4HtP0g.js";
-import { a as normalizeSignalAllowRecipient, c as resolveSignalSender, d as normalizeSignalMessagingTarget, i as isSignalSenderAllowed, l as looksLikeUuid, n as formatSignalSenderDisplay, o as resolveSignalPeerId, r as formatSignalSenderId, s as resolveSignalRecipient, t as formatSignalPairingIdLine } from "./identity-C8-yk4J9.js";
-import { a as isSignalNativeApprovalHandlerConfigured, n as resolveSignalReactionLevel } from "./message-actions-3OLDgjis.js";
-import { n as signalRpcRequest, r as streamSignalEvents, t as signalCheck } from "./client-adapter-C9mB2Jz8.js";
-import { n as sendReactionSignal, t as removeReactionSignal } from "./reaction-runtime-api-EQ7cc7-Y.js";
-import { a as maybeResolveSignalApprovalReaction, l as resolveSignalApprovalConversationKey, s as registerSignalApprovalReactionTargetForDeliveredPayload, t as addSignalApprovalReactionHintToStructuredPayload } from "./approval-reactions-UFmUPD0A.js";
-import { n as sendReadReceiptSignal, r as sendTypingSignal, t as sendMessageSignal } from "./send-CUJy6WPt.js";
-import { createChannelMessageReplyPipeline } from "openclaw/plugin-sdk/channel-outbound";
+import { a as normalizeSignalAllowRecipient, c as resolveSignalSender, d as normalizeSignalMessagingTarget, i as isSignalSenderAllowed, l as looksLikeUuid, n as formatSignalSenderDisplay, o as resolveSignalPeerId, r as formatSignalSenderId, s as resolveSignalRecipient, t as formatSignalPairingIdLine } from "./identity-BF8taj7g.js";
+import { a as resolveSignalReactionLevel, c as isSignalNativeApprovalHandlerConfigured, r as materializeSignalPresentationFallback, t as registerSignalReplyContext } from "./reply-authors-osU_SY4J.js";
+import { n as signalRpcRequest, r as streamSignalEvents, t as signalCheck } from "./client-adapter-aEM0kGhC.js";
+import { n as sendReactionSignal, t as removeReactionSignal } from "./reaction-runtime-api-DifyinAU.js";
+import { a as maybeResolveSignalApprovalReaction, l as resolveSignalApprovalConversationKey, s as registerSignalApprovalReactionTargetForDeliveredPayload, t as addSignalApprovalReactionHintToStructuredPayload } from "./approval-reactions-ChcS2rQN.js";
+import { n as sendReadReceiptSignal, r as sendTypingSignal, t as sendMessageSignal } from "./send-BWtA6h3J.js";
+import { createChannelMessageReplyPipeline, resolveChannelStreamingBlockEnabled } from "openclaw/plugin-sdk/channel-outbound";
 import { createChannelPairingChallengeIssuer } from "openclaw/plugin-sdk/channel-pairing";
 import { detectMime, estimateBase64DecodedBytes, kindFromMime, saveMediaBuffer } from "openclaw/plugin-sdk/media-runtime";
 import { resolveAgentRoute, resolveInboundLastRouteSessionKey } from "openclaw/plugin-sdk/routing";
@@ -15,6 +15,7 @@ import { CHANNEL_APPROVAL_NATIVE_RUNTIME_CONTEXT_CAPABILITY } from "openclaw/plu
 import { normalizeE164, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import nodePath from "node:path";
 import { resolvePinnedMainDmOwnerFromAllowlist } from "openclaw/plugin-sdk/security-runtime";
+import { collectErrorGraphCandidates, formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { resolveChannelGroupPolicy, resolveChannelGroupRequireMention } from "openclaw/plugin-sdk/channel-policy";
 import { registerChannelRuntimeContext } from "openclaw/plugin-sdk/channel-runtime-context";
 import { DEFAULT_GROUP_HISTORY_LIMIT, createChannelHistoryWindow } from "openclaw/plugin-sdk/reply-history";
@@ -26,18 +27,23 @@ import { resolveAllowlistProviderRuntimeGroupPolicy, resolveDefaultGroupPolicy,
 import { waitForTransportReady } from "openclaw/plugin-sdk/transport-ready-runtime";
 import { spawn } from "node:child_process";
 import os from "node:os";
+import { createInterface } from "node:readline";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { resolveHumanDelayConfig } from "openclaw/plugin-sdk/agent-runtime";
 import { DEFAULT_EMOJIS, DEFAULT_TIMING, createStatusReactionController, logAckFailure, logTypingFailure, resolveAckReaction, shouldAckReaction } from "openclaw/plugin-sdk/channel-feedback";
 import { buildChannelInboundEventContext, buildMentionRegexes, createChannelInboundDebouncer, filterChannelInboundQuoteContext, formatInboundEnvelope, formatInboundFromLabel, formatInboundMediaUnavailableText, hasVisibleInboundReplyDispatch, logInboundDrop, matchesMentionPatterns, resolveEnvelopeFormatOptions, resolveInboundMentionDecision, runChannelInboundEvent, shouldDebounceTextInbound } from "openclaw/plugin-sdk/channel-inbound";
-import { hasControlCommand } from "openclaw/plugin-sdk/command-auth-native";
+import { isControlCommandMessage } from "openclaw/plugin-sdk/command-detection";
 import { recordInboundSession, upsertChannelPairingRequest } from "openclaw/plugin-sdk/conversation-runtime";
 import { createInternalHookEvent, fireAndForgetHook, toInternalMessageReceivedContext, triggerInternalHook } from "openclaw/plugin-sdk/hook-runtime";
 import { resolveBatchedReplyThreadingPolicy } from "openclaw/plugin-sdk/reply-reference";
 import { readSessionUpdatedAt, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
 import { enqueueSystemEvent } from "openclaw/plugin-sdk/system-event-runtime";
 import { createChannelIngressResolver, defineStableChannelIngressIdentity } from "openclaw/plugin-sdk/channel-ingress-runtime";
+import { 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";
 //#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"})`;
 }
@@ -53,12 +59,11 @@ function classifySignalCliLogLine(line) {
 	return "log";
 }
 function bindSignalCliOutput(params) {
-	params.stream?.on("data", (data) => {
-		for (const line of data.toString().split(/\r?\n/)) {
-			const kind = classifySignalCliLogLine(line);
-			if (kind === "log") params.log(`signal-cli: ${line.trim()}`);
-			else if (kind === "error") params.error(`signal-cli: ${line.trim()}`);
-		}
+	if (!params.stream) return;
+	createInterface({ input: params.stream }).on("line", (line) => {
+		const kind = classifySignalCliLogLine(line);
+		if (kind === "log") params.log(`signal-cli: ${line.trim()}`);
+		else if (kind === "error") params.error(`signal-cli: ${line.trim()}`);
 	});
 }
 function resolveSignalCliConfigPath(raw) {
@@ -91,6 +96,7 @@ function spawnSignalDaemon(opts) {
 	const error = opts.runtime?.error ?? (() => {});
 	let exited = false;
 	let settledExit = false;
+	let stopPromise;
 	let resolveExit;
 	const exitedPromise = new Promise((resolve) => {
 		resolveExit = resolve;
@@ -131,19 +137,42 @@ function spawnSignalDaemon(opts) {
 		});
 	});
 	child.on("error", (err) => {
-		error(`signal-cli spawn error: ${String(err)}`);
-		settleExit({
-			source: "spawn-error",
-			code: null,
-			signal: null
-		});
+		if (child.pid === void 0) {
+			error(`signal-cli spawn error: ${String(err)}`);
+			settleExit({
+				source: "spawn-error",
+				code: null,
+				signal: null
+			});
+		} else error(`signal-cli process error: ${String(err)}`);
 	});
 	return {
 		pid: child.pid ?? void 0,
 		exited: exitedPromise,
 		isExited: () => exited,
 		stop: () => {
-			if (!child.killed && !exited) child.kill("SIGTERM");
+			if (exited) return Promise.resolve();
+			if (stopPromise) return stopPromise;
+			if (!child.killed) try {
+				child.kill("SIGTERM");
+			} catch (err) {
+				error(`signal-cli stop error: ${String(err)}`);
+			}
+			stopPromise = new Promise((resolve) => {
+				const timeout = setTimeout(() => {
+					if (!exited) try {
+						child.kill("SIGKILL");
+					} catch (err) {
+						error(`signal-cli force-stop error: ${String(err)}`);
+					}
+				}, SIGNAL_DAEMON_STOP_KILL_TIMEOUT_MS);
+				timeout.unref?.();
+				exitedPromise.then(() => {
+					clearTimeout(timeout);
+					resolve();
+				});
+			});
+			return stopPromise;
 		}
 	};
 }
@@ -214,8 +243,8 @@ function signalSubjectInput(params) {
 	return {
 		stableId: formatSignalSenderId(params.sender),
 		aliases: {
-			phone: params.sender.kind === "phone" ? params.sender.e164 : void 0,
-			uuid: params.sender.kind === "uuid" ? params.sender.raw : void 0,
+			phone: params.sender.kind === "phone" ? params.sender.e164 : params.sender.aliases?.e164,
+			uuid: params.sender.kind === "uuid" ? params.sender.raw : params.sender.aliases?.uuid,
 			group: params.groupId
 		}
 	};
@@ -281,6 +310,96 @@ async function handleSignalDirectMessageAccess(params) {
 	return false;
 }
 //#endregion
+//#region extensions/signal/src/monitor/event-handler.control-lane.ts
+const SIGNAL_ACTIVE_RUN_CONTROL_COMMAND_KEYS = /* @__PURE__ */ new Set([
+	"approve",
+	"commands",
+	"context",
+	"help",
+	"status",
+	"steer",
+	"tasks",
+	"tools",
+	"whoami"
+]);
+function resolveSignalConversationId(entry) {
+	return (entry.isGroup ? entry.groupId : entry.senderPeerId)?.trim() || null;
+}
+function resolveSignalInboundDebounceKey(accountId, entry) {
+	const conversationId = resolveSignalConversationId(entry);
+	if (!conversationId || !entry.senderPeerId) return null;
+	return `signal:${accountId}:${conversationId}:${entry.senderPeerId}`;
+}
+function resolveSignalInboundConversationKey(accountId, entry) {
+	const conversationId = resolveSignalConversationId(entry);
+	return conversationId ? `signal:${accountId}:${conversationId}` : null;
+}
+function isSignalActiveRunControlText(text) {
+	if (isAbortRequestText(text)) return true;
+	const normalizedBody = normalizeCommandBody(text.trim());
+	const alias = maybeResolveTextAlias(normalizedBody);
+	if (!alias) return false;
+	const command = listChatCommands().find((entry) => entry.textAliases.some((candidate) => candidate.trim().toLowerCase() === alias));
+	if (command?.key === "queue") return normalizedBody.slice(alias.length).trim() === "";
+	return command ? SIGNAL_ACTIVE_RUN_CONTROL_COMMAND_KEYS.has(command.key) : false;
+}
+function resolveSignalControlLaneKey(accountId, entry) {
+	if (!entry.commandAuthorized || !isSignalActiveRunControlText(entry.commandBody)) return null;
+	const conversationId = resolveSignalConversationId(entry);
+	return conversationId ? `signal:${accountId}:${conversationId}:control` : null;
+}
+function createSignalPendingInboundRegistry(accountId) {
+	const trackedEntries = /* @__PURE__ */ new WeakMap();
+	const countsByConversation = /* @__PURE__ */ new Map();
+	const track = (entry) => {
+		if (trackedEntries.has(entry)) return;
+		const conversationKey = resolveSignalInboundConversationKey(accountId, entry);
+		const inboundKey = resolveSignalInboundDebounceKey(accountId, entry);
+		if (!conversationKey || !inboundKey) return;
+		const counts = countsByConversation.get(conversationKey) ?? /* @__PURE__ */ new Map();
+		counts.set(inboundKey, (counts.get(inboundKey) ?? 0) + 1);
+		countsByConversation.set(conversationKey, counts);
+		trackedEntries.set(entry, {
+			conversationKey,
+			inboundKey
+		});
+	};
+	const complete = (entries) => {
+		for (const entry of entries) {
+			const tracked = trackedEntries.get(entry);
+			if (!tracked) continue;
+			trackedEntries.delete(entry);
+			const counts = countsByConversation.get(tracked.conversationKey);
+			const nextCount = (counts?.get(tracked.inboundKey) ?? 0) - 1;
+			if (nextCount > 0) {
+				counts?.set(tracked.inboundKey, nextCount);
+				continue;
+			}
+			counts?.delete(tracked.inboundKey);
+			if (counts?.size === 0) countsByConversation.delete(tracked.conversationKey);
+		}
+	};
+	const cancelPendingOnAbort = (entry, cancelKey) => {
+		if (!entry.commandAuthorized || !isAbortRequestText(entry.commandBody)) return;
+		const conversationKey = resolveSignalInboundConversationKey(accountId, entry);
+		if (!conversationKey) return;
+		for (const inboundKey of countsByConversation.get(conversationKey)?.keys() ?? []) cancelKey(inboundKey);
+	};
+	const completeAfter = (flush) => async (entries) => {
+		try {
+			await flush(entries);
+		} finally {
+			complete(entries);
+		}
+	};
+	return {
+		track,
+		complete,
+		completeAfter,
+		cancelPendingOnAbort
+	};
+}
+//#endregion
 //#region extensions/signal/src/monitor/inbound-context.ts
 function resolveSignalQuoteContext(params) {
 	const contextVisibilityMode = resolveChannelContextVisibilityMode({
@@ -328,6 +447,41 @@ function clampBounds(start, length, textLength) {
 		end: Math.min(textLength, safeStart + Math.max(0, Math.trunc(length)))
 	};
 }
+function isValidStructuredMention(message, mention) {
+	if (!mention || !(mention.uuid || mention.number)) return false;
+	const { start, length } = mention;
+	if (typeof start !== "number" || typeof length !== "number") return false;
+	return Number.isInteger(start) && Number.isInteger(length) && start >= 0 && length > 0 && start + length <= message.length;
+}
+function normalizeAccountPhone(account) {
+	const trimmed = account?.trim();
+	return trimmed ? normalizeE164(trimmed) : void 0;
+}
+function resolveSignalNativeMentionFacts(params) {
+	const validMentions = (params.mentions ?? []).filter((mention) => isValidStructuredMention(params.message, mention));
+	const botUuid = params.accountUuid?.trim();
+	const botPhone = normalizeAccountPhone(params.account);
+	const canDetectBotMention = Boolean(botUuid || botPhone);
+	const mentionsBot = validMentions.some((mention) => {
+		const mentionUuid = mention.uuid?.trim();
+		if (botUuid && mentionUuid === botUuid) return true;
+		const mentionNumber = mention.number?.trim();
+		return Boolean(botPhone && mentionNumber && normalizeE164(mentionNumber) === botPhone);
+	});
+	return {
+		canDetectBotMention,
+		hasAnyMention: validMentions.length > 0,
+		mentionsBot
+	};
+}
+function resolveSignalMentionFacts(identity, message, mentions) {
+	return resolveSignalNativeMentionFacts({
+		message,
+		mentions,
+		account: identity.account,
+		accountUuid: identity.accountUuid
+	});
+}
 function renderSignalMentions(message, mentions) {
 	if (!message || !mentions?.length) return message;
 	let normalized = message;
@@ -344,6 +498,15 @@ function renderSignalMentions(message, mentions) {
 }
 //#endregion
 //#region extensions/signal/src/monitor/event-handler.ts
+const REPLY_SESSION_INIT_CONFLICT_MESSAGE_RE = /reply session initialization conflicted for \S+/u;
+const RETRYABLE_FLUSH_RETRY_DELAYS_MS = [
+	1e3,
+	2e3,
+	4e3
+];
+function isSignalReplySessionInitConflictError(error) {
+	return collectErrorGraphCandidates(error, (current) => [current.cause, current.error]).some((candidate) => REPLY_SESSION_INIT_CONFLICT_MESSAGE_RE.test(formatErrorMessage(candidate)));
+}
 function formatAttachmentKindCount(kind, count) {
 	if (kind === "attachment") return `${count} file${count > 1 ? "s" : ""}`;
 	return `${count} ${kind}${count > 1 ? "s" : ""}`;
@@ -404,6 +567,7 @@ async function finalizeSignalStatusReaction(params) {
 	await params.controller.restoreInitial();
 }
 function createSignalEventHandler(deps) {
+	const activeEnqueueEntries = /* @__PURE__ */ new WeakSet();
 	async function handleSignalInboundMessage(entry) {
 		const fromLabel = formatInboundFromLabel({
 			isGroup: entry.isGroup,
@@ -461,11 +625,12 @@ function createSignalEventHandler(deps) {
 			historyKey,
 			limit: deps.historyLimit
 		}) : void 0;
-		const replyThreading = resolveBatchedReplyThreadingPolicy(resolveSignalReplyToMode({
+		const replyToMode = resolveSignalReplyToMode({
 			cfg: deps.cfg,
 			accountId: deps.accountId,
 			chatType: entry.isGroup ? "group" : "direct"
-		}), entry.isBatched === true);
+		});
+		const replyThreading = resolveBatchedReplyThreadingPolicy(replyToMode, entry.isBatched === true);
 		const media = entry.mediaPaths && entry.mediaPaths.length > 0 ? entry.mediaPaths.map((path, index) => ({
 			path,
 			url: path,
@@ -618,6 +783,7 @@ function createSignalEventHandler(deps) {
 			replyToId: ctxPayload.ReplyToId,
 			author: entry.senderRecipient,
 			body: entry.nativeReplyBody ?? entry.bodyText,
+			allowImplicitCurrentMessage: replyToMode !== "off" && replyThreading?.implicitCurrentMessage !== "deny",
 			state: { hasReplied: false }
 		};
 		const { dispatcher, replyOptions, markDispatchIdle } = createReplyDispatcherWithTyping({
@@ -753,14 +919,75 @@ function createSignalEventHandler(deps) {
 			}
 		});
 	}
-	const { debouncer: inboundDebouncer } = createChannelInboundDebouncer({
+	async function flushSignalInboundEntries(entries) {
+		const last = entries.at(-1);
+		if (!last) return;
+		if (entries.length === 1) {
+			await handleSignalInboundMessage(last);
+			return;
+		}
+		const combinedText = entries.map((entry) => entry.bodyText).filter(Boolean).join("\\n");
+		const combinedCommandBody = entries.map((entry) => entry.commandBody).filter(Boolean).join("\\n");
+		if (!combinedText.trim()) return;
+		await handleSignalInboundMessage({
+			...last,
+			bodyText: combinedText,
+			commandBody: combinedCommandBody,
+			isBatched: true,
+			nativeReplyBody: last.nativeReplyBody ?? last.bodyText,
+			mediaPath: void 0,
+			mediaType: void 0,
+			mediaPaths: void 0,
+			mediaTypes: void 0
+		});
+	}
+	async function retrySignalInboundFlush(entries, initialError) {
+		let lastError = initialError;
+		for (const [attemptIndex, delayMs] of RETRYABLE_FLUSH_RETRY_DELAYS_MS.entries()) {
+			const attempt = attemptIndex + 1;
+			logVerbose(`signal: reply session init conflict, retrying ${entries.length} inbound message(s) in ${delayMs}ms (attempt ${attempt}/${RETRYABLE_FLUSH_RETRY_DELAYS_MS.length})`);
+			try {
+				await setTimeout$1(delayMs, void 0, {
+					ref: false,
+					signal: deps.abortSignal
+				});
+			} catch (err) {
+				if (deps.abortSignal?.aborted) return;
+				throw err;
+			}
+			if (deps.abortSignal?.aborted) return;
+			try {
+				await flushSignalInboundEntries(entries);
+				return;
+			} catch (err) {
+				if (deps.abortSignal?.aborted) return;
+				lastError = err;
+				if (!isSignalReplySessionInitConflictError(err)) throw err;
+			}
+		}
+		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);
+			deps.runTrackedTask?.(() => retryTask.catch(() => void 0));
+			await retryTask;
+		}
+	};
+	const reportSignalInboundFlushError = (err) => {
+		deps.runtime.error?.(`signal debounce flush failed: ${String(err)}`);
+	};
+	const pendingInboundRegistry = createSignalPendingInboundRegistry(deps.accountId);
+	const flushNormalSignalInboundEntries = pendingInboundRegistry.completeAfter(flushDebouncedSignalInboundEntries);
+	const { debouncer } = createChannelInboundDebouncer({
 		cfg: deps.cfg,
 		channel: "signal",
-		buildKey: (entry) => {
-			const conversationId = entry.isGroup ? entry.groupId ?? "unknown" : entry.senderPeerId;
-			if (!conversationId || !entry.senderPeerId) return null;
-			return `signal:${deps.accountId}:${conversationId}:${entry.senderPeerId}`;
-		},
+		buildKey: (entry) => resolveSignalInboundDebounceKey(deps.accountId, entry),
 		shouldDebounce: (entry) => {
 			return shouldDebounceTextInbound({
 				text: entry.commandBody,
@@ -768,31 +995,18 @@ function createSignalEventHandler(deps) {
 				hasMedia: Boolean(entry.mediaPath || entry.mediaType || entry.mediaPaths?.length)
 			});
 		},
-		onFlush: async (entries) => {
-			const last = entries.at(-1);
-			if (!last) return;
-			if (entries.length === 1) {
-				await handleSignalInboundMessage(last);
-				return;
-			}
-			const combinedText = entries.map((entry) => entry.bodyText).filter(Boolean).join("\\n");
-			const combinedCommandBody = entries.map((entry) => entry.commandBody).filter(Boolean).join("\\n");
-			if (!combinedText.trim()) return;
-			await handleSignalInboundMessage({
-				...last,
-				bodyText: combinedText,
-				commandBody: combinedCommandBody,
-				isBatched: true,
-				nativeReplyBody: last.nativeReplyBody ?? last.bodyText,
-				mediaPath: void 0,
-				mediaType: void 0,
-				mediaPaths: void 0,
-				mediaTypes: void 0
-			});
-		},
-		onError: (err) => {
-			deps.runtime.error?.(`signal debounce flush failed: ${String(err)}`);
-		}
+		onFlush: flushNormalSignalInboundEntries,
+		onError: reportSignalInboundFlushError,
+		onCancel: pendingInboundRegistry.complete
+	});
+	const { debouncer: controlDebouncer } = createChannelInboundDebouncer({
+		cfg: deps.cfg,
+		channel: "signal",
+		serializeImmediate: true,
+		buildKey: (entry) => resolveSignalControlLaneKey(deps.accountId, entry),
+		shouldDebounce: () => false,
+		onFlush: flushDebouncedSignalInboundEntries,
+		onError: reportSignalInboundFlushError
 	});
 	async function handleReactionOnlyInbound(params) {
 		if (params.hasBodyContent) return false;
@@ -878,10 +1092,11 @@ function createSignalEventHandler(deps) {
 		if ("syncMessage" in envelope) return;
 		const dataMessage = envelope.dataMessage ?? envelope.editMessage?.dataMessage;
 		const reaction = deps.isSignalReactionMessage(envelope.reactionMessage) ? envelope.reactionMessage : deps.isSignalReactionMessage(dataMessage?.reaction) ? dataMessage?.reaction : null;
-		const messageText = renderSignalMentions(dataMessage?.message ?? "", dataMessage?.mentions).trim();
+		const rawMessage = dataMessage?.message ?? "";
+		const messageText = renderSignalMentions(rawMessage, dataMessage?.mentions).trim();
 		const groupId = dataMessage?.groupInfo?.groupId ?? reaction?.groupInfo?.groupId ?? void 0;
 		const isGroup = Boolean(groupId);
-		const hasControlCommandInMessage = hasControlCommand(messageText, deps.cfg);
+		const hasControlCommandInMessage = isControlCommandMessage(messageText, deps.cfg);
 		const senderDisplay = formatSignalSenderDisplay(sender);
 		const { senderAccess, commandAccess } = await resolveSignalAccessState({
 			accountId: deps.accountId,
@@ -966,8 +1181,16 @@ function createSignalEventHandler(deps) {
 			groupId,
 			senderPeerId
 		});
+		const inboundTimestamp = typeof envelope.timestamp === "number" ? envelope.timestamp : typeof dataMessage.timestamp === "number" ? dataMessage.timestamp : void 0;
+		const nativeReplyTargetTimestamp = typeof envelope.editMessage?.targetSentTimestamp === "number" ? envelope.editMessage.targetSentTimestamp : inboundTimestamp;
+		const messageId = typeof inboundTimestamp === "number" ? String(inboundTimestamp) : void 0;
+		const replyToId = typeof nativeReplyTargetTimestamp === "number" ? String(nativeReplyTargetTimestamp) : void 0;
+		const signalToRaw = isGroup ? `group:${groupId}` : `signal:${senderRecipient}`;
+		const signalTo = normalizeSignalMessagingTarget(signalToRaw) ?? signalToRaw;
 		const mentionRegexes = buildMentionRegexes(deps.cfg, route.agentId);
-		const wasMentioned = isGroup && matchesMentionPatterns(messageText, mentionRegexes);
+		const textWasMentioned = isGroup && matchesMentionPatterns(messageText, mentionRegexes);
+		const nativeMentionFacts = resolveSignalMentionFacts(deps, rawMessage, dataMessage?.mentions);
+		const wasMentioned = isGroup && (textWasMentioned || nativeMentionFacts.mentionsBot);
 		const requireMention = isGroup && resolveChannelGroupRequireMention({
 			cfg: deps.cfg,
 			channel: "signal",
@@ -975,12 +1198,12 @@ function createSignalEventHandler(deps) {
 			accountId: deps.accountId,
 			configuredGroupDefaultsToNoMention: true
 		});
-		const canDetectMention = mentionRegexes.length > 0;
+		const canDetectMention = mentionRegexes.length > 0 || nativeMentionFacts.canDetectBotMention;
 		const mentionDecision = resolveInboundMentionDecision({
 			facts: {
 				canDetectMention,
 				wasMentioned,
-				hasAnyMention: false,
+				hasAnyMention: nativeMentionFacts.hasAnyMention,
 				implicitMentionKinds: []
 			},
 			policy: {
@@ -1020,6 +1243,14 @@ function createSignalEventHandler(deps) {
 					messageId: typeof envelope.timestamp === "number" ? String(envelope.timestamp) : void 0
 				}
 			});
+			await registerSignalReplyContext({
+				accountId: deps.accountId,
+				to: signalTo,
+				replyToId,
+				author: senderRecipient,
+				body: pendingBodyText,
+				sourceTimestamp: inboundTimestamp
+			});
 			const signalGroupPolicy = resolveChannelGroupPolicy({
 				cfg: deps.cfg,
 				channel: "signal",
@@ -1098,8 +1329,6 @@ function createSignalEventHandler(deps) {
 			});
 		}
 		if (!bodyText) return;
-		const inboundTimestamp = typeof envelope.timestamp === "number" ? envelope.timestamp : typeof dataMessage.timestamp === "number" ? dataMessage.timestamp : void 0;
-		const nativeReplyTargetTimestamp = typeof envelope.editMessage?.targetSentTimestamp === "number" ? envelope.editMessage.targetSentTimestamp : inboundTimestamp;
 		if (deps.sendReadReceipts && !deps.readReceiptsViaDaemon && !isGroup && inboundTimestamp) try {
 			await sendReadReceiptSignal(`signal:${senderRecipient}`, inboundTimestamp, {
 				cfg: deps.cfg,
@@ -1112,9 +1341,15 @@ function createSignalEventHandler(deps) {
 		}
 		else if (deps.sendReadReceipts && !deps.readReceiptsViaDaemon && !isGroup && !inboundTimestamp) logVerbose(`signal read receipt skipped (missing timestamp) for ${senderDisplay}`);
 		const senderName = envelope.sourceName ?? senderDisplay;
-		const messageId = typeof inboundTimestamp === "number" ? String(inboundTimestamp) : void 0;
-		const replyToId = typeof nativeReplyTargetTimestamp === "number" ? String(nativeReplyTargetTimestamp) : void 0;
-		await inboundDebouncer.enqueue({
+		await registerSignalReplyContext({
+			accountId: deps.accountId,
+			to: signalTo,
+			replyToId,
+			author: senderRecipient,
+			body: bodyText,
+			sourceTimestamp: inboundTimestamp
+		});
+		const entry = {
 			senderName,
 			senderDisplay,
 			senderRecipient,
@@ -1138,7 +1373,16 @@ function createSignalEventHandler(deps) {
 			replyToBody: visibleQuoteText || void 0,
 			replyToSender: visibleQuoteSender,
 			replyToIsQuote: visibleQuoteText ? true : void 0
-		});
+		};
+		pendingInboundRegistry.cancelPendingOnAbort(entry, debouncer.cancelKey);
+		const inboundLane = resolveSignalControlLaneKey(deps.accountId, entry) ? controlDebouncer : debouncer;
+		if (inboundLane === debouncer) pendingInboundRegistry.track(entry);
+		activeEnqueueEntries.add(entry);
+		try {
+			await inboundLane.enqueue(entry);
+		} finally {
+			activeEnqueueEntries.delete(entry);
+		}
 	};
 }
 //#endregion
@@ -1209,8 +1453,8 @@ function resolveRuntime(opts) {
 function createSignalMonitorTaskRunner(runtime) {
 	const inFlight = /* @__PURE__ */ new Set();
 	return {
-		runEventTask(task) {
-			const trackedTask = Promise.resolve().then(task).catch((err) => runtime.error?.(`event handler failed: ${String(err)}`)).finally(() => inFlight.delete(trackedTask));
+		runTask(task) {
+			const trackedTask = Promise.resolve().then(task).catch((err) => runtime.error?.(`signal monitor task failed: ${String(err)}`)).finally(() => inFlight.delete(trackedTask));
 			inFlight.add(trackedTask);
 		},
 		async waitForIdle() {
@@ -1218,58 +1462,16 @@ function createSignalMonitorTaskRunner(runtime) {
 		}
 	};
 }
-function mergeAbortSignals(a, b) {
-	if (!a && !b) return {
-		signal: void 0,
-		dispose: () => {}
-	};
-	if (!a) return {
-		signal: b,
-		dispose: () => {}
-	};
-	if (!b) return {
-		signal: a,
-		dispose: () => {}
-	};
-	const controller = new AbortController();
-	const abortFrom = (source) => {
-		if (!controller.signal.aborted) controller.abort(source.reason);
-	};
-	if (a.aborted) {
-		abortFrom(a);
-		return {
-			signal: controller.signal,
-			dispose: () => {}
-		};
-	}
-	if (b.aborted) {
-		abortFrom(b);
-		return {
-			signal: controller.signal,
-			dispose: () => {}
-		};
-	}
-	const onAbortA = () => abortFrom(a);
-	const onAbortB = () => abortFrom(b);
-	a.addEventListener("abort", onAbortA, { once: true });
-	b.addEventListener("abort", onAbortB, { once: true });
-	return {
-		signal: controller.signal,
-		dispose: () => {
-			a.removeEventListener("abort", onAbortA);
-			b.removeEventListener("abort", onAbortB);
-		}
-	};
-}
 function createSignalDaemonLifecycle(params) {
 	let daemonHandle = null;
 	let daemonStopRequested = false;
 	let daemonExitError;
 	const daemonAbortController = new AbortController();
-	const mergedAbort = mergeAbortSignals(params.abortSignal, daemonAbortController.signal);
+	const abortSignal = params.abortSignal ? AbortSignal.any([params.abortSignal, daemonAbortController.signal]) : daemonAbortController.signal;
 	const stop = () => {
 		daemonStopRequested = true;
-		daemonHandle?.stop();
+		if (!daemonAbortController.signal.aborted) daemonAbortController.abort(params.abortSignal?.reason ?? /* @__PURE__ */ new Error("Signal monitor stopped"));
+		return daemonHandle?.stop() ?? Promise.resolve();
 	};
 	const attach = (handle) => {
 		daemonHandle = handle;
@@ -1284,8 +1486,7 @@ function createSignalDaemonLifecycle(params) {
 		attach,
 		stop,
 		getExitError,
-		abortSignal: mergedAbort.signal,
-		dispose: mergedAbort.dispose
+		abortSignal
 	};
 }
 function normalizeAllowList(raw) {
@@ -1403,14 +1604,15 @@ async function deliverReplies(params) {
 	});
 	for (const payload of replies) {
 		const deliveryResults = [];
+		const presentationPayload = materializeSignalPresentationFallback(payload);
 		const deliveredPayload = addSignalApprovalReactionHintToStructuredPayload({
 			cfg: params.cfg,
 			accountId,
 			to: target,
-			payload,
+			payload: presentationPayload,
 			targetAuthor: account,
 			targetAuthorUuid: accountUuid
-		}) ?? payload;
+		}) ?? presentationPayload;
 		const reply = resolveSendableOutboundReplyParts(deliveredPayload);
 		const nextNativeReply = createSignalNativeReplyResolver({
 			payload: deliveredPayload,
@@ -1471,12 +1673,15 @@ 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 (!payloadReplyToId || !contextReplyToId || payloadReplyToId !== contextReplyToId) return {};
+	if (!contextReplyToId || payloadReplyToId && payloadReplyToId !== contextReplyToId) return {};
+	const replyToId = payloadReplyToId ?? contextReplyToId;
 	const replyToAuthor = normalizeOptionalString(params.replyContext?.author);
-	if (!replyToAuthor) return { replyToId: payloadReplyToId };
+	if (!replyToAuthor) return { replyToId };
 	return {
-		replyToId: payloadReplyToId,
+		replyToId,
 		replyToAuthor,
 		replyToBody: params.replyContext?.body ?? ""
 	};
@@ -1603,12 +1808,14 @@ async function monitorSignalProvider(opts = {}) {
 		});
 		const handleEvent = createSignalEventHandler({
 			runtime,
+			abortSignal: daemonLifecycle.abortSignal,
+			runTrackedTask: (task) => monitorTaskRunner.runTask(task),
 			cfg,
 			baseUrl,
 			account,
 			accountUuid: accountInfo.config.accountUuid,
 			accountId: accountInfo.accountId,
-			blockStreaming: accountInfo.config.blockStreaming,
+			blockStreaming: resolveChannelStreamingBlockEnabled(accountInfo.config),
 			historyLimit,
 			groupHistories,
 			textLimit,
@@ -1645,7 +1852,7 @@ async function monitorSignalProvider(opts = {}) {
 			apiMode: configuredApiMode,
 			policy: opts.reconnectPolicy,
 			onEvent: (event) => {
-				monitorTaskRunner.runEventTask(() => handleEvent(event));
+				monitorTaskRunner.runTask(() => handleEvent(event));
 			}
 		});
 		const daemonExitError = daemonLifecycle.getExitError();
@@ -1655,10 +1862,8 @@ async function monitorSignalProvider(opts = {}) {
 		if (opts.abortSignal?.aborted && !daemonExitError) return;
 		throw err;
 	} finally {
-		await monitorTaskRunner.waitForIdle();
-		daemonLifecycle.dispose();
+		await Promise.all([daemonLifecycle.stop(), monitorTaskRunner.waitForIdle()]);
 		opts.abortSignal?.removeEventListener("abort", onAbort);
-		daemonLifecycle.stop();
 	}
 }
 //#endregion