@openclaw/signal 2026.7.1-beta.1 → 2026.7.1-beta.4

package/dist/{accounts-hOCHbEhX.js → accounts-Bz4HtP0g.js}

@@ -1,5 +1,5 @@
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { createAccountListHelpers, normalizeAccountId, resolveMergedAccountConfig } from "openclaw/plugin-sdk/account-resolution";
+import { createAccountListHelpers, normalizeAccountId, resolveAccountEntry, resolveMergedAccountConfig } from "openclaw/plugin-sdk/account-resolution";
 //#region extensions/signal/src/accounts.ts
 const { listAccountIds, resolveDefaultAccountId } = createAccountListHelpers("signal", { implicitDefaultAccount: { channelKeys: ["account"] } });
 const listSignalAccountIds = listAccountIds;
@@ -8,7 +8,8 @@ function mergeSignalAccountConfig(cfg, accountId) {
 	return resolveMergedAccountConfig({
 		channelConfig: cfg.channels?.signal,
 		accounts: cfg.channels?.signal?.accounts,
-		accountId
+		accountId,
+		nestedObjectKeys: ["aliases"]
 	});
 }
 function resolveSignalAccount(params) {
@@ -36,5 +37,23 @@ function listEnabledSignalAccounts(cfg) {
 		accountId
 	})).filter((account) => account.enabled);
 }
+function normalizeSignalReplyToMode(value) {
+	return value === "off" || value === "first" || value === "all" || value === "batched" ? value : void 0;
+}
+function resolveSignalReplyToMode(params) {
+	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultSignalAccountId(params.cfg));
+	const signalConfig = params.cfg.channels?.signal;
+	const accountConfig = resolveAccountEntry(signalConfig?.accounts, accountId);
+	const chatType = params.chatType === "direct" || params.chatType === "group" ? params.chatType : void 0;
+	if (chatType) {
+		const accountScoped = normalizeSignalReplyToMode(accountConfig?.replyToModeByChatType?.[chatType]);
+		if (accountScoped) return accountScoped;
+		const accountDefault = normalizeSignalReplyToMode(accountConfig?.replyToMode);
+		if (accountDefault) return accountDefault;
+		const channelScoped = normalizeSignalReplyToMode(signalConfig?.replyToModeByChatType?.[chatType]);
+		if (channelScoped) return channelScoped;
+	}
+	return normalizeSignalReplyToMode(accountConfig?.replyToMode) ?? normalizeSignalReplyToMode(signalConfig?.replyToMode) ?? "all";
+}
 //#endregion
-export { resolveSignalAccount as i, listSignalAccountIds as n, resolveDefaultSignalAccountId as r, listEnabledSignalAccounts as t };
+export { resolveSignalReplyToMode as a, resolveSignalAccount as i, listSignalAccountIds as n, resolveDefaultSignalAccountId as r, listEnabledSignalAccounts as t };

package/dist/api.js

