@openclaw/signal 2026.7.2-beta.7 → 2026.7.33

package/dist/{channel-CmbWaYlm.js → .setup/channel-DKzsFvG5.mjs}

@@ -1,44 +1,37 @@
-import { a as isSignalManagedNativeConnectionUrlForBind, i as assignSignalManagedNativePort, l as normalizeSignalTransportHost, o as isValidSignalManagedNativePort, r as allocateSignalManagedNativePort, s as resolveLocalSignalTransportPort, u as normalizeSignalTransportUrl } from "./transport-policy-DxvSMHp9.js";
-import { a as resolveSignalAccountConfig, i as resolveSignalAccount, n as listSignalAccountIds, o as resolveSignalReplyToMode, r as resolveDefaultSignalAccountId, s as resolveSignalTransport } from "./accounts-DrStJjiK.js";
-import { c as resolveSignalSender, d as normalizeSignalMessagingTarget, l as looksLikeUuid, o as resolveSignalPeerId, s as resolveSignalRecipient, u as looksLikeSignalTargetId } from "./identity-BQ4OzXXk.js";
-import { a as listSignalAliasDirectoryEntries, o as resolveSignalTarget } from "./runtime-JPrGlV7h.js";
-import { a as signalMessageActions, d as shouldSuppressLocalSignalExecApprovalPrompt, f as signalApprovalCapability, i as materializeSignalPresentationFallback, l as markdownToSignalTextChunks, o as resolveSignalReactionLevel, r as resolveSignalReplyContextWithPersistence, s as formatSignalMediaText, t as detectSignalTransport } from "./transport-detection-Da06-LOL.js";
-import { i as migrateLegacySignalTransportConfig, n as normalizeCompatibilityConfig, r as clearLegacySignalTransportFieldsForAccount } from "./doctor-contract-api-Dcte-QYB.js";
-import { t as SignalChannelConfigSchema } from "./config-schema-Y3dFGwdL.js";
+import { a as resolveSignalReplyToMode, i as resolveSignalAccount, n as listSignalAccountIds, r as resolveDefaultSignalAccountId } from "./accounts-Bz4HtP0g.mjs";
+import { c as resolveSignalSender, d as normalizeSignalMessagingTarget, l as looksLikeUuid, o as resolveSignalPeerId, s as resolveSignalRecipient, u as looksLikeSignalTargetId } from "./identity-C8-yk4J9.mjs";
+import { i as resolveSignalTarget, r as listSignalAliasDirectoryEntries } from "./approval-auth-CKMusyZI.mjs";
+import { i as markdownToSignalTextChunks, n as resolveSignalReactionLevel, o as shouldSuppressLocalSignalExecApprovalPrompt, s as signalApprovalCapability, t as signalMessageActions } from "./message-actions-Cplx3XNC.mjs";
+import { t as SignalChannelConfigSchema } from "./config-schema-BQRy2Glu.mjs";
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
 import { buildDmGroupAccountAllowlistAdapter } from "openclaw/plugin-sdk/allowlist-config-edit";
 import { createChatChannelPlugin } from "openclaw/plugin-sdk/channel-core";
-import { createReplyToFanout, defineChannelMessageAdapter, resolveOutboundSendDep } from "openclaw/plugin-sdk/channel-outbound";
+import { defineChannelMessageAdapter, resolveOutboundSendDep } from "openclaw/plugin-sdk/channel-outbound";
 import { createPairingPrefixStripper } from "openclaw/plugin-sdk/channel-pairing";
 import { attachChannelToResult } from "openclaw/plugin-sdk/channel-send-result";
 import { PAIRING_APPROVED_MESSAGE } from "openclaw/plugin-sdk/channel-status";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
 import { resolveChannelMediaMaxBytes } from "openclaw/plugin-sdk/media-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 { normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeStringifiedEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { sanitizeAssistantVisibleText } from "openclaw/plugin-sdk/text-chunking";
-import { normalizeAccountId as normalizeAccountId$1, resolveAccountEntry } from "openclaw/plugin-sdk/account-resolution";
 import { normalizeE164 } from "openclaw/plugin-sdk/text-utility-runtime";
 import { createChannelPluginBase, getChatChannelMeta } from "openclaw/plugin-sdk/core";
