@openclaw/signal 2026.9.5 → 2026.9.7

package/dist/.setup/{channel-gMpZmqLx.mjs → channel-DrUxv5cf.mjs}

@@ -1,12 +1,14 @@
+import { a as migrateLegacySignalTransportConfig, i as clearLegacySignalTransportFieldsForAccount, n as normalizeCompatibilityConfig, r as repairSignalAccountKeys } from "./doctor-contract-api-Db9V9gsY.mjs";
 import { a as normalizeSignalTransportUrl, i as normalizeSignalTransportHost, o as resolveSignalAccountEntry, s as resolveSignalAccountKey, t as assertSignalSocketTransport } from "./transport-url-CAC0JcuI.mjs";
-import { a as isSignalManagedNativeConnectionUrlForBind, i as assignSignalManagedNativePort, o as isValidSignalManagedNativePort, r as allocateSignalManagedNativePort, s as resolveLocalSignalTransportPort } from "./transport-policy-5VSnj5ma.mjs";
-import { a as resolveSignalAccountConfig, i as resolveSignalAccount, n as listSignalAccountIds, o as resolveSignalReplyToMode, r as resolveDefaultSignalAccountId, s as resolveSignalTransport } from "./accounts-BV6tDOTc.mjs";
-import { n as normalizeSignalMessagingTarget, t as looksLikeSignalTargetId } from "./normalize-l_b99hap.mjs";
-import { a as resolveSignalTarget, r as listSignalAliasDirectoryEntries } from "./approval-auth-BBI9BTRm.mjs";
-import { c as resolveSignalSender, l as looksLikeUuid, o as resolveSignalPeerId, s as resolveSignalRecipient } from "./identity-YXPmgFMu.mjs";
-import { c as resolveSignalReactionLevel, d as markdownToSignalTextChunks, l as formatSignalMediaText, m as signalApprovalCapability, o as materializeSignalPresentationFallback, p as shouldSuppressLocalSignalExecApprovalPrompt, r as resolveSignalReplyContextWithPersistence, s as signalMessageActions, t as detectSignalTransport } from "./transport-detection-CqyR2vG8.mjs";
-import { a as migrateLegacySignalTransportConfig, i as clearLegacySignalTransportFieldsForAccount, n as normalizeCompatibilityConfig, r as repairSignalAccountKeys } from "./doctor-contract-api-Rbq_sRTI.mjs";
-import { t as SignalChannelConfigSchema } from "./config-schema-aQwwMGUj.mjs";
+import { a as isSignalManagedNativeConnectionUrlForBind, c as resolveLocalSignalTransportPort, i as assignSignalManagedNativePort, o as isValidSignalManagedNativePort, r as allocateSignalManagedNativePort, s as reserveSignalTransportPorts } from "./transport-policy-B6C_LogW.mjs";
+import { a as resolveSignalAccountConfig, i as resolveSignalAccount, n as listSignalAccountIds, o as resolveSignalReplyToMode, r as resolveDefaultSignalAccountId, s as resolveSignalTransport, t as listEnabledSignalAccounts } from "./accounts-DMtj2E-4.mjs";
+import { n as normalizeSignalMessagingTarget, r as normalizeSignalReactionRecipient, t as looksLikeSignalTargetId } from "./normalize-l_b99hap.mjs";
+import { a as resolveSignalTarget, n as signalApprovalAuth, r as listSignalAliasDirectoryEntries, t as getSignalApprovalApprovers } from "./approval-auth-CszS7gwf.mjs";
+import { c as resolveSignalSender, l as looksLikeUuid, o as resolveSignalPeerId, s as resolveSignalRecipient } from "./identity-B3JyPqGO.mjs";
+import { n as sendReactionSignal, t as removeReactionSignal } from "./reaction-runtime-api-DDi5x2wC.mjs";
+import { t as getOptionalSignalRuntime } from "./runtime-8sxUF217.mjs";
+import { t as detectSignalTransport } from "./transport-detection-BVUDE42e.mjs";
+import { t as SignalChannelConfigSchema } from "./config-schema-DvxZ18SD.mjs";
 import { describeAccountSnapshot, resolveChannelMediaMaxBytes } from "openclaw/plugin-sdk/account-helpers";
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
 import { buildDmGroupAccountAllowlistAdapter } from "openclaw/plugin-sdk/allowlist-config-edit";
@@ -19,14 +21,24 @@ import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
 import { questionGatewayRuntime } from "openclaw/plugin-sdk/question-gateway-runtime";
 import { chunkText, resolveTextChunkLimit } from "openclaw/plugin-sdk/reply-chunking";
-import { buildOutboundBaseSessionKey } from "openclaw/plugin-sdk/routing";
-import { buildBaseChannelStatusSummary, collectStatusIssuesFromLastError, createComputedAccountStatusAdapter, createDefaultChannelRuntimeState } from "openclaw/plugin-sdk/status-helpers";
+import { buildOutboundBaseSessionKey, parseAgentSessionKey } from "openclaw/plugin-sdk/routing";
+import { buildBaseChannelStatusSummary, collectStatusIssuesFromLastError, createComputedAccountStatusAdapter, createDefaultChannelRuntimeState, resolveReactionLevel } from "openclaw/plugin-sdk/status-helpers";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeStringifiedEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { sanitizeAssistantVisibleText } from "openclaw/plugin-sdk/text-chunking";
+import { FormatCapabilityProfile, markdownToIR, renderMarkdownIRChunksWithinLimit, renderMarkdownWithAttributedRanges, sanitizeAssistantVisibleText } from "openclaw/plugin-sdk/text-chunking";
 import { normalizeAccountId as normalizeAccountId$1 } from "openclaw/plugin-sdk/account-resolution";
+import { createApproverRestrictedNativeApprovalCapabilityFromForwardingRoutes } from "openclaw/plugin-sdk/approval-delivery-runtime";
+import { createLazyChannelApprovalNativeRuntimeAdapter } from "openclaw/plugin-sdk/approval-handler-adapter-runtime";
+import { shouldSuppressLocalNativeExecApprovalPrompt } from "openclaw/plugin-sdk/approval-native-runtime";
+import { buildApprovalReactionPendingContentForRequest } from "openclaw/plugin-sdk/approval-reaction-runtime";
 import { normalizeE164 } from "openclaw/plugin-sdk/text-utility-runtime";