@@ -1,12 +1,12 @@
-import { i as resolveSignalAccount, n as listSignalAccountIds, r as resolveDefaultSignalAccountId, t as listEnabledSignalAccounts } from "./accounts-hOCHbEhX.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, u as looksLikeSignalTargetId } from "./identity-B6O4k8xg.js";
-import { i as markdownToSignalTextChunks, n as resolveSignalReactionLevel, r as markdownToSignalText, t as signalMessageActions } from "./message-actions-BnugYXjB.js";
-import { n as sendReactionSignal, t as removeReactionSignal } from "./reaction-runtime-api-BRJCLiqK.js";
-import { a as normalizeSignalAccountInput, l as signalSetupAdapter, n as createSignalPluginBase, r as signalSetupWizard, t as signalPlugin, u as resolveSignalOutboundTarget } from "./channel-aQhurb0Z.js";
-import { a as looksLikeArchive, n as extractSignalCliArchive, o as pickAsset, r as installSignalCli } from "./install-signal-cli-TwhJ0DGy.js";
-import { t as monitorSignalProvider } from "./monitor-C1gdgT7W.js";
-import { n as sendReadReceiptSignal, r as sendTypingSignal, t as sendMessageSignal } from "./send-De6LIOLq.js";
-import { t as probeSignal } from "./probe-BvFJLOBi.js";
+import { i as resolveSignalAccount, n as listSignalAccountIds, r as resolveDefaultSignalAccountId, t as listEnabledSignalAccounts } 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, u as looksLikeSignalTargetId } from "./identity-C8-yk4J9.js";
+import { i as markdownToSignalTextChunks, n as resolveSignalReactionLevel, r as markdownToSignalText, t as signalMessageActions } from "./message-actions-3OLDgjis.js";
+import { n as sendReactionSignal, t as removeReactionSignal } from "./reaction-runtime-api-EQ7cc7-Y.js";
+import { a as normalizeSignalAccountInput, l as signalSetupAdapter, n as createSignalPluginBase, r as signalSetupWizard, t as signalPlugin, u as resolveSignalOutboundTarget } from "./channel-Cnhy1RwG.js";
+import { a as looksLikeArchive, n as extractSignalCliArchive, o as pickAsset, r as installSignalCli } from "./install-signal-cli-ik8VPaGg.js";
+import { t as monitorSignalProvider } from "./monitor-Bee8O5Ay.js";
+import { n as sendReadReceiptSignal, r as sendTypingSignal, t as sendMessageSignal } from "./send-CUJy6WPt.js";
+import { t as probeSignal } from "./probe-Cnht8Ihg.js";
 //#region extensions/signal/src/channel.setup.ts
 const signalSetupPlugin = { ...createSignalPluginBase({
 	setupWizard: signalSetupWizard,

package/dist/approval-auth-CsHNcAiy.js

@@ -0,0 +1,151 @@
+import { i as resolveSignalAccount } from "./accounts-Bz4HtP0g.js";
+import { d as normalizeSignalMessagingTarget, l as looksLikeUuid, u as looksLikeSignalTargetId } from "./identity-C8-yk4J9.js";
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { createResolvedApproverActionAuthAdapter, resolveApprovalApprovers } from "openclaw/plugin-sdk/approval-auth-runtime";
+import { normalizeE164 } from "openclaw/plugin-sdk/text-utility-runtime";
+//#region extensions/signal/src/aliases.ts
+function normalizeAliasKey(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return;
+	return normalizeLowercaseStringOrEmpty(/^signal:/i.test(trimmed) ? trimmed.slice(7).trim() : trimmed) || void 0;
+}
+function resolveAliasMap(params) {
+	const account = resolveSignalAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	const aliases = /* @__PURE__ */ new Map();
+	for (const [rawKey, rawValue] of Object.entries(account.config.aliases ?? {})) {
+		const key = normalizeAliasKey(rawKey);
+		if (!key) continue;
+		aliases.set(key, rawValue);
+	}
+	return aliases;
+}
+function resolveTargetKind(target) {
+	return normalizeLowercaseStringOrEmpty(target).startsWith("group:") ? "group" : "user";
+}
+function resolveRawSignalTarget(input) {
+	const normalized = normalizeSignalMessagingTarget(input);
+	if (!normalized || !looksLikeSignalTargetId(input, normalized)) return null;
+	return {
+		to: normalized,
+		kind: resolveTargetKind(normalized)
+	};
+}
+function resolveSignalAliasTargetFromMap(params) {
+	const initialAlias = normalizeAliasKey(params.input);
+	if (!initialAlias || !params.aliases.has(initialAlias)) return null;
+	const visited = /* @__PURE__ */ new Set();
+	let alias = initialAlias;
+	for (;;) {
+		if (visited.has(alias)) throw new Error(`Signal alias "${initialAlias}" resolves recursively through "${alias}".`);
+		visited.add(alias);
+		const rawValue = params.aliases.get(alias);
+		if (typeof rawValue !== "string" || !rawValue.trim()) throw new Error(`Signal alias "${alias}" must point to a non-empty Signal target.`);
+		const rawTarget = resolveRawSignalTarget(rawValue);
+		if (rawTarget) return {
+			...rawTarget,
+			alias: initialAlias
+		};
+		const nextAlias = normalizeAliasKey(rawValue);
+		if (nextAlias && params.aliases.has(nextAlias)) {
+			alias = nextAlias;
+			continue;
+		}
+		throw new Error(`Signal alias "${initialAlias}" must point to an E.164 number, uuid:<id>, username:<name>, or group:<id>.`);
+	}
+}
+function resolveSignalAliasTarget(params) {
+	return resolveSignalAliasTargetFromMap({
+		aliases: resolveAliasMap(params),
+		input: params.input
+	});
+}
+function resolveSignalTarget(params) {
+	const rawTarget = resolveRawSignalTarget(params.input);
+	if (rawTarget) return {
+		...rawTarget,
+		source: "raw"
+	};
+	const aliasTarget = resolveSignalAliasTarget(params);
+	if (aliasTarget) return {
+		...aliasTarget,
+		source: "alias"
+	};
+	return null;
+}
+function listSignalAliasDirectoryEntries(params) {
+	const aliases = resolveAliasMap(params);
+	const query = normalizeLowercaseStringOrEmpty(params.query);
+	const limit = typeof params.limit === "number" && params.limit > 0 ? params.limit : void 0;
+	const exactAlias = params.query ? normalizeAliasKey(params.query) : void 0;
+	if (exactAlias && aliases.has(exactAlias)) {
+		const target = resolveSignalAliasTargetFromMap({
+			aliases,
+			input: exactAlias
+		});
+		if (target?.kind === params.kind) return [{
+			kind: params.kind,
+			id: target.to,
+			name: target.alias
+		}];
+		if (target) return [];
+	}
+	const entries = [];
+	for (const alias of aliases.keys()) {
+		let target;
+		try {
+			target = resolveSignalAliasTargetFromMap({
+				aliases,
+				input: alias
+			});
+		} catch {
+			continue;
+		}
+		if (!target) continue;
+		if (target.kind !== params.kind) continue;
+		if (query && !alias.includes(query) && !normalizeLowercaseStringOrEmpty(target.to).includes(query)) continue;
+		entries.push({
+			kind: params.kind,
+			id: target.to,
+			name: alias
+		});
+		if (typeof limit === "number" && entries.length >= limit) break;
+	}
+	return entries;
+}
+//#endregion
+//#region extensions/signal/src/approval-auth.ts
+function normalizeSignalApproverId(value) {
+	const normalized = normalizeSignalMessagingTarget(String(value));
+	if (!normalized || normalized.startsWith("group:") || normalized.startsWith("username:")) return;
+	if (looksLikeUuid(normalized)) return `uuid:${normalized}`;
+	const e164 = normalizeE164(normalized);
+	return e164.length > 1 ? e164 : void 0;
+}
+function getSignalApprovalApprovers(params) {
+	const account = resolveSignalAccount(params).config;
+	let defaultTo = account.defaultTo;
+	if (typeof account.defaultTo === "string") try {
+		defaultTo = resolveSignalTarget({
+			cfg: params.cfg,
+			accountId: params.accountId,
+			input: account.defaultTo
+		})?.to ?? account.defaultTo;
+	} catch {
+		defaultTo = account.defaultTo;
+	}
+	return resolveApprovalApprovers({
+		allowFrom: account.allowFrom,
+		defaultTo,
+		normalizeApprover: normalizeSignalApproverId
+	});
+}
+const signalApprovalAuth = createResolvedApproverActionAuthAdapter({
+	channelLabel: "Signal",
+	resolveApprovers: getSignalApprovalApprovers,
+	normalizeSenderId: (value) => normalizeSignalApproverId(value)
+});
+//#endregion
+export { resolveSignalTarget as i, signalApprovalAuth as n, listSignalAliasDirectoryEntries as r, getSignalApprovalApprovers as t };

package/dist/{approval-handler.runtime-C4S7IAvt.js → approval-handler.runtime-DDQ4ZRyc.js}

@@ -1,6 +1,8 @@
-import { d as normalizeSignalMessagingTarget } from "./identity-B6O4k8xg.js";
-import { a as registerSignalApprovalReactionTarget, c as resolveSignalApprovalTargetAuthorKeys, l as unregisterSignalApprovalReactionTarget, r as hasSignalApprovalReactionApprovers, s as resolveSignalApprovalConversationKey } from "./approval-reactions-H-RPGBK7.js";
-import { r as sendTypingSignal, t as sendMessageSignal } from "./send-De6LIOLq.js";
+import { r as resolveDefaultSignalAccountId } from "./accounts-Bz4HtP0g.js";
+import { d as normalizeSignalMessagingTarget } from "./identity-C8-yk4J9.js";
+import { i as resolveSignalTarget } from "./approval-auth-CsHNcAiy.js";
+import { d as unregisterSignalApprovalReactionTarget, i as hasSignalApprovalReactionApprovers, l as resolveSignalApprovalConversationKey, o as registerSignalApprovalReactionTarget, u as resolveSignalApprovalTargetAuthorKeys } from "./approval-reactions-UFmUPD0A.js";
+import { r as sendTypingSignal, t as sendMessageSignal } from "./send-CUJy6WPt.js";
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { buildChannelApprovalNativeTargetKey } from "openclaw/plugin-sdk/approval-native-runtime";
@@ -49,8 +51,28 @@ const signalApprovalNativeRuntime = createChannelApprovalNativeRuntimeAdapter({
 		})
 	},
 	transport: {
-		prepareTarget: ({ plannedTarget, accountId, context }) => {
-			const to = normalizeSignalMessagingTarget(plannedTarget.target.to);
+		prepareTarget: ({ cfg, plannedTarget, accountId, context }) => {
+			const plannedAccountId = plannedTarget.target.accountId;
+			const explicitAccountId = resolvePreparedApprovalAccountId({
+				plannedAccountId,
+				contextAccountId: accountId
+			});
+			const preparedAccountId = resolvePreparedApprovalAccountId({
+				plannedAccountId,
+				contextAccountId: accountId,
+				fallbackAccountId: cfg ? resolveDefaultSignalAccountId(cfg) : DEFAULT_ACCOUNT_ID
+			});
+			const rawTo = plannedTarget.target.to;
+			let to = normalizeSignalMessagingTarget(rawTo);
+			if (cfg) try {
+				to = resolveSignalTarget({
+					cfg,
+					accountId: explicitAccountId,
+					input: rawTo
+				})?.to ?? to;
+			} catch {
+				return null;
+			}
 			if (!to) return null;
 			const runtimeContext = readSignalApprovalRuntimeContext(context);
 			const targetAuthorKeys = resolveSignalApprovalTargetAuthorKeys({
@@ -59,11 +81,7 @@ const signalApprovalNativeRuntime = createChannelApprovalNativeRuntimeAdapter({
 			});
 			const prepared = {
 				to,
-				accountId: resolvePreparedApprovalAccountId({
-					plannedAccountId: plannedTarget.target.accountId,
-					contextAccountId: accountId,
-					fallbackAccountId: DEFAULT_ACCOUNT_ID
-				}),
+				accountId: preparedAccountId,
 				...runtimeContext.baseUrl ? { baseUrl: runtimeContext.baseUrl } : {},
 				...runtimeContext.account ? { account: runtimeContext.account } : {},
 				...runtimeContext.accountUuid ? { accountUuid: runtimeContext.accountUuid } : {},

package/dist/{approval-reactions-H-RPGBK7.js → approval-reactions-UFmUPD0A.js}

@@ -1,9 +1,10 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { d as normalizeSignalMessagingTarget, l as looksLikeUuid } from "./identity-B6O4k8xg.js";
-import { c as getSignalApprovalApprovers, l as signalApprovalAuth } from "./message-actions-BnugYXjB.js";
+import { d as normalizeSignalMessagingTarget, l as looksLikeUuid } from "./identity-C8-yk4J9.js";
+import { i as resolveSignalTarget, n as signalApprovalAuth, t as getSignalApprovalApprovers } from "./approval-auth-CsHNcAiy.js";
+import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { buildApprovalReactionHint, createApprovalReactionTargetStore, listApprovalReactionBindings, resolveApprovalReactionTarget } from "openclaw/plugin-sdk/approval-reaction-runtime";
+import { addApprovalReactionHintToText, buildApprovalReactionHint, createApprovalReactionTargetStore, hasApprovalReactionHintText, listApprovalReactionBindings, resolveApprovalReactionTarget } from "openclaw/plugin-sdk/approval-reaction-runtime";
 import { normalizeE164 } from "openclaw/plugin-sdk/text-utility-runtime";
 import { matchesApprovalRequestFilters } from "openclaw/plugin-sdk/approval-client-runtime";
 import { getExecApprovalReplyMetadata } from "openclaw/plugin-sdk/approval-reply-runtime";
@@ -18,13 +19,14 @@ const { setRuntime: setSignalRuntime, getRuntime: getSignalRuntime, tryGetRuntim
 var approval_reactions_exports = /* @__PURE__ */ __exportAll({
 	addSignalApprovalReactionHintToStructuredPayload: () => addSignalApprovalReactionHintToStructuredPayload,
 	addSignalApprovalReactionHintToText: () => addSignalApprovalReactionHintToText,
+	appendSignalApprovalReactionHintForOutboundMessage: () => appendSignalApprovalReactionHintForOutboundMessage,
 	buildSignalApprovalReactionHint: () => buildSignalApprovalReactionHint,
 	clearSignalApprovalReactionTargetsForTest: () => clearSignalApprovalReactionTargetsForTest,
 	hasSignalApprovalReactionApprovers: () => hasSignalApprovalReactionApprovers,
-	listSignalApprovalReactionBindings: () => listSignalApprovalReactionBindings,
 	maybeResolveSignalApprovalReaction: () => maybeResolveSignalApprovalReaction,
 	registerSignalApprovalReactionTarget: () => registerSignalApprovalReactionTarget,
 	registerSignalApprovalReactionTargetForDeliveredPayload: () => registerSignalApprovalReactionTargetForDeliveredPayload,
+	registerSignalApprovalReactionTargetForOutboundMessage: () => registerSignalApprovalReactionTargetForOutboundMessage,
 	resolveSignalApprovalConversationKey: () => resolveSignalApprovalConversationKey,
 	resolveSignalApprovalReactionTargetWithPersistence: () => resolveSignalApprovalReactionTargetWithPersistence,
 	resolveSignalApprovalTargetAuthorKeys: () => resolveSignalApprovalTargetAuthorKeys,
@@ -33,7 +35,7 @@ var approval_reactions_exports = /* @__PURE__ */ __exportAll({
 const PERSISTENT_NAMESPACE = "signal.approval-reactions.v2";
 const PERSISTENT_MAX_ENTRIES = 1e3;
 const DEFAULT_REACTION_TARGET_TTL_MS = 1440 * 60 * 1e3;
-let resolverRuntimePromise;
+const resolverRuntimeLoader = createLazyRuntimeModule(() => import("./approval-resolver-BR0MioAA.js"));
 const signalApprovalReactionTargets = createApprovalReactionTargetStore({
 	namespace: PERSISTENT_NAMESPACE,
 	maxEntries: PERSISTENT_MAX_ENTRIES,
@@ -42,10 +44,7 @@ const signalApprovalReactionTargets = createApprovalReactionTargetStore({
 	logPersistentError: reportPersistentApprovalReactionError,
 	readPersistedTarget
 });
-function loadApprovalResolver() {
-	resolverRuntimePromise ??= import("./approval-resolver-BR0MioAA.js");
-	return resolverRuntimePromise;
-}
+const loadApprovalResolver = resolverRuntimeLoader;
 function resolveApprovalKindFromId(approvalId) {
 	return approvalId.startsWith("plugin:") ? "plugin" : "exec";
 }
@@ -78,10 +77,25 @@ function targetAccountMatches(params) {
 	const routeAccountId = normalizeOptionalString(params.routeAccountId);
 	return Boolean(routeAccountId && normalizeAccountId(routeAccountId) === normalizeAccountId(configuredAccountId));
 }
+function resolveSignalApprovalRouteTarget(params) {
+	try {
+		return resolveSignalTarget({
+			cfg: params.cfg,
+			accountId: params.accountId,
+			input: params.to
+		})?.to ?? normalizeSignalMessagingTarget(params.to) ?? null;
+	} catch {
+		return null;
+	}
+}
 function hasMatchingSignalApprovalReactionTarget(params) {
 	return (params.config.targets ?? []).some((target) => {
 		if (normalizeLowercaseStringOrEmpty(target.channel) !== "signal") return false;
-		const configuredTo = normalizeSignalMessagingTarget(target.to);
+		const configuredTo = resolveSignalApprovalRouteTarget({
+			cfg: params.cfg,
+			accountId: target.accountId ?? params.route.accountId,
+			to: target.to
+		});
 		if (!configuredTo || configuredTo !== params.route.to) return false;
 		return targetAccountMatches({
 			routeAccountId: params.route.accountId,
@@ -100,6 +114,7 @@ function isSignalApprovalReactionRouteStillEnabled(params) {
 		config,
 		route: params.target.route
 	}) && hasMatchingSignalApprovalReactionTarget({
+		cfg: params.cfg,
 		config,
 		route: params.target.route
 	});
@@ -112,6 +127,17 @@ function isSignalApprovalReactionRouteStillEnabled(params) {
 function resolveSignalApprovalConversationKey(to) {
 	return normalizeSignalMessagingTarget(to) ?? null;
 }
+function resolveSignalApprovalConversationKeyForDeliveredTarget(params) {
+	try {
+		return resolveSignalTarget({
+			cfg: params.cfg,
+			accountId: params.accountId,
+			input: params.to
+		})?.to ?? resolveSignalApprovalConversationKey(params.to);
+	} catch {
+		return resolveSignalApprovalConversationKey(params.to);
+	}
+}
 function normalizeSignalApprovalTargetAuthorKey(value) {
 	const normalized = normalizeOptionalString(value);
 	if (!normalized) return null;
@@ -173,29 +199,53 @@ function listSignalApprovalReactionBindings(allowedDecisions) {
 function buildSignalApprovalReactionHint(allowedDecisions) {
 	return buildApprovalReactionHint({ allowedDecisions });
 }
-function insertSignalApprovalReactionHintNearHeader(params) {
-	const lines = params.text.split(/\r?\n/);
-	const idLineIndex = lines.findIndex((line) => /^ID:\s*\S+/.test(line.trim()));
-	if (idLineIndex >= 0) {
-		const before = lines.slice(0, idLineIndex + 1).join("\n");
-		const after = lines.slice(idLineIndex + 1).join("\n").replace(/^\n+/, "");
-		return after ? `${before}\n\n${params.hint}\n\n${after}` : `${before}\n\n${params.hint}`;
-	}
-	return `${params.hint}\n\n${params.text}`;
-}
 function addSignalApprovalReactionHintToText(params) {
-	if (hasSignalApprovalReactionHintText(params.text)) return params.text;
-	const hint = buildSignalApprovalReactionHint(params.allowedDecisions);
-	return hint ? insertSignalApprovalReactionHintNearHeader({
-		text: params.text,
-		hint
-	}) : params.text;
-}
-function hasSignalApprovalReactionHintText(text) {
-	return /(^|\n)React with:\s*(\n|$)/i.test(text ?? "");
+	return addApprovalReactionHintToText(params);
+}
+function resolveStandaloneApprovalPromptKind(text) {
+	const firstLine = text.split(/\r?\n/).map((line) => line.trim()).find(Boolean);
+	if (/^(?:🔒\s*)?Exec approval required$/.test(firstLine ?? "")) return "exec";
+	if (/^(?:(?:🛡️|🛡|🚨|ℹ️|ℹ)\s*)?Plugin approval required$/.test(firstLine ?? "")) return "plugin";
+	return null;
+}
+function isStandaloneApprovalPromptText(text) {
+	return resolveStandaloneApprovalPromptKind(text) !== null;
+}
+function normalizeApprovalDecision(value) {
+	const normalized = value.trim().toLowerCase();
+	if (normalized === "always") return "allow-always";
+	if (normalized === "allow-once" || normalized === "allow-always" || normalized === "deny") return normalized;
+	return null;
+}
+const APPROVAL_ID_LINE_RE = /^\s*ID:\s*([A-Za-z0-9][A-Za-z0-9._:-]*)\s*$/i;
+const APPROVE_REPLY_COMMAND_LINE_RE = /^\s*Reply with:\s*\/approve(?:@[^\s]+)?\s+([A-Za-z0-9][A-Za-z0-9._:-]*)\s+(.+)$/i;
+function extractSignalApprovalPromptBinding(text) {
+	const lines = text.split(/\r?\n/);
+	const idHeaderMatch = lines.map((line) => line.match(APPROVAL_ID_LINE_RE)).find((match) => Boolean(match));
+	if (!idHeaderMatch) return null;
+	const approvalId = idHeaderMatch[1];
+	const approvalKind = resolveStandaloneApprovalPromptKind(text) ?? resolveApprovalKindFromId(approvalId);
+	const allowedDecisions = [];
+	for (const line of lines) {
+		const match = line.match(APPROVE_REPLY_COMMAND_LINE_RE);
+		if (!match || match[1] !== approvalId) continue;
+		for (const decisionText of match[2].split(/[\s|,]+/)) {
+			const decision = normalizeApprovalDecision(decisionText);
+			if (decision && !allowedDecisions.includes(decision)) allowedDecisions.push(decision);
+		}
+	}
+	return allowedDecisions.length > 0 ? {
+		approvalId,
+		approvalKind,
+		allowedDecisions
+	} : null;
 }
 function buildTargetRoute(params) {
-	const to = normalizeSignalMessagingTarget(params.to);
+	const to = resolveSignalApprovalRouteTarget({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		to: params.to
+	});
 	if (!to) return null;
 	const route = {
 		deliveryMode: "target",
@@ -212,6 +262,36 @@ function buildTargetRoute(params) {
 		}
 	}) ? route : null;
 }
+function shouldAppendSignalApprovalReactionHintForOutboundMessage(params) {
+	const binding = extractSignalApprovalPromptBinding(params.text);
+	if (!binding) return false;
+	if (resolveSignalApprovalTargetAuthorKeys(params).length === 0) return false;
+	if (!hasSignalApprovalReactionApprovers({
+		cfg: params.cfg,
+		accountId: params.accountId
+	})) return false;
+	return Boolean(buildTargetRoute({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		to: params.to,
+		approvalId: binding.approvalId,
+		approvalKind: binding.approvalKind,
+		agentId: params.agentId,
+		sessionKey: params.sessionKey
+	}));
+}
+function appendSignalApprovalReactionHintForOutboundMessage(params) {
+	if (!isStandaloneApprovalPromptText(params.text)) return params.text;
+	const binding = extractSignalApprovalPromptBinding(params.text);
+	if (!binding || !shouldAppendSignalApprovalReactionHintForOutboundMessage({
+		...params,
+		text: params.text
+	})) return params.text;
+	return addSignalApprovalReactionHintToText({
+		text: params.text,
+		allowedDecisions: binding.allowedDecisions
+	});
+}
 function hasSignalApprovalReactionApprovers(params) {
 	return getSignalApprovalApprovers(params).length > 0;
 }
@@ -269,8 +349,7 @@ function addSignalApprovalReactionHintToStructuredPayload(params) {
 	};
 }
 function readSignalDeliveryVisibleText(result) {
-	const meta = result.meta;
-	const visibleText = meta?.signalVisibleText ?? meta?.visibleText;
+	const visibleText = result.meta?.signalVisibleText ?? result.meta?.visibleText;
 	return typeof visibleText === "string" ? visibleText : null;
 }
 function listDeliveredSignalMessageIdsWithVisibleHint(params) {
@@ -278,19 +357,23 @@ function listDeliveredSignalMessageIdsWithVisibleHint(params) {
 	const resultsWithVisibleText = signalResults.filter((result) => readSignalDeliveryVisibleText(result) !== null);
 	const candidates = resultsWithVisibleText.length > 0 ? resultsWithVisibleText : signalResults;
 	if (resultsWithVisibleText.length === 0 && candidates.length !== 1) return [];
-	const ids = candidates.filter((result) => resultsWithVisibleText.length > 0 ? hasSignalApprovalReactionHintText(readSignalDeliveryVisibleText(result)) : hasSignalApprovalReactionHintText(params.payload.text)).map((result) => normalizeOptionalString(result.messageId)).filter((messageId) => Boolean(messageId && messageId !== "unknown"));
+	const ids = candidates.filter((result) => resultsWithVisibleText.length > 0 ? hasApprovalReactionHintText(readSignalDeliveryVisibleText(result)) : hasApprovalReactionHintText(params.payload.text)).map((result) => normalizeOptionalString(result.messageId)).filter((messageId) => Boolean(messageId && messageId !== "unknown"));
 	return Array.from(new Set(ids));
 }
 function registerSignalApprovalReactionTargetForDeliveredPayload(params) {
 	if (normalizeLowercaseStringOrEmpty(params.target.channel) !== "signal") return false;
 	const metadata = getExecApprovalReplyMetadata(params.payload);
 	if (!metadata?.allowedDecisions || metadata.allowedDecisions.length === 0) return false;
-	if (!hasSignalApprovalReactionHintText(params.payload.text)) return false;
+	if (!hasApprovalReactionHintText(params.payload.text)) return false;
 	if (!hasSignalApprovalReactionApprovers({
 		cfg: params.cfg,
 		accountId: params.target.accountId
 	})) return false;
-	const conversationKey = resolveSignalApprovalConversationKey(params.target.to);
+	const conversationKey = resolveSignalApprovalConversationKeyForDeliveredTarget({
+		cfg: params.cfg,
+		accountId: params.target.accountId,
+		to: params.target.to
+	});
 	if (!conversationKey) return false;
 	const route = buildTargetRoute({
 		cfg: params.cfg,
@@ -322,6 +405,41 @@ function registerSignalApprovalReactionTargetForDeliveredPayload(params) {
 	})) || registered;
 	return registered;
 }
+function registerSignalApprovalReactionTargetForOutboundMessage(params) {
+	if (!isStandaloneApprovalPromptText(params.text)) return false;
+	const binding = extractSignalApprovalPromptBinding(params.text);
+	if (!binding) return false;
+	if (!hasSignalApprovalReactionApprovers({
+		cfg: params.cfg,
+		accountId: params.accountId
+	})) return false;
+	const targetAuthorKeys = resolveSignalApprovalTargetAuthorKeys(params);
+	if (targetAuthorKeys.length === 0) return false;
+	const conversationKey = resolveSignalApprovalConversationKey(params.to);
+	if (!conversationKey) return false;
+	const route = buildTargetRoute({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		to: params.to,
+		approvalId: binding.approvalId,
+		approvalKind: binding.approvalKind,
+		agentId: params.agentId,
+		sessionKey: params.sessionKey
+	});
+	if (!route) return false;
+	return Boolean(registerSignalApprovalReactionTarget({
+		accountId: params.accountId,
+		conversationKey,
+		messageId: params.messageId,
+		approvalId: binding.approvalId,
+		approvalKind: binding.approvalKind,
+		allowedDecisions: binding.allowedDecisions,
+		targetAuthorKeys,
+		route,
+		routeAllowed: true,
+		ttlMs: params.ttlMs
+	}));
+}
 function unregisterSignalApprovalReactionTarget(params) {
 	const key = buildReactionTargetKey(params);
 	if (!key) return;
@@ -420,7 +538,7 @@ async function maybeResolveSignalApprovalReaction(params) {
 }
 function clearSignalApprovalReactionTargetsForTest() {
 	signalApprovalReactionTargets.clearForTest();
-	resolverRuntimePromise = void 0;
+	resolverRuntimeLoader.clear();
 }
 //#endregion
-export { registerSignalApprovalReactionTarget as a, resolveSignalApprovalTargetAuthorKeys as c, maybeResolveSignalApprovalReaction as i, unregisterSignalApprovalReactionTarget as l, approval_reactions_exports as n, registerSignalApprovalReactionTargetForDeliveredPayload as o, hasSignalApprovalReactionApprovers as r, resolveSignalApprovalConversationKey as s, addSignalApprovalReactionHintToStructuredPayload as t, setSignalRuntime as u };
+export { maybeResolveSignalApprovalReaction as a, registerSignalApprovalReactionTargetForOutboundMessage as c, unregisterSignalApprovalReactionTarget as d, setSignalRuntime as f, hasSignalApprovalReactionApprovers as i, resolveSignalApprovalConversationKey as l, appendSignalApprovalReactionHintForOutboundMessage as n, registerSignalApprovalReactionTarget as o, approval_reactions_exports as r, registerSignalApprovalReactionTargetForDeliveredPayload as s, addSignalApprovalReactionHintToStructuredPayload as t, resolveSignalApprovalTargetAuthorKeys as u };