-import { parseAllowFromEntries } from "openclaw/plugin-sdk/allow-from";
-import { createChannelDmPolicy } from "openclaw/plugin-sdk/channel-dm-policy";
-import { defineChannelSetupContract } from "openclaw/plugin-sdk/channel-setup";
-import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$2, createCliPathTextInput, createDelegatedSetupWizardProxy, createDelegatedTextInputShouldPrompt, createPatchedAccountSetupAdapter, createSetupInputPresenceValidator, createSetupTranslator, patchChannelConfigForAccount, promptParsedAllowFromForAccount, setAccountAllowFromForChannel, setSetupChannelEnabled } from "openclaw/plugin-sdk/setup-runtime";
+import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1, createCliPathTextInput, createDelegatedSetupWizardProxy, createDelegatedTextInputShouldPrompt, createPatchedAccountSetupAdapter, createSetupInputPresenceValidator, createSetupTranslator, mergeAllowFromEntries, parseSetupEntriesAllowingWildcard, patchChannelConfigForAccount, promptParsedAllowFromForAccount, setAccountAllowFromForChannel, setSetupChannelEnabled } from "openclaw/plugin-sdk/setup-runtime";
 import { formatCliCommand, formatDocsLink } from "openclaw/plugin-sdk/setup-tools";
 import { describeAccountSnapshot } from "openclaw/plugin-sdk/account-helpers";
 import { adaptScopedAccountAccessor, createScopedChannelConfigAdapter } from "openclaw/plugin-sdk/channel-config-helpers";
 import { createRestrictSendersChannelSecurity } from "openclaw/plugin-sdk/channel-policy";
 //#region extensions/signal/src/outbound-session.ts
 function resolveSignalOutboundTarget(target) {
-	const normalized = normalizeSignalMessagingTarget(target);
-	if (!normalized) return null;
-	const lowered = normalizeLowercaseStringOrEmpty(normalized);
+	const stripped = target.replace(/^signal:/i, "").trim();
+	const lowered = normalizeLowercaseStringOrEmpty(stripped);
 	if (lowered.startsWith("group:")) {
-		const groupId = normalized.slice(6);
+		const groupId = stripped.slice(6).trim();
+		if (!groupId) return null;
 		return {
 			peer: {
 				kind: "group",
@@ -49,16 +42,10 @@ function resolveSignalOutboundTarget(target) {
 			to: `group:${groupId}`
 		};
 	}
-	if (lowered.startsWith("username:")) return {
-		peer: {
-			kind: "direct",
-			id: normalized
-		},
-		chatType: "direct",
-		from: `signal:${normalized}`,
-		to: `signal:${normalized}`
-	};
-	const recipient = normalized;
+	let recipient = stripped.trim();
+	if (lowered.startsWith("username:")) recipient = stripped.slice(9).trim();
+	else if (lowered.startsWith("u:")) recipient = stripped.slice(2).trim();
+	if (!recipient) return null;
 	const uuidCandidate = normalizeLowercaseStringOrEmpty(recipient).startsWith("uuid:") ? recipient.slice(5) : recipient;
 	const sender = resolveSignalSender({
 		sourceUuid: looksLikeUuid(uuidCandidate) ? uuidCandidate : null,
@@ -77,221 +64,9 @@ function resolveSignalOutboundTarget(target) {
 	};
 }
 //#endregion
-//#region extensions/signal/src/setup-transport.ts
-function managedTransportOptions(transport) {
-	const { kind: _kind, ...options } = transport;
-	return options;
-}
-function normalizeTransport(transport) {
-	if (transport.kind === "managed-native") return {
-		...transport,
-		...transport.url ? { url: normalizeSignalTransportUrl(transport.url) } : {},
-		...transport.httpHost ? { httpHost: normalizeSignalTransportHost(transport.httpHost) } : {}
-	};
-	return {
-		...transport,
-		url: normalizeSignalTransportUrl(transport.url)
-	};
-}
-function assertSignalContainerTransportHasAccount(params) {
-	if (params.transport.kind !== "container" || params.cfg.channels?.signal?.enabled === false) return;
-	const account = resolveSignalAccountConfig(params.cfg, normalizeAccountId$1(params.accountId));
-	if (account.enabled === false || normalizeOptionalString(account.account)) return;
-	throw new Error("Signal container transport requires an account number for an enabled account.");
-}
-function assertSignalLocalEndpointDoesNotConflictWithManagedSibling(params) {
-	if (params.transport.kind === "managed-native") return;
-	const localPort = resolveLocalSignalTransportPort(params.transport.url);
-	if (localPort === void 0) return;
-	const targetAccountId = normalizeAccountId$1(params.accountId);
-	for (const accountId of listSignalAccountIds(params.cfg)) {
-		if (normalizeAccountId$1(accountId) === targetAccountId) continue;
-		if (resolveAccountEntry(params.cfg.channels?.signal?.accounts, accountId)?.enabled === false) continue;
-		const siblingAccount = resolveSignalAccount({
-			cfg: params.cfg,
-			accountId
-		});
-		if (!siblingAccount.configured) continue;
-		const siblingTransport = siblingAccount.transport;
-		if (siblingTransport?.kind !== "managed-native" || siblingTransport.httpPort !== localPort) continue;
-		throw new Error(`Signal ${params.transport.kind} account "${targetAccountId}" uses local port ${localPort}, which conflicts with managed native account "${accountId}". Choose a distinct transport URL.`);
-	}
-}
-function resolveConfiguredSignalTransport(cfg, accountId) {
-	const signal = cfg.channels?.signal;
-	const normalizedAccountId = normalizeAccountId$1(accountId);
-	return normalizedAccountId === DEFAULT_ACCOUNT_ID$2 ? signal?.transport ?? resolveAccountEntry(signal?.accounts, normalizedAccountId)?.transport : resolveAccountEntry(signal?.accounts, normalizedAccountId)?.transport;
-}
-function alignManagedConnectionUrlAfterBindChange(params) {
-	if (params.hasUrlOverride || !params.existing?.url || !isSignalManagedNativeConnectionUrlForBind(params.existing)) return assignSignalManagedNativePort(params.prepared, params.httpPort);
-	const connectionUrl = new URL(params.existing.url);
-	connectionUrl.port = String(params.httpPort);
-	const alignedPortUrl = normalizeSignalTransportUrl(connectionUrl.toString());
-	const next = {
-		...params.prepared,
-		url: alignedPortUrl,
-		httpPort: params.httpPort
-	};
-	if (isSignalManagedNativeConnectionUrlForBind(next)) return next;
-	const bindHost = params.prepared.httpHost ?? "127.0.0.1";
-	const connectionHost = bindHost === "0.0.0.0" ? "127.0.0.1" : bindHost === "::" ? "::1" : bindHost;
-	connectionUrl.hostname = connectionHost.includes(":") ? `[${connectionHost}]` : connectionHost;
-	return {
-		...next,
-		url: normalizeSignalTransportUrl(connectionUrl.toString())
-	};
-}
-function prepareSignalManagedNativeTransport(params) {
-	const existing = resolveConfiguredSignalTransport(params.cfg, params.accountId);
-	const existingManaged = existing?.kind === "managed-native" ? existing : void 0;
-	const preferredPort = params.overrides?.httpPort ?? existingManaged?.httpPort;
-	const prepared = {
-		kind: "managed-native",
-		...existingManaged,
-		...params.overrides,
-		httpHost: params.overrides?.httpHost ?? existingManaged?.httpHost ?? "127.0.0.1"
-	};
-	const portsByAccountId = /* @__PURE__ */ new Map();
-	const implicitManagedAccountIds = [];
-	for (const accountId of listSignalAccountIds(params.cfg)) {
-		const normalizedAccountId = normalizeAccountId$1(accountId);
-		const accountConfig = resolveSignalAccountConfig(params.cfg, accountId);
-		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.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);
-	}
-	const currentReservedPorts = /* @__PURE__ */ new Set();
-	for (const accountPorts of portsByAccountId.values()) for (const httpPort of accountPorts) currentReservedPorts.add(httpPort);
-	for (const accountId of implicitManagedAccountIds) {
-		const accountPorts = portsByAccountId.get(accountId);
-		if (!accountPorts) continue;
-		const httpPort = allocateSignalManagedNativePort({ reservedPorts: currentReservedPorts });
-		currentReservedPorts.add(httpPort);
-		accountPorts.add(httpPort);
-	}
-	const targetAccountId = normalizeAccountId$1(params.accountId);
-	const reservedPorts = /* @__PURE__ */ new Set();
-	for (const [accountId, accountPorts] of portsByAccountId) {
-		if (accountId === targetAccountId) continue;
-		for (const httpPort of accountPorts) reservedPorts.add(httpPort);
-	}
-	if (prepared.url && (params.overrides?.url !== void 0 ? !isSignalManagedNativeConnectionUrlForBind(prepared) : Boolean(existingManaged?.url && !isSignalManagedNativeConnectionUrlForBind(existingManaged))) && prepared.url) {
-		const localConnectionPort = resolveLocalSignalTransportPort(prepared.url);
-		if (localConnectionPort !== void 0) reservedPorts.add(localConnectionPort);
-	}
-	if (params.overrides?.httpPort !== void 0 && reservedPorts.has(params.overrides.httpPort)) throw new Error(`Signal managed native port ${params.overrides.httpPort} is already reserved by another account or local transport endpoint.`);
-	return alignManagedConnectionUrlAfterBindChange({
-		existing: existingManaged,
-		prepared,
-		httpPort: allocateSignalManagedNativePort({
-			reservedPorts,
-			preferredPort
-		}),
-		hasUrlOverride: params.overrides?.url !== void 0
-	});
-}
-async function probeSignalTransport(params) {
-	const timeoutMs = params.timeoutMs ?? 1e4;
-	const resolved = resolveSignalTransport(params.transport.kind === "managed-native" ? prepareSignalManagedNativeTransport({
-		cfg: params.cfg,
-		accountId: params.accountId,
-		overrides: managedTransportOptions(params.transport)
-	}) : params.transport);
-	if (resolved.kind === "container") return (params.probeContainer ?? (await import("./transport-probes.runtime-CV6Qs0Og.js")).containerCheck)(resolved.baseUrl, timeoutMs, params.account);
-	return (params.probeNative ?? (await import("./transport-probes.runtime-CV6Qs0Og.js")).nativeCheck)(resolved.baseUrl, timeoutMs);
-}
-function writeSignalAccountTransport(params) {
-	const transport = normalizeTransport(params.transport);
-	assertSignalContainerTransportHasAccount({
-		cfg: params.cfg,
-		accountId: params.accountId,
-		transport
-	});
-	assertSignalLocalEndpointDoesNotConflictWithManagedSibling({
-		cfg: params.cfg,
-		accountId: params.accountId,
-		transport
-	});
-	const canonical = clearLegacySignalTransportFieldsForAccount({
-		cfg: patchChannelConfigForAccount({
-			cfg: params.cfg,
-			channel: "signal",
-			accountId: params.accountId,
-			patch: { transport }
-		}),
-		accountId: params.accountId
-	});
-	if (transport.kind === "managed-native") resolveSignalAccount({
-		cfg: canonical,
-		accountId: params.accountId
-	});
-	return canonical;
-}
-//#endregion
 //#region extensions/signal/src/setup-core.ts
 const t = createSetupTranslator();
 const channel = "signal";
-const signalSetupFields = {
-	signalNumber: {
-		kind: "string",
-		cli: {
-			flags: "--signal-number <e164>",
-			description: "Signal account number (E.164)"
-		}
-	},
-	signalTransport: {
-		kind: "choice",
-		choices: ["external-native", "container"],
-		cli: {
-			flags: "--signal-transport <kind>",
-			description: "Signal HTTP transport (external-native or container)"
-		}
-	},
-	cliPath: {
-		kind: "string",
-		cli: {
-			flags: "--cli-path <path>",
-			description: "signal-cli executable path"
-		}
-	},
-	httpUrl: {
-		kind: "string",
-		cli: {
-			flags: "--http-url <url>",
-			description: "Signal HTTP service URL"
-		}
-	},
-	httpHost: {
-		kind: "string",
-		cli: {
-			flags: "--http-host <host>",
-			description: "Signal HTTP daemon host"
-		}
-	},
-	httpPort: {
-		kind: "string",
-		cli: {
-			flags: "--http-port <port>",
-			description: "Signal HTTP daemon port"
-		}
-	}
-};
 const MIN_E164_DIGITS = 5;
 const MAX_E164_DIGITS = 15;
 const DIGITS_ONLY = /^\d+$/;
@@ -311,7 +86,7 @@ function isUuidLike(value) {
 	return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
 }
 function parseSignalAllowFromEntries(raw) {
-	return parseAllowFromEntries(raw, (entry) => {
+	return parseSetupEntriesAllowingWildcard(raw, (entry) => {
 		if (normalizeLowercaseStringOrEmpty(entry).startsWith("uuid:")) {
 			const id = entry.slice(5).trim();
 			if (!id) return { error: "Invalid uuid entry" };
@@ -324,53 +99,14 @@ function parseSignalAllowFromEntries(raw) {
 	});
 }
 function buildSignalSetupPatch(input) {
-	const transport = input.httpUrl ? {
-		kind: input.signalTransport ?? "external-native",
-		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) } : {}
-	} : void 0;
 	return {
 		...input.signalNumber ? { account: input.signalNumber } : {},
-		...transport ? { transport } : {}
-	};
-}
-async function prepareSignalSetupInput(params) {
-	if (!params.input.httpUrl || params.input.signalTransport) return params.input;
-	const account = normalizeSignalAccountInput(params.input.signalNumber) ?? normalizeSignalAccountInput(resolveSignalSetupAccount({
-		cfg: params.cfg,
-		accountId: params.accountId
-	})) ?? void 0;
-	try {
-		const detected = await detectSignalTransport({
-			url: params.input.httpUrl,
-			...account ? { account } : {}
-		});
-		return {
-			...params.input,
-			signalTransport: detected.kind === "container" ? "container" : "external-native"
-		};
-	} catch {
-		const existing = resolveConfiguredSignalTransport(params.cfg, params.accountId);
-		if (existing?.kind === "container" || existing?.kind === "external-native") return params.input;
-		throw new Error("Signal could not detect the HTTP transport; start the endpoint or pass --signal-transport external-native|container.");
-	}
-}
-function managedTransportOverridesFromSetupInput(input) {
-	return {
 		...input.cliPath ? { cliPath: input.cliPath } : {},
+		...input.httpUrl ? { httpUrl: input.httpUrl } : {},
 		...input.httpHost ? { httpHost: input.httpHost } : {},
 		...input.httpPort ? { httpPort: Number(input.httpPort) } : {}
 	};
 }
-function resolveSignalSetupAccount(params) {
-	const accountId = normalizeAccountId$1(params.accountId ?? resolveDefaultSignalAccountId(params.cfg));
-	const signal = params.cfg.channels?.signal;
-	return resolveAccountEntry(signal?.accounts, accountId)?.account ?? signal?.account;
-}
 async function promptSignalAllowFrom(params) {
 	return promptParsedAllowFromForAccount({
 		cfg: params.cfg,
@@ -397,28 +133,45 @@ async function promptSignalAllowFrom(params) {
 			cfg,
 			channel,
 			accountId,
-			allowFrom,
-			setupSurface: signalSetupAdapter
+			allowFrom
 		})
 	});
 }
-const signalDmPolicy = createChannelDmPolicy({
+const signalDmPolicy = {
 	label: "Signal",
 	channel,
-	resolveAccount: (cfg, accountId) => resolveSignalAccount({
+	policyKey: "channels.signal.dmPolicy",
+	allowFromKey: "channels.signal.allowFrom",
+	resolveConfigKeys: (cfg, accountId) => (accountId ?? resolveDefaultSignalAccountId(cfg)) !== DEFAULT_ACCOUNT_ID$1 ? {
+		policyKey: `channels.signal.accounts.${accountId ?? resolveDefaultSignalAccountId(cfg)}.dmPolicy`,
+		allowFromKey: `channels.signal.accounts.${accountId ?? resolveDefaultSignalAccountId(cfg)}.allowFrom`
+	} : {
+		policyKey: "channels.signal.dmPolicy",
+		allowFromKey: "channels.signal.allowFrom"
+	},
+	getCurrent: (cfg, accountId) => resolveSignalAccount({
 		cfg,
 		accountId: accountId ?? resolveDefaultSignalAccountId(cfg)
+	}).config.dmPolicy ?? "pairing",
+	setPolicy: (cfg, policy, accountId) => patchChannelConfigForAccount({
+		cfg,
+		channel,
+		accountId: accountId ?? resolveDefaultSignalAccountId(cfg),
+		patch: policy === "open" ? {
+			dmPolicy: "open",
+			allowFrom: mergeAllowFromEntries(resolveSignalAccount({
+				cfg,
+				accountId: accountId ?? resolveDefaultSignalAccountId(cfg)
+			}).config.allowFrom, ["*"])
+		} : { dmPolicy: policy }
 	}),
-	setupSurface: () => signalSetupAdapter,
 	promptAllowFrom: promptSignalAllowFrom
-});
+};
 function resolveSignalCliPath(params) {
-	const transport = resolveSignalAccount({
+	return (typeof params.credentialValues.cliPath === "string" ? params.credentialValues.cliPath : void 0) ?? resolveSignalAccount({
 		cfg: params.cfg,
 		accountId: params.accountId
-	}).transport;
-	if (transport.kind !== "managed-native") return;
-	return typeof params.credentialValues.cliPath === "string" ? params.credentialValues.cliPath : transport.cliPath;
+	}).config.cliPath ?? "signal-cli";
 }
 function createSignalCliPathTextInput(shouldPrompt) {
 	return createCliPathTextInput({
@@ -452,94 +205,14 @@ const signalCompletionNote = {
 		`Docs: ${formatDocsLink("/signal", "signal")}`
 	]
 };
-const signalSetupAdapterBase = createPatchedAccountSetupAdapter({
+const signalSetupAdapter = createPatchedAccountSetupAdapter({
 	channelKey: channel,
-	validateInput: createSetupInputPresenceValidator({ validate: ({ cfg, accountId, input }) => {
-		if (input.signalTransport && input.signalTransport !== "external-native" && input.signalTransport !== "container") return "Signal --signal-transport must be external-native or container.";
-		if (input.signalTransport && !input.httpUrl) return "Signal --signal-transport requires --http-url.";
-		if (input.httpPort !== void 0 && !isValidSignalManagedNativePort(Number(input.httpPort))) return "Signal --http-port must be an integer between 1 and 65535.";
-		if (input.httpHost) try {
-			normalizeSignalTransportHost(input.httpHost);
-		} catch {
-			return "Signal --http-host must be a hostname or IP address.";
-		}
-		if (input.signalTransport === "container" && !normalizeSignalAccountInput(input.signalNumber) && !normalizeSignalAccountInput(resolveSignalSetupAccount({
-			cfg,
-			accountId
-		}))) return "Signal container transport requires --signal-number or an existing account.";
+	validateInput: createSetupInputPresenceValidator({ validate: ({ input }) => {
 		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)
 });
-function restorePromotedSignalDefaultAccount(cfg) {
-	const signal = cfg.channels?.signal;
-	const promoted = signal?.accounts?.[DEFAULT_ACCOUNT_ID$2];
-	if (!signal?.transport || signal.account || !promoted?.account) return cfg;
-	const { account, transport: _shadowedTransport, ...remainingDefault } = promoted;
-	const accounts = { ...signal.accounts };
-	if (Object.keys(remainingDefault).length === 0) delete accounts[DEFAULT_ACCOUNT_ID$2];
-	else accounts[DEFAULT_ACCOUNT_ID$2] = remainingDefault;
-	return {
-		...cfg,
-		channels: {
-			...cfg.channels,
-			signal: {
-				...signal,
-				account,
-				accounts
-			}
-		}
-	};
-}
-const signalSetupAdapter = {
-	...signalSetupAdapterBase,
-	prepareAccountConfigInput: ({ cfg, accountId, input }) => prepareSignalSetupInput({
-		cfg,
-		accountId,
-		input
-	}),
-	singleAccountKeysToMove: [
-		"signalNumber",
-		"account",
-		"cliPath",
-		"httpUrl",
-		"httpHost",
-		"httpPort"
-	],
-	applyAccountConfig: (params) => {
-		const accountId = normalizeAccountId$1(params.accountId);
-		const cfg = restorePromotedSignalDefaultAccount(params.cfg);
-		const previousTransport = resolveConfiguredSignalTransport(cfg, accountId);
-		const next = signalSetupAdapterBase.applyAccountConfig?.({
-			...params,
-			cfg,
-			accountId
-		}) ?? cfg;
-		const configuredTransport = resolveConfiguredSignalTransport(next, accountId);
-		if (configuredTransport && configuredTransport.kind !== "managed-native") return writeSignalAccountTransport({
-			cfg: next,
-			accountId,
-			transport: params.input.httpUrl && !params.input.signalTransport && (previousTransport?.kind === "container" || previousTransport?.kind === "external-native") ? {
-				...configuredTransport,
-				kind: previousTransport.kind
-			} : configuredTransport
-		});
-		return writeSignalAccountTransport({
-			cfg: next,
-			accountId,
-			transport: prepareSignalManagedNativeTransport({
-				cfg,
-				accountId,
-				overrides: managedTransportOverridesFromSetupInput(params.input)
-			})
-		});
-	}
-};
-const signalSetupContract = defineChannelSetupContract({
-	fields: signalSetupFields,
-	adapter: signalSetupAdapter
-});
 function createSignalSetupWizardProxy(loadWizard) {
 	return createDelegatedSetupWizardProxy({
 		channel,
@@ -564,22 +237,10 @@ function createSignalSetupWizardProxy(loadWizard) {
 	});
 }
 //#endregion
-//#region extensions/signal/src/doctor.ts
-const signalDoctor = {
-	normalizeCompatibilityConfig,
-	cleanStaleConfig: async ({ cfg }) => {
-		const { detectSignalTransport } = await import("./transport-detection.runtime-D_190UUL.js");
-		return await migrateLegacySignalTransportConfig({
-			cfg,
-			detect: detectSignalTransport
-		});
-	}
-};
-//#endregion
 //#region extensions/signal/src/shared.ts
 const SIGNAL_CHANNEL = "signal";
 async function loadSignalChannelRuntime() {
-	return await import("./channel.runtime-BRDaqr5-.js");
+	return await import("./channel.runtime-jVmVayf_.mjs");
 }
 const signalSetupWizard = createSignalSetupWizardProxy(async () => (await loadSignalChannelRuntime()).signalSetupWizard);
 const signalConfigAdapter = {
@@ -590,8 +251,11 @@ const signalConfigAdapter = {
 		defaultAccountId: (cfg) => resolveDefaultSignalAccountId(cfg),
 		clearBaseFields: [
 			"account",
-			"accountUuid",
-			"transport",
+			"configPath",
+			"httpUrl",
+			"httpHost",
+			"httpPort",
+			"cliPath",
 			"name"
 		],
 		resolveAllowFrom: (account) => account.config.allowFrom,
@@ -645,7 +309,6 @@ function createSignalPluginBase(params) {
 			} },
 			reload: { configPrefixes: ["channels.signal"] },
 			configSchema: SignalChannelConfigSchema,
-			doctor: signalDoctor,
 			config: {
 				...signalConfigAdapter,
 				isConfigured: (account) => account.configured,
@@ -656,17 +319,17 @@ function createSignalPluginBase(params) {
 				})
 			},
 			security: signalSecurityAdapter,
-			setupContract: params.setupContract
+			setup: params.setup
 		}),
 		messaging: { defaultMarkdownTableMode: "bullets" }
 	};
 }
 //#endregion
 //#region extensions/signal/src/channel.ts
-const loadSignalMonitorModule = createLazyRuntimeModule(() => import("./monitor-BvIzkrYW.js").then((n) => n.n));
-const loadSignalProbeModule = createLazyRuntimeModule(() => import("./probe-Br9abaGp.js").then((n) => n.n));
-const loadSignalSendRuntime = createLazyRuntimeModule(() => import("./send.runtime-CbuXycZT.js"));
-const loadSignalApprovalReactionsModule = createLazyRuntimeModule(() => import("./approval-reactions-DtL47gSK.js").then((n) => n.r));
+const loadSignalMonitorModule = createLazyRuntimeModule(() => import("./monitor-CZUTeDiv.mjs").then((n) => n.n));
+const loadSignalProbeModule = createLazyRuntimeModule(() => import("./probe-BXmpsFzO.mjs").then((n) => n.n));
+const loadSignalSendRuntime = createLazyRuntimeModule(() => import("./send.runtime-DqumNf6-.mjs"));
+const loadSignalApprovalReactionsModule = createLazyRuntimeModule(() => import("./approval-reactions-DoY1BVpl.mjs").then((n) => n.r));
 async function resolveSignalSendContext(params) {
 	return {
 		send: resolveOutboundSendDep(params.deps, "signal") ?? (await loadSignalSendRuntime()).sendMessageSignal,
@@ -686,54 +349,15 @@ function resolveSignalSendTarget(params) {
 }
 async function sendSignalOutbound(params) {
 	const { send, maxBytes } = await resolveSignalSendContext(params);
-	const to = resolveSignalSendTarget(params);
-	const replyOptions = await resolveSignalReplyOptions({
-		cfg: params.cfg,
-		to,
-		accountId: params.accountId,
-		replyToId: params.replyToId
-	});
-	return await send(to, params.text, {
+	return await send(resolveSignalSendTarget(params), params.text, {
 		cfg: params.cfg,
 		...params.mediaUrl ? { mediaUrl: params.mediaUrl } : {},
 		...params.mediaLocalRoots?.length ? { mediaLocalRoots: params.mediaLocalRoots } : {},
 		...params.mediaReadFile ? { mediaReadFile: params.mediaReadFile } : {},
 		maxBytes,
-		accountId: params.accountId ?? void 0,
-		...replyOptions
+		accountId: params.accountId ?? void 0
 	});
 }
-function resolveSignalReplyOptions(params) {
-	const replyToId = normalizeOptionalString(params.replyToId);
-	if (!replyToId) return Promise.resolve({});
-	const accountId = resolveSignalAccount({
-		cfg: params.cfg,
-		accountId: params.accountId
-	}).accountId;
-	return 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 } : {}
-		};
-	});
-}
-function inferSignalTargetChatType(rawTo) {
-	let to = rawTo.trim();
-	if (!to) return;
-	if (/^signal:/i.test(to)) to = to.replace(/^signal:/i, "").trim();
-	if (!to) return;
-	const lower = normalizeLowercaseStringOrEmpty(to);
-	if (lower.startsWith("group:")) return "group";
-	if (lower.startsWith("username:") || lower.startsWith("u:")) return "direct";
-	return "direct";
-}
 function attachSignalVisibleText(result, visibleText) {
 	const meta = "meta" in result && result.meta && typeof result.meta === "object" ? result.meta : {};
 	return {
@@ -756,8 +380,7 @@ const signalMessageAdapter = defineChannelMessageAdapter({
 			to: ctx.to,
 			text: ctx.text,
 			accountId: ctx.accountId ?? void 0,
-			deps: ctx.deps,
-			replyToId: ctx.replyToId ?? void 0
+			deps: ctx.deps
 		}),
 		media: async (ctx) => await sendSignalOutbound({
 			cfg: ctx.cfg,
@@ -767,11 +390,20 @@ const signalMessageAdapter = defineChannelMessageAdapter({
 			mediaLocalRoots: ctx.mediaLocalRoots,
 			mediaReadFile: ctx.mediaReadFile,
 			accountId: ctx.accountId ?? void 0,
-			deps: ctx.deps,
-			replyToId: ctx.replyToId ?? void 0
+			deps: ctx.deps
 		})
 	}
 });
+function inferSignalTargetChatType(rawTo) {
+	let to = rawTo.trim();
+	if (!to) return;
+	if (/^signal:/i.test(to)) to = to.replace(/^signal:/i, "").trim();
+	if (!to) return;
+	const lower = normalizeLowercaseStringOrEmpty(to);
+	if (lower.startsWith("group:")) return "group";
+	if (lower.startsWith("username:") || lower.startsWith("u:")) return "direct";
+	return "direct";
+}
 function buildSignalBaseSessionKey(params) {
 	return buildOutboundBaseSessionKey({
 		...params,
@@ -819,33 +451,17 @@ async function sendFormattedSignalText(ctx) {
 		text: ctx.text,
 		styles: []
 	}];
-	const nextReplyToId = createReplyToFanout({
-		replyToId: ctx.replyToId,
-		replyToIdSource: ctx.replyToIdSource,
-		replyToMode: ctx.replyToMode ?? resolveSignalReplyToMode({
-			cfg: ctx.cfg,
-			accountId: ctx.accountId,
-			chatType: inferSignalTargetChatType(to)
-		})
-	});
 	const results = [];
 	for (const chunk of chunks) {
 		ctx.abortSignal?.throwIfAborted();
-		const replyToId = nextReplyToId();
-		const replyOptions = await resolveSignalReplyOptions({
-			cfg: ctx.cfg,
-			to,
-			accountId: ctx.accountId,
-			replyToId
-		});
-		const deliveryResult = attachChannelToResult("signal", attachSignalVisibleText(await send(to, chunk.text, {
+		const result = await send(to, chunk.text, {
 			cfg: ctx.cfg,
 			maxBytes,
 			accountId: ctx.accountId ?? void 0,
 			textMode: "plain",
-			textStyles: chunk.styles,
-			...replyOptions
-		}), chunk.text));
+			textStyles: chunk.styles
+		});
+		const deliveryResult = attachChannelToResult("signal", attachSignalVisibleText(result, chunk.text));
 		results.push(deliveryResult);
 		await ctx.onDeliveryResult?.(deliveryResult);
 	}
@@ -872,13 +488,7 @@ async function sendFormattedSignalMedia(ctx) {
 		text: ctx.text,
 		styles: []
 	};
-	const replyOptions = await resolveSignalReplyOptions({
-		cfg: ctx.cfg,
-		to,
-		accountId: ctx.accountId,
-		replyToId: ctx.replyToId
-	});
-	return attachChannelToResult("signal", attachSignalVisibleText(await send(to, formatted.text, {
+	const result = await send(to, formatted.text, {
 		cfg: ctx.cfg,
 		mediaUrl: ctx.mediaUrl,
 		mediaLocalRoots: ctx.mediaLocalRoots,
@@ -886,9 +496,9 @@ async function sendFormattedSignalMedia(ctx) {
 		maxBytes,
 		accountId: ctx.accountId ?? void 0,
 		textMode: "plain",
-		textStyles: formatted.styles,
-		...replyOptions
-	}), formatted.text));
+		textStyles: formatted.styles
+	});
+	return attachChannelToResult("signal", attachSignalVisibleText(result, formatted.text));
 }
 async function registerDeliveredSignalApprovalPayloadForReactions(params) {
 	const account = resolveSignalAccount({
@@ -898,18 +508,6 @@ 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-Ds48FtEu.js").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();
 	registerSignalApprovalReactionTargetForDeliveredPayload({
 		cfg: params.cfg,
@@ -932,17 +530,11 @@ async function renderSignalApprovalPayloadForReactions(params) {
 	const targetAuthorUuid = normalizeOptionalString(account.config.accountUuid);
 	if (!targetAuthor && !targetAuthorUuid) return null;
 	const { addSignalApprovalReactionHintToStructuredPayload } = await loadSignalApprovalReactionsModule();
-	const payload = materializeSignalPresentationFallback(params.payload, params.presentation);
-	const questionPayload = questionGatewayRuntime.prepareReactionPayloadForDelivery({
-		payload: params.payload,
-		presentation: params.presentation
-	});
-	if (questionPayload) return questionPayload;
 	return addSignalApprovalReactionHintToStructuredPayload({
 		cfg: params.ctx.cfg,
 		accountId: params.ctx.accountId ?? void 0,
 		to: params.ctx.to,
-		payload,
+		payload: params.payload,
 		targetAuthor,
 		targetAuthorUuid
 	});
@@ -951,7 +543,7 @@ const signalPlugin = createChatChannelPlugin({
 	base: {
 		...createSignalPluginBase({
 			setupWizard: signalSetupWizard,
-			setupContract: signalSetupContract
+			setup: signalSetupAdapter
 		}),
 		actions: signalMessageActions,
 		approvalCapability: signalApprovalCapability,
@@ -1049,7 +641,7 @@ const signalPlugin = createChatChannelPlugin({
 			probeAccount: async ({ account, timeoutMs }) => {
 				const baseUrl = account.baseUrl;
 				const { probeSignal } = await loadSignalProbeModule();
-				return await probeSignal(baseUrl, timeoutMs, { transportKind: account.transport.kind });
+				return await probeSignal(baseUrl, timeoutMs, { apiMode: account.config?.apiMode ?? "auto" });
 			},
 			formatCapabilitiesProbe: ({ probe }) => probe?.version ? [{ text: `Signal daemon: ${probe.version}` }] : [],
 			resolveAccountSnapshot: ({ account }) => ({
@@ -1088,30 +680,7 @@ const signalPlugin = createChatChannelPlugin({
 		}
 	} },
 	security: signalSecurityAdapter,
-	threading: {
-		resolveReplyToMode: (params) => resolveSignalReplyToMode(params),
-		matchesToolContextTarget: ({ target, toolContext }) => {
-			const normalizedTarget = normalizeSignalMessagingTarget(target);
-			if (!normalizedTarget) return false;
-			return [toolContext.currentMessagingTarget, toolContext.currentChannelId].some((currentTarget) => currentTarget != null && normalizeSignalMessagingTarget(currentTarget) === normalizedTarget);
-		},
-		buildToolContext: ({ cfg, accountId, context, hasRepliedRef }) => {
-			const currentMessagingTarget = normalizeOptionalString(context.To);
-			const currentChatType = context.ChatType === "direct" || context.ChatType === "group" ? context.ChatType : void 0;
-			return {
-				currentChannelId: normalizeOptionalString(context.NativeChannelId) ?? currentMessagingTarget,
-				currentChatType,
-				currentMessagingTarget,
-				currentMessageId: context.ReplyToId ?? context.CurrentMessageId,
-				replyToMode: resolveSignalReplyToMode({
-					cfg,
-					accountId,
-					chatType: currentChatType
-				}),
-				hasRepliedRef
-			};
-		}
-	},
+	threading: { resolveReplyToMode: (params) => resolveSignalReplyToMode(params) },
 	outbound: {
 		base: {
 			deliveryMode: "direct",
@@ -1155,19 +724,16 @@ const signalPlugin = createChatChannelPlugin({
 			}),
 			afterDeliverPayload: async (params) => await registerDeliveredSignalApprovalPayloadForReactions(params),
 			renderPresentation: async (params) => await renderSignalApprovalPayloadForReactions(params),
-			sendFormattedText: async ({ cfg, to, text, accountId, deps, replyToId, replyToIdSource, replyToMode, abortSignal, onDeliveryResult }) => await sendFormattedSignalText({
+			sendFormattedText: async ({ cfg, to, text, accountId, deps, abortSignal, onDeliveryResult }) => await sendFormattedSignalText({
 				cfg,
 				to,
 				text,
 				accountId,
 				deps,
-				replyToId,
-				replyToIdSource,
-				replyToMode,
 				abortSignal,
 				onDeliveryResult
 			}),
-			sendFormattedMedia: async ({ cfg, to, text, mediaUrl, mediaLocalRoots, mediaReadFile, accountId, deps, replyToId, abortSignal }) => await sendFormattedSignalMedia({
+			sendFormattedMedia: async ({ cfg, to, text, mediaUrl, mediaLocalRoots, mediaReadFile, accountId, deps, abortSignal }) => await sendFormattedSignalMedia({
 				cfg,
 				to,
 				text,
@@ -1176,21 +742,19 @@ const signalPlugin = createChatChannelPlugin({
 				mediaReadFile,
 				accountId,
 				deps,
-				replyToId,
 				abortSignal
 			})
 		},
 		attachedResults: {
 			channel: "signal",
-			sendText: async ({ cfg, to, text, accountId, deps, replyToId }) => await sendSignalOutbound({
+			sendText: async ({ cfg, to, text, accountId, deps }) => await sendSignalOutbound({
 				cfg,
 				to,
 				text,
 				accountId: accountId ?? void 0,
-				deps,
-				replyToId
+				deps
 			}),
-			sendMedia: async ({ cfg, to, text, mediaUrl, mediaLocalRoots, mediaReadFile, accountId, deps, replyToId }) => await sendSignalOutbound({
+			sendMedia: async ({ cfg, to, text, mediaUrl, mediaLocalRoots, mediaReadFile, accountId, deps }) => await sendSignalOutbound({
 				cfg,
 				to,
 				text,
@@ -1198,11 +762,10 @@ const signalPlugin = createChatChannelPlugin({
 				mediaLocalRoots,
 				mediaReadFile,
 				accountId: accountId ?? void 0,
-				deps,
-				replyToId
+				deps
 			})
 		}
 	}
 });
 //#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 { normalizeSignalAccountInput as a, signalNumberTextInput as c, createSignalCliPathTextInput as i, signalSetupAdapter as l, createSignalPluginBase as n, signalCompletionNote as o, signalSetupWizard as r, signalDmPolicy as s, signalPlugin as t, resolveSignalOutboundTarget as u };