+import { formatMediaPlaceholderText } from "openclaw/plugin-sdk/channel-inbound";
+import { kindFromMime } from "openclaw/plugin-sdk/media-runtime";
+import { createActionGate, jsonResult, readStringParam, resolveReactionMessageId } from "openclaw/plugin-sdk/channel-actions";
+import { parseStrictNonNegativeInteger } from "openclaw/plugin-sdk/number-runtime";
 import { createChannelPluginBase, getChatChannelMeta } from "openclaw/plugin-sdk/core";
 import { parseAllowFromEntries } from "openclaw/plugin-sdk/allow-from";
+import { getExecApprovalReplyMetadata } from "openclaw/plugin-sdk/approval-reply-runtime";
+import { isMessagePresentationInteractiveBlock, normalizeMessagePresentation, renderMessagePresentationFallbackText } from "openclaw/plugin-sdk/interactive-runtime";
 import { createChannelDmPolicy } from "openclaw/plugin-sdk/channel-dm-policy";
 import { defineChannelSetupContract } from "openclaw/plugin-sdk/channel-setup";
 import { patchTopLevelChannelConfigSection } from "openclaw/plugin-sdk/setup";
@@ -34,6 +46,282 @@ import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$2, createCliPathTextInput, cre
 import { formatCliCommand, formatDocsLink } from "openclaw/plugin-sdk/setup-tools";
 import { adaptScopedAccountAccessor, createScopedChannelConfigAdapter } from "openclaw/plugin-sdk/channel-config-helpers";
 import { createRestrictSendersChannelSecurity } from "openclaw/plugin-sdk/channel-policy";
+//#region extensions/signal/src/approval-native.ts
+function isSignalApprovalTransportEnabled(params) {
+	return resolveSignalAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	}).enabled;
+}
+const signalApproval = createApproverRestrictedNativeApprovalCapabilityFromForwardingRoutes({
+	channel: "signal",
+	channelLabel: "Signal",
+	authorizeActorAction: (params) => signalApprovalAuth.authorizeActorAction(params),
+	routing: {
+		defaultForwardingMode: "session",
+		isTransportEnabled: isSignalApprovalTransportEnabled,
+		listAccountIds: listSignalAccountIds,
+		resolveDefaultAccountId: resolveDefaultSignalAccountId,
+		normalizeTo: normalizeSignalMessagingTarget,
+		resolveApprovers: getSignalApprovalApprovers,
+		suppressExplicitTargetFallback: false,
+		isOriginTargetAllowed: ({ cfg, accountId, target }) => !isSignalGroupTarget(target.to) || getSignalApprovalApprovers({
+			cfg,
+			accountId
+		}).length > 0
+	},
+	describeExecApprovalSetup: ({ accountId }) => {
+		return `Signal supports native exec approvals for this account when \`approvals.exec.enabled\` is true and the route allows Signal. Link Signal and keep the gateway running; configure \`${accountId && accountId !== "default" ? `channels.signal.accounts.${accountId}` : "channels.signal"}.allowFrom\` to restrict approvers.`;
+	},
+	render: {
+		exec: { buildPendingPayload: ({ request, nowMs }) => buildApprovalReactionPendingContentForRequest({
+			request,
+			nowMs
+		}).manualFallbackPayload },
+		plugin: { buildPendingPayload: ({ request, nowMs }) => buildApprovalReactionPendingContentForRequest({
+			request,
+			nowMs
+		}).manualFallbackPayload }
+	},
+	createNativeRuntime: (routing) => createLazyChannelApprovalNativeRuntimeAdapter({
+		capabilityBoundary: true,
+		eventKinds: [
+			"exec",
+			"plugin",
+			"system-agent"
+		],
+		isConfigured: ({ cfg, accountId, context }) => Boolean(context) && routing.isNativeApprovalHandlerConfigured({
+			cfg,
+			accountId
+		}),
+		shouldHandle: ({ cfg, accountId, context, approvalKind, request }) => Boolean(context) && routing.shouldHandleApprovalRequest({
+			cfg,
+			accountId,
+			approvalKind,
+			request
+		}),
+		load: async () => (await import("./approval-handler.runtime-D9ofZcZW.mjs")).signalApprovalNativeRuntime
+	})
+});
+const signalApprovalRouting = signalApproval.routing;
+function isSignalNativeApprovalHandlerConfigured(params) {
+	return signalApprovalRouting.isNativeApprovalHandlerConfigured(params);
+}
+function resolveSignalSessionTargetFromSessionKey(sessionKey) {
+	const rest = parseAgentSessionKey(sessionKey)?.rest ?? normalizeOptionalString(sessionKey);
+	if (!rest || !normalizeLowercaseStringOrEmpty(rest).startsWith("signal:")) return null;
+	return normalizeSignalMessagingTarget(rest.slice(7)) ?? null;
+}
+function shouldSuppressLocalSignalExecApprovalPrompt(params) {
+	return shouldSuppressLocalNativeExecApprovalPrompt({
+		...params,
+		isTransportEnabled: isSignalApprovalTransportEnabled,
+		isSessionRouteEligible: ({ cfg, accountId, metadata }) => {
+			if (getSignalApprovalApprovers({
+				cfg,
+				accountId
+			}).length > 0) return true;
+			const sessionTarget = resolveSignalSessionTargetFromSessionKey(metadata.sessionKey);
+			return Boolean(sessionTarget && !isSignalGroupTarget(sessionTarget));
+		}
+	});
+}
+function isSignalGroupTarget(to) {
+	return normalizeLowercaseStringOrEmpty(to).startsWith("group:");
+}
+const signalApprovalCapability = signalApproval.capability;
+//#endregion
+//#region extensions/signal/src/format.ts
+const SIGNAL_STYLE_MAP = {
+	bold: "BOLD",
+	italic: "ITALIC",
+	strikethrough: "STRIKETHROUGH",
+	code: "MONOSPACE",
+	code_block: "MONOSPACE",
+	spoiler: "SPOILER"
+};
+const SIGNAL_FORMAT_PROFILE = FormatCapabilityProfile.define({
+	mechanism: "ranges",
+	constructs: {
+		underline: "strip",
+		codeLanguage: "fallback",
+		linkLabel: "fallback",
+		heading: "fallback",
+		bulletList: "fallback",
+		orderedList: "fallback",
+		taskList: "fallback",
+		table: "fallback",
+		blockquote: "fallback",
+		image: "fallback",
+		mention: "strip"
+	},
+	chunk: {
+		limit: 4e3,
+		unit: "chars"
+	}
+});
+function stripEquivalentSignalLinks(ir) {
+	const normalize = (value, preserveSuffixCase) => {
+		const normalized = value.trim().replace(/^(?:https?:\/\/)?(?:www\.)?/i, "").replace(/\/+$/, "");
+		return preserveSuffixCase ? normalized.replace(/^[^/?#]+/, (host) => host.toLowerCase()) : normalizeLowercaseStringOrEmpty(normalized);
+	};
+	return {
+		...ir,
+		links: ir.links.filter((link) => {
+			const label = ir.text.slice(link.start, link.end);
+			const href = link.href.trim();
+			const preserveSuffixCase = /^https?:\/\//i.test(href);
+			return normalize(label, preserveSuffixCase) !== normalize(href.replace(/^mailto:/, ""), preserveSuffixCase);
+		})
+	};
+}
+function renderSignalText(ir) {
+	const rendered = renderMarkdownWithAttributedRanges(stripEquivalentSignalLinks(ir), {
+		styleMap: SIGNAL_STYLE_MAP,
+		annotationStyleMap: { assistant_transcript_role: "MONOSPACE" },
+		trimEnd: true
+	}, SIGNAL_FORMAT_PROFILE);
+	return {
+		text: rendered.text,
+		styles: rendered.ranges
+	};
+}
+function markdownToSignalIR(markdown, options) {
+	return markdownToIR(markdown ?? "", {
+		assistantTranscriptRoleHeaders: true,
+		linkify: true,
+		enableSpoilers: true,
+		headingStyle: "rich",
+		blockquotePrefix: "> ",
+		tableMode: options.tableMode
+	});
+}
+function markdownToSignalText(markdown, options = {}) {
+	return renderSignalText(markdownToSignalIR(markdown, options));
+}
+function markdownToSignalTextChunks(markdown, limit, options = {}) {
+	const ir = markdownToSignalIR(markdown, options);
+	if (ir.listItems && ir.text.length > limit) ir.listItems = ir.listItems.map((item) => ({ ...item }));
+	return renderMarkdownIRChunksWithinLimit({
+		ir,
+		limit,
+		assistantTranscriptRoleMessageBoundaries: true,
+		renderChunk: renderSignalText,
+		measureRendered: (rendered) => rendered.text.length
+	}).map(({ rendered }) => rendered);
+}
+//#endregion
+//#region extensions/signal/src/media-text.ts
+function formatAttachmentKindCount(kind, count) {
+	if (kind === "attachment") return `${count} file${count > 1 ? "s" : ""}`;
+	return `${count} ${kind}${count > 1 ? "s" : ""}`;
+}
+/** Keeps Signal's established multi-attachment text while sharing single-item rendering. */
+function formatSignalMediaText(media) {
+	if (media.length <= 1) return formatMediaPlaceholderText(media);
+	const kindCounts = /* @__PURE__ */ new Map();
+	for (const entry of media) {
+		const kind = entry.kind && entry.kind !== "unknown" ? entry.kind : kindFromMime(entry.contentType) ?? "attachment";
+		kindCounts.set(kind, (kindCounts.get(kind) ?? 0) + 1);
+	}
+	return `[${[...kindCounts.entries()].map(([kind, count]) => formatAttachmentKindCount(kind, count)).join(" + ")} attached]`;
+}
+//#endregion
+//#region extensions/signal/src/reaction-level.ts
+function resolveSignalReactionLevel(params) {
+	const account = resolveSignalAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	return resolveReactionLevel({
+		value: account.config.reactionLevel,
+		defaultLevel: "minimal",
+		invalidFallback: "minimal"
+	});
+}
+//#endregion
+//#region extensions/signal/src/message-actions.ts
+const providerId = "signal";
+const GROUP_PREFIX = "group:";
+function resolveSignalReactionTarget(raw) {
+	const withoutSignal = raw.trim().replace(/^signal:/i, "").trim();
+	if (!withoutSignal) return {};
+	if (normalizeLowercaseStringOrEmpty(withoutSignal).startsWith(GROUP_PREFIX)) {
+		const groupId = withoutSignal.slice(6).trim();
+		return groupId ? { groupId } : {};
+	}
+	return { recipient: normalizeSignalReactionRecipient(withoutSignal) };
+}
+const signalMessageActions = {
+	describeMessageTool: ({ cfg, accountId }) => {
+		const configuredAccounts = accountId ? [resolveSignalAccount({
+			cfg,
+			accountId
+		})].filter((account) => account.enabled && account.configured) : listEnabledSignalAccounts(cfg).filter((account) => account.configured);
+		if (configuredAccounts.length === 0) return null;
+		return { actions: configuredAccounts.some((account) => createActionGate(account.config.actions)("reactions")) ? ["send", "react"] : ["send"] };
+	},
+	supportsAction: ({ action }) => action === "react",
+	prepareSendPayload: ({ ctx, payload, replyToId, replyToIdSource }) => {
+		if (ctx.action !== "send") return null;
+		const normalizedReplyToId = replyToId?.trim();
+		if (!normalizedReplyToId) return payload;
+		return replyToIdSource === "implicit" ? payload : {
+			...payload,
+			replyToId: normalizedReplyToId
+		};
+	},
+	handleAction: async ({ action, params, cfg, accountId, toolContext, assertDirectAdapterHandoff }) => {
+		if (action === "send") throw new Error("Send should be handled by outbound, not actions handler.");
+		if (action === "react") {
+			const account = resolveSignalAccount({
+				cfg,
+				accountId
+			});
+			if (!account.enabled) throw new Error(`Signal account "${account.accountId}" is disabled.`);
+			if (!account.configured) throw new Error(`Signal account "${account.accountId}" is not configured.`);
+			const reactionLevelInfo = resolveSignalReactionLevel({
+				cfg,
+				accountId: account.accountId
+			});
+			if (!reactionLevelInfo.agentReactionsEnabled) throw new Error(`Signal agent reactions disabled (reactionLevel="${reactionLevelInfo.level}"). Set channels.signal.reactionLevel to "minimal" or "extensive" to enable.`);
+			if (!createActionGate(account.config.actions)("reactions")) throw new Error("Signal reactions are disabled via actions.reactions.");
+			const target = resolveSignalReactionTarget(readStringParam(params, "to", {
+				required: true,
+				label: "recipient (UUID, phone number, or group)"
+			}));
+			if (!target.recipient && !target.groupId) throw new Error("recipient or group required");
+			const messageIdRaw = resolveReactionMessageId({
+				args: params,
+				toolContext
+			});
+			const messageId = messageIdRaw != null ? String(messageIdRaw) : void 0;
+			if (!messageId) throw new Error("messageId (timestamp) required. Provide messageId explicitly or react to the current inbound message.");
+			const targetAuthor = readStringParam(params, "targetAuthor");
+			const targetAuthorUuid = readStringParam(params, "targetAuthorUuid");
+			if (target.groupId && !targetAuthor && !targetAuthorUuid) throw new Error("targetAuthor or targetAuthorUuid required for group reactions.");
+			const emoji = readStringParam(params, "emoji", { allowEmpty: true });
+			const remove = typeof params.remove === "boolean" ? params.remove : void 0;
+			const timestamp = parseStrictNonNegativeInteger(messageId);
+			if (timestamp === void 0) throw new Error(`Invalid messageId: ${messageId}. Expected numeric timestamp.`);
+			if (!emoji) throw new Error(`Emoji required to ${remove ? "remove" : "add"} reaction.`);
+			await (remove ? removeReactionSignal : sendReactionSignal)(target.recipient ?? "", timestamp, emoji, {
+				cfg,
+				accountId: account.accountId,
+				groupId: target.groupId,
+				targetAuthor,
+				targetAuthorUuid,
+				...assertDirectAdapterHandoff ? { assertDirectAdapterHandoff } : {}
+			});
+			return jsonResult({
+				ok: true,
+				[remove ? "removed" : "added"]: emoji
+			});
+		}
+		throw new Error(`Action ${action} not supported for ${providerId}.`);
+	}
+};
+//#endregion
 //#region extensions/signal/src/outbound-session.ts
 function resolveSignalOutboundTarget(target) {
 	const normalized = normalizeSignalMessagingTarget(target);
@@ -79,6 +367,219 @@ function resolveSignalOutboundTarget(target) {
 	};
 }
 //#endregion
+//#region extensions/signal/src/presentation-fallback.ts
+/** Materialize presentation content once before Signal's text-only delivery funnels. */
+function materializeSignalPresentationFallback(payload, presentationOverride) {
+	const reactionPayload = questionGatewayRuntime.prepareReactionPayloadForDelivery({
+		payload,
+		presentation: presentationOverride ?? payload.presentation
+	});
+	if (reactionPayload) return reactionPayload;
+	const presentation = presentationOverride ?? normalizeMessagePresentation(payload.presentation);
+	if (!presentation) return payload;
+	const currentText = payload.text?.trim() ?? "";
+	const fallbackPresentation = Boolean(getExecApprovalReplyMetadata(payload) && currentText) ? {
+		...presentation,
+		blocks: presentation.blocks.filter((block) => !isMessagePresentationInteractiveBlock(block))
+	} : presentation;
+	const presentationFallback = renderMessagePresentationFallbackText({ presentation: fallbackPresentation });
+	const text = currentText.includes(presentationFallback) ? currentText : [currentText, presentationFallback].filter(Boolean).join("\n\n");
+	const { presentation: _presentation, ...withoutPresentation } = payload;
+	return {
+		...withoutPresentation,
+		text
+	};
+}
+//#endregion
+//#region extensions/signal/src/reply-authors-state.ts
+const signalReplyAuthorState = {
+	memoryReplyContexts: /* @__PURE__ */ new Map(),
+	persistentStoreDisabled: false
+};
+//#endregion
+//#region extensions/signal/src/reply-authors.ts
+const PERSISTENT_NAMESPACE = "signal.reply-authors.v1";
+const PERSISTENT_MAX_ENTRIES = 5e3;
+const DEFAULT_REPLY_AUTHOR_TTL_MS = 6048e5;
+const { memoryReplyContexts } = signalReplyAuthorState;
+function openSignalReplyAuthorStore() {
+	if (signalReplyAuthorState.persistentStoreDisabled) return;
+	const runtime = getOptionalSignalRuntime();
+	try {
+		return runtime?.state.openKeyedStore({
+			namespace: PERSISTENT_NAMESPACE,
+			maxEntries: PERSISTENT_MAX_ENTRIES,
+			defaultTtlMs: DEFAULT_REPLY_AUTHOR_TTL_MS
+		});
+	} catch (error) {
+		signalReplyAuthorState.persistentStoreDisabled = true;
+		runtime?.logging.getChildLogger({
+			plugin: "signal",
+			feature: "reply-author-state"
+		}).warn("Signal persistent reply author state unavailable", { error: String(error) });
+		return;
+	}
+}
+function buildSignalReplyAuthorStoreKey(params) {
+	const conversationKey = normalizeSignalMessagingTarget(params.to);
+	const replyToId = normalizeOptionalString(params.replyToId);
+	if (!conversationKey || !replyToId) return;
+	return `account=${normalizeLowercaseStringOrEmpty(normalizeOptionalString(params.accountId) ?? DEFAULT_ACCOUNT_ID)}|to=${conversationKey}|id=${replyToId}`;
+}
+function pruneMemoryReplyContexts(now = Date.now()) {
+	for (const [key, record] of memoryReplyContexts) if (record.expiresAt <= now) memoryReplyContexts.delete(key);
+	while (memoryReplyContexts.size > PERSISTENT_MAX_ENTRIES) {
+		const oldestKey = memoryReplyContexts.keys().next().value;
+		if (!oldestKey) break;
+		memoryReplyContexts.delete(oldestKey);
+	}
+}
+function resolveReplyContext(record) {
+	if (!record) return;
+	if (record.kind === "ambiguous") return { ambiguous: true };
+	const author = normalizeOptionalString(record.author);
+	if (!author) return;
+	const body = normalizeOptionalString(record.body);
+	const media = record.media;
+	return {
+		author,
+		...body ? { body } : {},
+		...media?.length ? { media } : {}
+	};
+}
+function resolveSourceTimestamp(value) {
+	return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : Date.now();
+}
+function mergeReplyContext(current, next) {
+	if (!current) return next;
+	if (current.kind === "ambiguous") return current;
+	if (next.kind === "ambiguous") return next;
+	if (current.author !== next.author) {
+		const { author: _author, body: _body, media: _media, ...identity } = next;
+		return {
+			...identity,
+			kind: "ambiguous"
+		};
+	}
+	return next.sourceTimestamp >= current.sourceTimestamp ? next : current;
+}
+async function registerSignalReplyContext(params) {
+	const store = openSignalReplyAuthorStore();
+	const key = buildSignalReplyAuthorStoreKey(params);
+	const author = normalizeOptionalString(params.author);
+	const body = normalizeOptionalString(params.body);
+	const media = params.media?.map((entry) => ({
+		contentType: normalizeOptionalString(entry.contentType),
+		kind: entry.kind ?? void 0
+	}));
+	const conversationKey = normalizeSignalMessagingTarget(params.to);
+	const replyToId = normalizeOptionalString(params.replyToId);
+	const accountKey = normalizeLowercaseStringOrEmpty(normalizeOptionalString(params.accountId) ?? DEFAULT_ACCOUNT_ID);
+	const sourceTimestamp = resolveSourceTimestamp(params.sourceTimestamp);
+	if (!key || !author || !conversationKey || !replyToId) return;
+	const registeredAt = Date.now();
+	const record = {
+		kind: "resolved",
+		author,
+		...body ? { body } : {},
+		...media?.length ? { media } : {},
+		accountId: accountKey,
+		conversationKey,
+		replyToId,
+		sourceTimestamp,
+		registeredAt
+	};
+	const expiresAt = registeredAt + DEFAULT_REPLY_AUTHOR_TTL_MS;
+	const usesComparisons = Boolean(store?.observe && store.compareAndApply);
+	if (!store || !store.update && !usesComparisons) {
+		const next = mergeReplyContext(memoryReplyContexts.get(key), record);
+		memoryReplyContexts.set(key, {
+			...next,
+			expiresAt
+		});
+		pruneMemoryReplyContexts(registeredAt);
+		if (store) {
+			signalReplyAuthorState.persistentStoreDisabled = true;
+			getOptionalSignalRuntime()?.logging.getChildLogger({
+				plugin: "signal",
+				feature: "reply-author-state"
+			}).warn("Signal persistent reply author state lacks atomic updates");
+		}
+		return;
+	}
+	const cachedBeforeUpdate = memoryReplyContexts.get(key);
+	const cacheReplyContext = (next) => {
+		const current = memoryReplyContexts.get(key);
+		const changedDuringUpdate = usesComparisons && current !== cachedBeforeUpdate;
+		if (!next) {
+			if (!changedDuringUpdate) memoryReplyContexts.delete(key);
+			return;
+		}
+		const concurrent = changedDuringUpdate && current && current.expiresAt > registeredAt ? current : void 0;
+		memoryReplyContexts.set(key, {
+			...concurrent ? mergeReplyContext(concurrent, next) : next,
+			expiresAt: Math.max(expiresAt, concurrent?.expiresAt ?? expiresAt)
+		});
+	};
+	let updateEvaluated = false;
+	let nextRecord;
+	try {
+		let updated = false;
+		if (store.observe && store.compareAndApply) {
+			let observation = await store.observe(key);
+			for (;;) {
+				updateEvaluated = true;
+				nextRecord = mergeReplyContext(observation.value, record);
+				const result = await store.compareAndApply(key, observation.comparison, {
+					operation: "update",
+					action: "set",
+					value: nextRecord
+				});
+				if (result.status !== "conflict") {
+					updated = result.status === "applied";
+					break;
+				}
+				observation = result.current;
+			}
+		} else if (store.update) updated = await store.update(key, (current) => {
+			updateEvaluated = true;
+			nextRecord = mergeReplyContext(current, record);
+			return nextRecord;
+		});
+		cacheReplyContext(updated ? nextRecord : void 0);
+		pruneMemoryReplyContexts(registeredAt);
+	} catch (error) {
+		if (!updateEvaluated) try {
+			nextRecord = mergeReplyContext(await store.lookup(key), record);
+		} catch {
+			nextRecord = void 0;
+		}
+		if (nextRecord || updateEvaluated) cacheReplyContext(nextRecord);
+		pruneMemoryReplyContexts(registeredAt);
+		getOptionalSignalRuntime()?.logging.getChildLogger({
+			plugin: "signal",
+			feature: "reply-author-state"
+		}).warn("Signal persistent reply author state failed", { error: String(error) });
+	}
+}
+async function resolveSignalReplyContextWithPersistence(params) {
+	const store = openSignalReplyAuthorStore();
+	const key = buildSignalReplyAuthorStoreKey(params);
+	if (!key) return;
+	pruneMemoryReplyContexts();
+	const memoryContext = resolveReplyContext(memoryReplyContexts.get(key));
+	if (!store || memoryContext) return memoryContext;
+	try {
+		return resolveReplyContext(await store.lookup(key));
+	} catch (error) {
+		getOptionalSignalRuntime()?.logging.getChildLogger({
+			plugin: "signal",
+			feature: "reply-author-state"
+		}).warn("Signal persistent reply author lookup failed", { error: String(error) });
+		return;
+	}
+}
+//#endregion
 //#region extensions/signal/src/setup-transport.ts
 function managedTransportOptions(transport) {
 	const { kind: _kind, ...options } = transport;
@@ -173,23 +674,7 @@ function prepareSignalManagedNativeTransport(params) {
 		if (!normalizeOptionalString(accountConfig.account) && !accountConfig.transport) continue;
 		const accountPorts = portsByAccountId.get(normalizedAccountId) ?? /* @__PURE__ */ new Set();
 		portsByAccountId.set(normalizedAccountId, accountPorts);
-		const transport = accountConfig.transport;
-		if (transport?.kind === "managed-native") {
-			if (transport.socketPath !== void 0) continue;
-			if (transport.httpPort !== void 0) accountPorts.add(transport.httpPort);
-			else implicitManagedAccountIds.push(normalizedAccountId);
-			if (transport.url && !isSignalManagedNativeConnectionUrlForBind(transport)) {
-				const localConnectionPort = resolveLocalSignalTransportPort(transport.url);
-				if (localConnectionPort !== void 0) accountPorts.add(localConnectionPort);
-			}
-			continue;
-		}
-		if (transport?.kind === "external-native" || transport?.kind === "container") {
-			const localPort = resolveLocalSignalTransportPort(transport.url);
-			if (localPort !== void 0) accountPorts.add(localPort);
-			continue;
-		}
-		implicitManagedAccountIds.push(normalizedAccountId);
+		if (reserveSignalTransportPorts(accountConfig.transport, accountPorts)) implicitManagedAccountIds.push(normalizedAccountId);
 	}
 	const currentReservedPorts = /* @__PURE__ */ new Set();
 	for (const accountPorts of portsByAccountId.values()) for (const httpPort of accountPorts) currentReservedPorts.add(httpPort);
@@ -229,8 +714,8 @@ async function probeSignalTransport(params) {
 		overrides: managedTransportOptions(params.transport)
 	}) : params.transport;
 	const resolved = resolveSignalTransport(transport);
-	if (resolved.kind === "container") return (params.probeContainer ?? (await import("./transport-probes.runtime-WprAyBbL.mjs")).containerCheck)(resolved.baseUrl, timeoutMs, params.account);
-	return (params.probeNative ?? (await import("./transport-probes.runtime-WprAyBbL.mjs")).nativeCheck)(resolved.baseUrl, timeoutMs);
+	if (resolved.kind === "container") return (params.probeContainer ?? (await import("./transport-probes.runtime-DwXEHnXr.mjs")).containerCheck)(resolved.baseUrl, timeoutMs, params.account);
+	return (params.probeNative ?? (await import("./transport-probes.runtime-DwXEHnXr.mjs")).nativeCheck)(resolved.baseUrl, timeoutMs);
 }
 function writeSignalAccountTransport(params) {
 	const transport = normalizeTransport(params.transport);
@@ -347,9 +832,7 @@ function buildSignalSetupPatch(input) {
 		url: normalizeSignalTransportUrl(input.httpUrl)
 	} : input.cliPath || input.httpHost || input.httpPort ? {
 		kind: "managed-native",
-		...input.cliPath ? { cliPath: input.cliPath } : {},
-		...input.httpHost ? { httpHost: input.httpHost } : {},
-		...input.httpPort ? { httpPort: Number(input.httpPort) } : {}
+		...managedTransportOverridesFromSetupInput(input)
 	} : void 0;
 	return {
 		...account ? { account } : {},
@@ -442,11 +925,7 @@ function createSignalCliPathTextInput(shouldPrompt) {
 	return createCliPathTextInput({
 		inputKey: "cliPath",
 		message: "signal-cli path",
-		resolvePath: ({ cfg, accountId, credentialValues }) => resolveSignalCliPath({
-			cfg,
-			accountId,
-			credentialValues
-		}),
+		resolvePath: resolveSignalCliPath,
 		shouldPrompt
 	});
 }
@@ -489,7 +968,7 @@ const signalSetupAdapterBase = createPatchedAccountSetupAdapter({
 		if (!input.signalNumber && !input.httpUrl && !input.httpHost && !input.httpPort && !input.cliPath) return "Signal requires --signal-number or --http-url/--http-host/--http-port/--cli-path.";
 		return null;
 	} }),
-	buildPatch: (input) => buildSignalSetupPatch(input)
+	buildPatch: buildSignalSetupPatch
 });
 function restorePromotedSignalDefaultAccount(cfg) {
 	const signal = cfg.channels?.signal;
@@ -512,11 +991,7 @@ function restorePromotedSignalDefaultAccount(cfg) {
 const signalSetupAdapter = {
 	...signalSetupAdapterBase,
 	namedAccountPromotionKeys: [],
-	prepareAccountConfigInput: ({ cfg, accountId, input }) => prepareSignalSetupInput({
-		cfg,
-		accountId,
-		input
-	}),
+	prepareAccountConfigInput: prepareSignalSetupInput,
 	singleAccountKeysToMove: [
 		"signalNumber",
 		"account",
@@ -586,7 +1061,7 @@ function createSignalSetupWizardProxy(loadWizard) {
 const signalDoctor = {
 	normalizeCompatibilityConfig,
 	cleanStaleConfig: async ({ cfg }) => {
-		const { detectSignalTransport } = await import("./transport-detection.runtime-CW1lp2d9.mjs");
+		const { detectSignalTransport } = await import("./transport-detection-BVUDE42e.mjs").then((n) => n.n);
 		const transport = await migrateLegacySignalTransportConfig({
 			cfg,
 			detect: detectSignalTransport
@@ -600,16 +1075,13 @@ const signalDoctor = {
 //#endregion
 //#region extensions/signal/src/shared.ts
 const SIGNAL_CHANNEL = "signal";
-async function loadSignalChannelRuntime() {
-	return await import("./channel.runtime-Dqc18A1e.mjs");
-}
-const signalSetupWizard = createSignalSetupWizardProxy(async () => (await loadSignalChannelRuntime()).signalSetupWizard);
+const signalSetupWizard = createSignalSetupWizardProxy(async () => (await import("./setup-surface-Drt-4t3R.mjs")).signalSetupWizard);
 const signalConfigAdapter = {
 	...createScopedChannelConfigAdapter({
 		sectionKey: SIGNAL_CHANNEL,
-		listAccountIds: (cfg) => listSignalAccountIds(cfg),
-		resolveAccount: adaptScopedAccountAccessor((params) => resolveSignalAccount(params)),
-		defaultAccountId: (cfg) => resolveDefaultSignalAccountId(cfg),
+		listAccountIds: listSignalAccountIds,
+		resolveAccount: adaptScopedAccountAccessor(resolveSignalAccount),
+		defaultAccountId: resolveDefaultSignalAccountId,
 		clearBaseFields: [
 			"account",
 			"accountUuid",
@@ -617,8 +1089,7 @@ const signalConfigAdapter = {
 			"name"
 		],
 		resolveAllowFrom: (account) => account.config.allowFrom,
-		formatAllowFrom: (allowFrom) => normalizeStringifiedEntries(allowFrom).map((entry) => entry === "*" ? "*" : normalizeE164(entry.replace(/^signal:/i, ""))).filter(Boolean),
-		resolveDefaultTo: (account) => account.config.defaultTo
+		formatAllowFrom: (allowFrom) => normalizeStringifiedEntries(allowFrom).map((entry) => entry === "*" ? "*" : normalizeE164(entry.replace(/^signal:/i, ""))).filter(Boolean)
 	}),
 	resolveDefaultTo({ cfg, accountId }) {
 		const raw = resolveSignalAccount({
@@ -657,11 +1128,6 @@ function createSignalPluginBase(params) {
 			id: SIGNAL_CHANNEL,
 			meta: { ...getChatChannelMeta(SIGNAL_CHANNEL) },
 			setupWizard: params.setupWizard,
-			capabilities: {
-				chatTypes: ["direct", "group"],
-				media: true,
-				reactions: true
-			},
 			streaming: { blockStreamingCoalesceDefaults: {
 				minChars: 1500,
 				idleMs: 1e3
@@ -672,27 +1138,32 @@ function createSignalPluginBase(params) {
 			},
 			configSchema: SignalChannelConfigSchema,
 			doctor: signalDoctor,
-			config: {
-				...signalConfigAdapter,
-				isConfigured: (account) => account.configured,
-				describeAccount: (account) => describeAccountSnapshot({
-					account,
-					configured: account.configured,
-					extra: { baseUrl: account.baseUrl }
-				})
-			},
 			security: signalSecurityAdapter,
 			setupContract: params.setupContract
 		}),
+		capabilities: {
+			chatTypes: ["direct", "group"],
+			media: true,
+			reactions: true
+		},
+		config: {
+			...signalConfigAdapter,
+			isConfigured: (account) => account.configured,
+			describeAccount: (account) => describeAccountSnapshot({
+				account,
+				configured: account.configured,
+				extra: { baseUrl: account.baseUrl }
+			})
+		},
 		messaging: { defaultMarkdownTableMode: "bullets" }
 	};
 }
 //#endregion
 //#region extensions/signal/src/channel.ts
-const loadSignalMonitorModule = createLazyRuntimeModule(() => import("./monitor-DAMQw1pZ.mjs").then((n) => n.n));
-const loadSignalProbeModule = createLazyRuntimeModule(() => import("./probe-IKCS9D-z.mjs").then((n) => n.n));
-const loadSignalSendRuntime = createLazyRuntimeModule(() => import("./send.runtime-B7C4IP23.mjs"));
-const loadSignalApprovalReactionsModule = createLazyRuntimeModule(() => import("./approval-reactions-B25QoVJc.mjs").then((n) => n.n));
+const loadSignalMonitorModule = createLazyRuntimeModule(() => import("./monitor-BfwQr78f.mjs").then((n) => n.n));
+const loadSignalProbeModule = createLazyRuntimeModule(() => import("./probe-BYLzra6D.mjs").then((n) => n.n));
+const loadSignalSendRuntime = createLazyRuntimeModule(() => import("./send-DEjrbpIC.mjs").then((n) => n.i));
+const loadSignalApprovalReactionsModule = createLazyRuntimeModule(() => import("./approval-reactions-BKkjIAoi.mjs").then((n) => n.n));
 async function resolveSignalSendContext(params) {
 	return {
 		send: resolveOutboundSendDep(params.deps, "signal") ?? (await loadSignalSendRuntime()).sendMessageSignal,
@@ -711,14 +1182,8 @@ function resolveSignalSendTarget(params) {
 }
 async function sendSignalOutbound(params) {
 	const accountId = params.accountId ?? void 0;
-	const { send, maxBytes } = await resolveSignalSendContext({
-		...params,
-		accountId
-	});
-	const to = resolveSignalSendTarget({
-		...params,
-		accountId
-	});
+	const { send, maxBytes } = await resolveSignalSendContext(params);
+	const to = resolveSignalSendTarget(params);
 	const replyOptions = await resolveSignalReplyOptions({
 		cfg: params.cfg,
 		to,
@@ -737,26 +1202,25 @@ async function sendSignalOutbound(params) {
 		...replyOptions
 	});
 }
-function resolveSignalReplyOptions(params) {
+async function resolveSignalReplyOptions(params) {
 	const replyToId = normalizeOptionalString(params.replyToId);
-	if (!replyToId) return Promise.resolve({});
+	if (!replyToId) return {};
 	const accountId = resolveSignalAccount({
 		cfg: params.cfg,
 		accountId: params.accountId
 	}).accountId;
-	return resolveSignalReplyContextWithPersistence({
+	const persistedContext = await resolveSignalReplyContextWithPersistence({
 		accountId,
 		to: params.to,
 		replyToId
-	}).then((persistedContext) => {
-		const replyToAuthor = persistedContext?.ambiguous === true ? void 0 : persistedContext?.author;
-		const replyToBody = persistedContext?.ambiguous === true ? "" : [persistedContext?.body, formatSignalMediaText(persistedContext?.media ?? [])].filter(Boolean).join("\n");
-		return {
-			replyToId,
-			...replyToAuthor ? { replyToAuthor } : {},
-			...replyToBody ? { replyToBody } : {}
-		};
 	});
+	const replyToAuthor = persistedContext?.ambiguous === true ? void 0 : persistedContext?.author;
+	const replyToBody = persistedContext?.ambiguous === true ? "" : [persistedContext?.body, formatSignalMediaText(persistedContext?.media ?? [])].filter(Boolean).join("\n");
+	return {
+		replyToId,
+		...replyToAuthor ? { replyToAuthor } : {},
+		...replyToBody ? { replyToBody } : {}
+	};
 }
 function inferSignalTargetChatType(rawTo) {
 	let to = rawTo.trim();
@@ -791,19 +1255,14 @@ const signalMessageAdapter = defineChannelMessageAdapter({
 		media: sendSignalOutbound
 	}
 });
-function buildSignalBaseSessionKey(params) {
-	return buildOutboundBaseSessionKey({
-		...params,
-		channel: "signal"
-	});
-}
 function resolveSignalOutboundSessionRoute(params) {
 	const target = params.resolvedTarget?.to ?? params.target;
 	const resolved = resolveSignalOutboundTarget(target);
 	if (!resolved) return null;
 	const normalizedTarget = target.replace(/^signal:/i, "").trim();
 	const recipientSessionExact = resolved.chatType === "group" || /^\+?\d{3,15}$/.test(normalizedTarget) ? true : "direct-alias";
-	const baseSessionKey = buildSignalBaseSessionKey({
+	const baseSessionKey = buildOutboundBaseSessionKey({
+		channel: "signal",
 		cfg: params.cfg,
 		agentId: params.agentId,
 		accountId: params.accountId,
@@ -817,23 +1276,15 @@ function resolveSignalOutboundSessionRoute(params) {
 	};
 }
 async function sendFormattedSignalText(ctx) {
-	const { send, maxBytes } = await resolveSignalSendContext({
-		cfg: ctx.cfg,
-		accountId: ctx.accountId ?? void 0,
-		deps: ctx.deps
-	});
+	const { send, maxBytes } = await resolveSignalSendContext(ctx);
 	const limit = resolveTextChunkLimit(ctx.cfg, "signal", ctx.accountId ?? void 0, { fallbackLimit: 4e3 });
-	const to = resolveSignalSendTarget({
-		cfg: ctx.cfg,
-		accountId: ctx.accountId ?? void 0,
-		to: ctx.to
-	});
+	const to = resolveSignalSendTarget(ctx);
 	const tableMode = resolveMarkdownTableMode({
 		cfg: ctx.cfg,
 		channel: "signal",
 		accountId: ctx.accountId ?? void 0
 	});
-	let chunks = limit === void 0 ? markdownToSignalTextChunks(ctx.text, Number.POSITIVE_INFINITY, { tableMode }) : markdownToSignalTextChunks(ctx.text, limit, { tableMode });
+	let chunks = markdownToSignalTextChunks(ctx.text, limit ?? Number.POSITIVE_INFINITY, { tableMode });
 	if (chunks.length === 0 && ctx.text) chunks = [{
 		text: ctx.text,
 		styles: []
@@ -875,16 +1326,8 @@ async function sendFormattedSignalText(ctx) {
 }
 async function sendFormattedSignalMedia(ctx) {
 	ctx.abortSignal?.throwIfAborted();
-	const { send, maxBytes } = await resolveSignalSendContext({
-		cfg: ctx.cfg,
-		accountId: ctx.accountId ?? void 0,
-		deps: ctx.deps
-	});
-	const to = resolveSignalSendTarget({
-		cfg: ctx.cfg,
-		accountId: ctx.accountId ?? void 0,
-		to: ctx.to
-	});
+	const { send, maxBytes } = await resolveSignalSendContext(ctx);
+	const to = resolveSignalSendTarget(ctx);
 	const tableMode = resolveMarkdownTableMode({
 		cfg: ctx.cfg,
 		channel: "signal",
@@ -923,20 +1366,8 @@ async function registerDeliveredSignalApprovalPayloadForReactions(params) {
 	const targetAuthor = normalizeOptionalString(account.config.account);
 	const targetAuthorUuid = normalizeOptionalString(account.config.accountUuid);
 	if (!targetAuthor && !targetAuthorUuid) return;
-	const { registerSignalQuestionReactionTargetForDeliveredPayload } = await import("./question-reactions-DSNAD0cd.mjs").then((n) => n.n);
-	registerSignalQuestionReactionTargetForDeliveredPayload({
-		cfg: params.cfg,
-		target: {
-			...params.target,
-			accountId: account.accountId
-		},
-		payload: params.payload,
-		results: params.results,
-		targetAuthor,
-		targetAuthorUuid
-	});
-	const { registerSignalApprovalReactionTargetForDeliveredPayload } = await loadSignalApprovalReactionsModule();
-	await registerSignalApprovalReactionTargetForDeliveredPayload({
+	const { registerSignalReactionTargetsForDeliveredPayload } = await import("./reaction-targets-CEdyjtrC.mjs").then((n) => n.t);
+	await registerSignalReactionTargetsForDeliveredPayload({
 		cfg: params.cfg,
 		target: {
 			...params.target,
@@ -1007,7 +1438,7 @@ const signalPlugin = createChatChannelPlugin({
 			targetPrefixes: ["signal"],
 			normalizeTarget: normalizeSignalMessagingTarget,
 			inferTargetChatType: ({ to }) => inferSignalTargetChatType(to),
-			resolveOutboundSessionRoute: (params) => resolveSignalOutboundSessionRoute(params),
+			resolveOutboundSessionRoute: resolveSignalOutboundSessionRoute,
 			targetResolver: {
 				looksLikeId: looksLikeSignalTargetId,
 				hint: "<E.164|uuid:ID|group:ID|signal:group:ID|signal:+E.164>",
@@ -1123,7 +1554,7 @@ const signalPlugin = createChatChannelPlugin({
 	} },
 	security: signalSecurityAdapter,
 	threading: {
-		resolveReplyToMode: (params) => resolveSignalReplyToMode(params),
+		resolveReplyToMode: resolveSignalReplyToMode,
 		matchesToolContextTarget: ({ target, toolContext }) => {
 			const normalizedTarget = normalizeSignalMessagingTarget(target);
 			if (!normalizedTarget) return false;
@@ -1200,4 +1631,4 @@ const signalPlugin = createChatChannelPlugin({
 	}
 });
 //#endregion
-export { normalizeSignalAccountInput as a, signalNumberTextInput as c, probeSignalTransport as d, writeSignalAccountTransport as f, createSignalCliPathTextInput as i, signalSetupContract as l, createSignalPluginBase as n, signalCompletionNote as o, resolveSignalOutboundTarget as p, signalSetupWizard as r, signalDmPolicy as s, signalPlugin as t, prepareSignalManagedNativeTransport as u };
+export { resolveSignalReactionLevel as _, normalizeSignalAccountInput as a, markdownToSignalTextChunks as b, signalNumberTextInput as c, probeSignalTransport as d, writeSignalAccountTransport as f, signalMessageActions as g, resolveSignalOutboundTarget as h, createSignalCliPathTextInput as i, signalSetupContract as l, materializeSignalPresentationFallback as m, createSignalPluginBase as n, signalCompletionNote as o, registerSignalReplyContext as p, signalSetupWizard as r, signalDmPolicy as s, signalPlugin as t, prepareSignalManagedNativeTransport as u, formatSignalMediaText as v, isSignalNativeApprovalHandlerConfigured as x, markdownToSignalText as y };