@openclaw/signal 2026.9.4 → 2026.9.5

package/dist/{doctor-contract-api-D0SnglP4.js → .setup/doctor-contract-api-Rbq_sRTI.mjs}

@@ -1,5 +1,6 @@
-import { a as isSignalManagedNativeConnectionUrlForBind, c as buildSignalTransportHttpUrl, i as assignSignalManagedNativePort, o as isValidSignalManagedNativePort, r as allocateSignalManagedNativePort, s as resolveLocalSignalTransportPort, u as normalizeSignalTransportUrl } from "./transport-policy-DxvSMHp9.js";
-import { isRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { a as normalizeSignalTransportUrl, r as buildSignalTransportHttpUrl, 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 { isRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
 import { defineChannelAliasMigration } from "openclaw/plugin-sdk/runtime-doctor-migrations";
 //#region extensions/signal/src/config-compat.ts
@@ -22,6 +23,11 @@ const PENDING_LEGACY_CONTAINER_ACCOUNT_WARNING = "- channels.signal: legacy cont
 function isSignalTransportConfig(value) {
 	if (!isRecord(value)) return false;
 	if (value.kind === "managed-native") {
+		try {
+			assertSignalSocketTransport(value);
+		} catch {
+			return false;
+		}
 		if (value.httpPort !== void 0 && !isValidSignalManagedNativePort(value.httpPort)) return false;
 		if (value.url === void 0) return true;
 		if (typeof value.url !== "string") return false;
@@ -173,13 +179,15 @@ function signalAccountIds(entries) {
 	const accounts = isRecord(entries[0]?.accounts) ? entries[0].accounts : {};
 	return Object.entries(accounts).filter(([, entry]) => isRecord(entry)).map(([accountId]) => accountId);
 }
+function resolveNestedDefaultEntryIndex(entries) {
+	const accounts = isRecord(entries[0]?.accounts) ? entries[0].accounts : {};
+	const key = resolveSignalAccountKey(accounts, DEFAULT_ACCOUNT_ID);
+	const offset = signalAccountIds(entries).findIndex((accountId) => accountId === key);
+	return offset >= 0 ? offset + 1 : void 0;
+}
 function isDefaultSignalAccountId(accountId) {
 	return Boolean(accountId?.trim()) && normalizeAccountId(accountId) === DEFAULT_ACCOUNT_ID;
 }
-function resolveSignalAccountKey(accounts, accountId) {
-	const normalizedAccountId = normalizeAccountId(accountId);
-	return Object.keys(accounts).find((key) => Boolean(key.trim()) && normalizeAccountId(key) === normalizedAccountId);
-}
 function nestedDefaultOwnsEffectiveTransport(entries) {
 	const accounts = isRecord(entries[0]?.accounts) ? entries[0].accounts : {};
 	const nestedDefaultKey = resolveSignalAccountKey(accounts, DEFAULT_ACCOUNT_ID);
@@ -188,7 +196,7 @@ function nestedDefaultOwnsEffectiveTransport(entries) {
 }
 function isDiscardedTransportEntry(entries, index) {
 	if (index === 0) return !hasRootSignalAccount(entries) || nestedDefaultOwnsEffectiveTransport(entries);
-	return isDefaultSignalAccountId(signalAccountIds(entries)[index - 1]) && isSignalTransportConfig(entries[0]?.transport);
+	return index === resolveNestedDefaultEntryIndex(entries) && isSignalTransportConfig(entries[0]?.transport);
 }
 function shouldMaterializeTransport(entries, index) {
 	if (isDiscardedTransportEntry(entries, index)) return false;
@@ -221,10 +229,11 @@ function clearLegacySignalTransportFieldsForAccount(params) {
 function allocateMigratedManagedPorts(params) {
 	const reservedPorts = /* @__PURE__ */ new Set();
 	const rootIsAccount = hasRootSignalAccount(params.entries);
-	const nestedDefaultOffset = signalAccountIds(params.entries).findIndex((accountId) => isDefaultSignalAccountId(accountId));
-	const canonicalDefaultIndex = isSignalTransportConfig(params.entries[0]?.transport) ? 0 : nestedDefaultOffset >= 0 ? nestedDefaultOffset + 1 : rootIsAccount ? 0 : void 0;
+	const nestedDefaultIndex = resolveNestedDefaultEntryIndex(params.entries);
+	const canonicalDefaultIndex = isSignalTransportConfig(params.entries[0]?.transport) ? 0 : nestedDefaultIndex !== void 0 ? nestedDefaultIndex : rootIsAccount ? 0 : void 0;
 	for (const [index, transport] of params.transports.entries()) {
 		if (!transport || index === 0 && canonicalDefaultIndex !== 0) continue;
+		if (transport.kind === "managed-native" && transport.socketPath !== void 0) continue;
 		if (transport.kind !== "managed-native") {
 			const localPort = resolveLocalSignalTransportPort(transport.url);
 			if (localPort !== void 0) reservedPorts.add(localPort);
@@ -238,7 +247,7 @@ function allocateMigratedManagedPorts(params) {
 	}
 	return params.transports.map((transport, index) => {
 		if (!transport || index === 0 && canonicalDefaultIndex !== 0) return transport;
-		if (transport.kind !== "managed-native") return transport;
+		if (transport.kind !== "managed-native" || transport.socketPath !== void 0) return transport;
 		if (isRecord(params.entries[index]?.transport) || index === canonicalDefaultIndex) return transport;
 		const rawPreferredPort = params.entries[index]?.httpPort;
 		const preferredPort = typeof rawPreferredPort === "number" ? rawPreferredPort : transport.httpPort;
@@ -254,13 +263,13 @@ function applyMigratedSignalTransports(params) {
 	const next = structuredClone(params.cfg);
 	const nextSignal = next.channels?.signal;
 	if (!isRecord(nextSignal)) return;
-	const accountIds = signalAccountIds(params.entries);
+	const nestedDefaultIndex = resolveNestedDefaultEntryIndex(params.entries);
 	const nextAccounts = isRecord(nextSignal.accounts) ? nextSignal.accounts : {};
 	const nextEntries = [nextSignal, ...Object.values(nextAccounts).filter(isRecord)];
 	const rootIsAccount = hasRootSignalAccount(params.entries);
 	const canonicalRootTransport = isSignalTransportConfig(params.entries[0]?.transport) ? params.entries[0].transport : void 0;
 	for (const [index, entry] of nextEntries.entries()) {
-		if (isDefaultSignalAccountId(index === 0 ? void 0 : accountIds[index - 1])) {
+		if (index === nestedDefaultIndex) {
 			const defaultTransport = canonicalRootTransport ?? params.transports[index];
 			if (defaultTransport) nextSignal.transport = defaultTransport;
 			else delete nextSignal.transport;
@@ -306,6 +315,11 @@ function prepareLegacySignalTransportMigration(cfg) {
 	};
 	const apiMode = signal.apiMode;
 	const entries = [signal, ...Object.values(accounts).filter(isRecord)];
+	if (entries.some((entry) => isRecord(entry.transport) && Object.hasOwn(entry.transport, "socketPath") && (entry.transport.kind !== "managed-native" || !isSignalTransportConfig(entry.transport)))) return {
+		config: cfg,
+		changes: [],
+		warnings: ["- channels.signal: invalid transport.socketPath configuration; correct the socket path and remove conflicting HTTP or receiveMode on-start options, then run openclaw doctor --fix."]
+	};
 	const legacyResolutionEntries = entries.filter((_, index) => shouldMaterializeTransport(entries, index)).filter((entry) => !isSignalTransportConfig(entry.transport));
 	const invalidDerivedEndpoint = findInvalidLegacyDerivedEndpoint(legacyResolutionEntries, signal);
 	if (invalidDerivedEndpoint) return {
@@ -390,6 +404,51 @@ function migrateLegacySignalTransportConfigSync(cfg) {
 	}));
 }
 //#endregion
+//#region extensions/signal/src/account-key-repair.ts
+function repairSignalAccountKeys({ cfg }) {
+	const signal = cfg.channels?.signal;
+	const accounts = signal?.accounts;
+	if (!accounts) return {
+		config: cfg,
+		changes: []
+	};
+	const groups = /* @__PURE__ */ new Map();
+	for (const key of Object.keys(accounts)) if (key) {
+		const id = normalizeAccountId(key);
+		groups.set(id, [...groups.get(id) ?? [], key]);
+	}
+	const moves = /* @__PURE__ */ new Map();
+	const warnings = [];
+	for (const [id, keys] of groups) {
+		if (keys.length > 1) {
+			warnings.push(`Signal account keys ${keys.map((key) => JSON.stringify(key)).join(", ")} resolve to "${id}". Doctor preserved them; rename them so each account has a unique normalized key.`);
+			continue;
+		}
+		for (const key of keys) if (normalizeLowercaseStringOrEmpty(key) !== id) {
+			if (resolveSignalAccountKey(accounts, id) !== key) {
+				warnings.push(`Signal account "${key}" is listed as "${id}" but currently uses the channel defaults. Doctor preserved it to avoid changing a working account; check its settings before renaming the key to "${id}".`);
+				continue;
+			}
+			moves.set(key, id);
+		}
+	}
+	const repaired = Object.fromEntries(Object.entries(accounts).map(([key, entry]) => [moves.get(key) ?? key, entry]));
+	return {
+		config: moves.size ? {
+			...cfg,
+			channels: {
+				...cfg.channels,
+				signal: {
+					...signal,
+					accounts: repaired
+				}
+			}
+		} : cfg,
+		changes: [...moves].map(([from, to]) => `Moved Signal account "${from}" to channels.signal.accounts.${to}.`),
+		warnings
+	};
+}
+//#endregion
 //#region extensions/signal/config-doctor-api.ts
 const RETIRED_SIGNAL_ACCOUNT_TRANSPORT_FIELDS = [
 	"configPath",
@@ -434,13 +493,18 @@ const legacyConfigRules = [
 	}
 ];
 function normalizeCompatibilityConfig({ cfg }) {
-	const streaming = streamingAliasMigration.normalizeChannelConfig({ cfg });
+	const accountKeys = repairSignalAccountKeys({ cfg });
+	const streaming = streamingAliasMigration.normalizeChannelConfig({ cfg: accountKeys.config });
 	const transport = migrateLegacySignalTransportConfigSync(streaming.config);
 	return {
 		config: transport.config,
-		changes: [...streaming.changes, ...transport.changes],
+		changes: [
+			...accountKeys.changes,
+			...streaming.changes,
+			...transport.changes
+		],
 		...transport.warnings?.length ? { warnings: transport.warnings } : {}
 	};
 }
 //#endregion
-export { migrateLegacySignalTransportConfig as i, normalizeCompatibilityConfig as n, clearLegacySignalTransportFieldsForAccount as r, legacyConfigRules as t };
+export { migrateLegacySignalTransportConfig as a, clearLegacySignalTransportFieldsForAccount as i, normalizeCompatibilityConfig as n, repairSignalAccountKeys as r, legacyConfigRules as t };

package/dist/{install-signal-cli-QlEIfWBv.js → .setup/install-signal-cli-bXeTrTyL.mjs}

@@ -1,10 +1,10 @@
 import { isRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import path from "node:path";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
-import path from "node:path";
+import fs from "node:fs/promises";
 import { CONFIG_DIR, extractArchive, resolveBrewExecutable } from "openclaw/plugin-sdk/setup-tools";
 import { createWriteStream } from "node:fs";
-import fs from "node:fs/promises";
 import { Readable, Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { readProviderJsonObjectResponse } from "openclaw/plugin-sdk/provider-http";
@@ -13,7 +13,6 @@ import { fetchWithSsrFGuard } from "openclaw/plugin-sdk/ssrf-runtime";
 import { withTempDownloadPath } from "openclaw/plugin-sdk/temp-path";
 //#region extensions/signal/src/install-signal-cli.ts
 const MAX_SIGNAL_CLI_ARCHIVE_BYTES = 268435456;
-/** @internal Exported for testing. */
 const MAX_SIGNAL_CLI_EXTRACTED_BYTES = 402653184;
 const SIGNAL_CLI_DOWNLOAD_TIMEOUT_MS = 3e5;
 const SIGNAL_CLI_RELEASE_INFO_TIMEOUT_MS = 3e4;
@@ -290,4 +289,4 @@ async function installSignalCli(runtime) {
 	return installSignalCliViaBrew(runtime);
 }
 //#endregion
-export { installSignalCliFromRelease as a, installSignalCli as i, downloadToFile as n, looksLikeArchive as o, extractSignalCliArchive as r, pickAsset as s, MAX_SIGNAL_CLI_EXTRACTED_BYTES as t };
+export { looksLikeArchive as a, installSignalCliFromRelease as i, extractSignalCliArchive as n, pickAsset as o, installSignalCli as r, downloadToFile as t };

package/dist/{monitor-BiNWxMB3.js → .setup/monitor-DAMQw1pZ.mjs}

@@ -1,26 +1,28 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { l as normalizeSignalTransportHost } from "./transport-policy-DxvSMHp9.js";
-import { i as resolveSignalAccount, o as resolveSignalReplyToMode } from "./accounts-DO4HMqaK.js";
-import { n as normalizeSignalMessagingTarget } from "./normalize-l_b99hap.js";
-import { a as normalizeSignalAllowRecipient, c as resolveSignalSender, i as isSignalSenderAllowed, l as looksLikeUuid, n as formatSignalSenderDisplay, o as resolveSignalPeerId, r as formatSignalSenderId, s as resolveSignalRecipient, t as formatSignalPairingIdLine } from "./identity-YXPmgFMu.js";
-import { c as resolveSignalReactionLevel, f as isSignalNativeApprovalHandlerConfigured, i as getOptionalSignalRuntime, l as formatSignalMediaText, n as registerSignalReplyContext, o as materializeSignalPresentationFallback } from "./transport-detection-Do2pYMAH.js";
-import { t as SignalSseRejectionError } from "./client-B3C0ciqU.js";
-import { n as signalRpcRequest, r as streamSignalEvents, t as signalCheck } from "./client-adapter-CNc5wzzs.js";
-import { n as sendReactionSignal } from "./reaction-runtime-api-CWqDv5-q.js";
-import { i as maybeResolveSignalApprovalReaction, o as registerSignalApprovalReactionTargetForDeliveredPayload, s as resolveSignalApprovalConversationKey, t as addSignalApprovalReactionHintToStructuredPayload } from "./approval-reactions-CjhdkJ8P.js";
-import { r as registerSignalQuestionReactionTargetForDeliveredPayload, t as maybeResolveSignalQuestionReaction } from "./question-reactions-BFR9Mf-O.js";
-import { n as sendReadReceiptSignal, r as sendTypingSignal, t as sendMessageSignal } from "./send-Bz0x0JC1.js";
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
+import { i as normalizeSignalTransportHost } from "./transport-url-CAC0JcuI.mjs";
+import { i as resolveSignalAccount, o as resolveSignalReplyToMode } from "./accounts-BV6tDOTc.mjs";
+import { n as normalizeSignalMessagingTarget } from "./normalize-l_b99hap.mjs";
+import { a as normalizeSignalAllowRecipient, c as resolveSignalSender, i as isSignalSenderAllowed, l as looksLikeUuid, n as formatSignalSenderDisplay, o as resolveSignalPeerId, r as formatSignalSenderId, s as resolveSignalRecipient, t as formatSignalPairingIdLine } from "./identity-YXPmgFMu.mjs";
+import { c as resolveSignalReactionLevel, f as isSignalNativeApprovalHandlerConfigured, i as getOptionalSignalRuntime, l as formatSignalMediaText, n as registerSignalReplyContext, o as materializeSignalPresentationFallback } from "./transport-detection-CqyR2vG8.mjs";
+import { a as prepareSignalSocketPath, t as SignalSseRejectionError } from "./client-BseAt7F7.mjs";
+import { n as signalRpcRequest, r as streamSignalEvents, t as signalCheck } from "./client-adapter-dvFa47YL.mjs";
+import { n as sendReactionSignal } from "./reaction-runtime-api-BnQGHcrB.mjs";
+import { i as maybeResolveSignalApprovalReaction, o as registerSignalApprovalReactionTargetForDeliveredPayload, s as resolveSignalApprovalConversationKey, t as addSignalApprovalReactionHintToStructuredPayload } from "./approval-reactions-B25QoVJc.mjs";
+import { r as registerSignalQuestionReactionTargetForDeliveredPayload, t as maybeResolveSignalQuestionReaction } from "./question-reactions-DSNAD0cd.mjs";
+import { n as sendReadReceiptSignal, r as sendTypingSignal, t as sendMessageSignal } from "./send-CcetN4rk.mjs";
 import { bindIngressLifecycleToReplyOptions, createChannelIngressError, createChannelIngressMonitor, createChannelMessageReplyPipeline, resolveChannelStreamingBlockEnabled } from "openclaw/plugin-sdk/channel-outbound";
 import { createChannelPairingChallengeIssuer } from "openclaw/plugin-sdk/channel-pairing";
 import { resolveAgentRoute, resolveInboundLastRouteSessionKey } from "openclaw/plugin-sdk/routing";
 import { asPositiveSafeInteger, isRecord, normalizeNullableString, normalizeOptionalString, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
+import path from "node:path";
 import { CHANNEL_APPROVAL_NATIVE_RUNTIME_CONTEXT_CAPABILITY } from "openclaw/plugin-sdk/approval-handler-adapter-runtime";
 import { normalizeE164, truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { buildChannelInboundEventContext, buildMentionRegexes, createChannelInboundDebouncer, filterChannelInboundQuoteContext, formatInboundEnvelope, formatInboundFromLabel, formatInboundMediaUnavailableText, hasVisibleInboundReplyDispatch, logInboundDrop, matchesMentionPatterns, readAgentRunTerminalOutcome, resolveEnvelopeFormatOptions, resolveInboundDebounceMs, resolveInboundMentionDecision, resolveInboundSupplementalSenderAllowed, runChannelInboundEvent, shouldDebounceTextInbound, toHistoryMediaEntries, toInboundMediaFactsWithMetadata } from "openclaw/plugin-sdk/channel-inbound";
 import { canonicalizeBase64, detectMime, estimateBase64DecodedBytes, kindFromMime, saveMediaBuffer } from "openclaw/plugin-sdk/media-runtime";
 import { collectErrorGraphCandidates, formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { ensurePortAvailable, extractErrorCode, formatErrorMessage as formatErrorMessage$1, resolvePinnedMainDmOwnerFromAllowlist } from "openclaw/plugin-sdk/security-runtime";
-import path from "node:path";
+import { spawn } from "node:child_process";
+import os from "node:os";
 import { resolveChannelGroupPolicy, resolveChannelGroupRequireMention, resolveChannelGroups, resolveChannelGroupsConfigPath } from "openclaw/plugin-sdk/channel-policy";
 import { registerChannelRuntimeContext } from "openclaw/plugin-sdk/channel-runtime-context";
 import { DEFAULT_GROUP_HISTORY_LIMIT, createChannelHistoryWindow } from "openclaw/plugin-sdk/reply-history";
@@ -30,8 +32,6 @@ import { createRuntimeConfigReader, getRuntimeConfig } from "openclaw/plugin-sdk
 import { computeBackoff, createNonExitingRuntime, danger, logVerbose, shouldLogVerbose, sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 import { resolveAllowlistProviderRuntimeGroupPolicy, resolveDefaultGroupPolicy, warnMissingProviderGroupPolicyFallbackOnce } from "openclaw/plugin-sdk/runtime-group-policy";
 import { waitForTransportReady } from "openclaw/plugin-sdk/transport-ready-runtime";
-import { spawn } from "node:child_process";
-import os from "node:os";
 import { createInterface } from "node:readline";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { resolveHumanDelayConfig } from "openclaw/plugin-sdk/agent-runtime";
@@ -56,6 +56,12 @@ function formatSignalDaemonEndpoint(httpHost, httpPort) {
 	return `${httpHost.includes(":") ? `[${httpHost}]` : httpHost}:${httpPort}`;
 }
 async function assertSignalDaemonEndpointAvailable(params) {
+	if (params.socketPath) {
+		params.abortSignal?.throwIfAborted();
+		await prepareSignalSocketPath(params.socketPath, params.abortSignal);
+		params.abortSignal?.throwIfAborted();
+		return;
+	}
 	try {
 		await ensurePortAvailable(params.httpPort, params.httpHost, params.abortSignal);
 	} catch (error) {
@@ -123,9 +129,11 @@ function buildDaemonArgs(opts) {
 	if (opts.configPath?.trim()) args.push("--config", resolveSignalCliConfigPath(opts.configPath));
 	if (opts.account) args.push("-a", opts.account);
 	args.push("daemon");
-	args.push("--http", `${opts.httpHost}:${opts.httpPort}`);
+	if (opts.socketPath) args.push("--socket", opts.socketPath);
+	else args.push("--http", `${opts.httpHost}:${opts.httpPort}`);
 	args.push("--no-receive-stdout");
-	if (opts.receiveMode) args.push("--receive-mode", opts.receiveMode);
+	if (opts.socketPath) args.push("--receive-mode", "manual");
+	else if (opts.receiveMode) args.push("--receive-mode", opts.receiveMode);
 	if (opts.ignoreAttachments) args.push("--ignore-attachments");
 	if (opts.ignoreStories) args.push("--ignore-stories");
 	if (opts.sendReadReceipts) args.push("--send-read-receipts");
@@ -1559,9 +1567,9 @@ function createSignalEventHandler(deps) {
 }
 //#endregion
 //#region extensions/signal/src/reaction-targets.ts
-function registerSignalReactionTargetsForDeliveredPayload(params) {
+async function registerSignalReactionTargetsForDeliveredPayload(params) {
 	registerSignalQuestionReactionTargetForDeliveredPayload(params);
-	registerSignalApprovalReactionTargetForDeliveredPayload(params);
+	await registerSignalApprovalReactionTargetForDeliveredPayload(params);
 }
 //#endregion
 //#region extensions/signal/src/signal-ingress.ts
@@ -1919,7 +1927,7 @@ async function deliverReplies(params) {
 			sendText: send,
 			sendMedia: ({ mediaUrl, caption }) => send(caption ?? "", mediaUrl)
 		}) !== "empty") {
-			registerSignalReactionTargetsForDeliveredPayload({
+			await registerSignalReactionTargetsForDeliveredPayload({
 				cfg: params.cfg,
 				target: {
 					channel: "signal",
@@ -1968,6 +1976,8 @@ async function monitorSignalProvider(opts = {}) {
 	const mediaMaxBytes = (opts.mediaMaxMb ?? accountInfo.config.mediaMaxMb ?? 8) * 1024 * 1024;
 	const transportKind = accountInfo.transport.kind;
 	const managedTransport = accountInfo.transport.kind === "managed-native" ? accountInfo.transport : void 0;
+	const socketPath = managedTransport?.socketPath;
+	if (socketPath && (opts.baseUrl !== void 0 || opts.httpHost !== void 0 || opts.httpPort !== void 0)) throw new Error("Signal socket transport cannot be combined with HTTP endpoint overrides");
 	const ignoreAttachments = opts.ignoreAttachments ?? accountInfo.config.ignoreAttachments ?? false;
 	const sendReadReceipts = Boolean(opts.sendReadReceipts ?? accountInfo.config.sendReadReceipts);
 	const waitForTransportReadyFn = opts.waitForTransportReady ?? waitForTransportReady;
@@ -1990,6 +2000,7 @@ async function monitorSignalProvider(opts = {}) {
 			await assertSignalDaemonEndpointAvailable({
 				httpHost,
 				httpPort,
+				...socketPath ? { socketPath } : {},
 				abortSignal: endpointProbeSignal
 			});
 		} catch (error) {
@@ -2005,6 +2016,7 @@ async function monitorSignalProvider(opts = {}) {
 			account,
 			httpHost,
 			httpPort,
+			...socketPath ? { socketPath } : {},
 			receiveMode: opts.receiveMode ?? managedTransport?.receiveMode,
 			ignoreAttachments: opts.ignoreAttachments ?? accountInfo.config.ignoreAttachments,
 			ignoreStories: opts.ignoreStories ?? managedTransport?.ignoreStories,

package/dist/{probe-kOJqyjWz.js → .setup/probe-IKCS9D-z.mjs}

@@ -1,6 +1,6 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { t as detectSignalTransport } from "./transport-detection-Do2pYMAH.js";
-import { n as signalRpcRequest, t as signalCheck } from "./client-adapter-CNc5wzzs.js";
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
+import { t as detectSignalTransport } from "./transport-detection-CqyR2vG8.mjs";
+import { n as signalRpcRequest, t as signalCheck } from "./client-adapter-dvFa47YL.mjs";
 import { runChannelProbe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 //#region extensions/signal/src/probe.ts

package/dist/{question-reactions-BFR9Mf-O.js → .setup/question-reactions-DSNAD0cd.mjs}

@@ -1,6 +1,6 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { i as resolveSignalDeliveredConversationKey } from "./approval-auth-pNCKKotV.js";
-import { c as resolveSignalApprovalTargetAuthorKeys } from "./approval-reactions-CjhdkJ8P.js";
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
+import { i as resolveSignalDeliveredConversationKey } from "./approval-auth-BBI9BTRm.mjs";
+import { c as resolveSignalApprovalTargetAuthorKeys } from "./approval-reactions-B25QoVJc.mjs";
 import { createQuestionReactionTargetStore, questionGatewayRuntime } from "openclaw/plugin-sdk/question-gateway-runtime";
 import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
 //#region extensions/signal/src/question-reactions.ts

package/dist/{reaction-runtime-api-CWqDv5-q.js → .setup/reaction-runtime-api-BnQGHcrB.mjs}

@@ -1,7 +1,7 @@
-import { i as resolveSignalAccount } from "./accounts-DO4HMqaK.js";
-import { r as normalizeSignalReactionRecipient } from "./normalize-l_b99hap.js";
-import { n as signalRpcRequest } from "./client-adapter-CNc5wzzs.js";
-import { t as resolveSignalRpcContext } from "./rpc-context-dXSy4NtF.js";
+import { i as resolveSignalAccount } from "./accounts-BV6tDOTc.mjs";
+import { r as normalizeSignalReactionRecipient } from "./normalize-l_b99hap.mjs";
+import { n as signalRpcRequest } from "./client-adapter-dvFa47YL.mjs";
+import { t as resolveSignalRpcContext } from "./rpc-context-CwwADZ1b.mjs";
 import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
 //#region extensions/signal/src/send-reactions.ts
 async function sendReactionSignalCore(params) {
@@ -38,7 +38,8 @@ async function sendReactionSignalCore(params) {
 		timestamp: (await signalRpcRequest("sendReaction", requestParams, {
 			baseUrl,
 			timeoutMs: params.opts.timeoutMs,
-			transportKind: params.opts.transportKind ?? accountInfo.transport.kind
+			transportKind: params.opts.transportKind ?? accountInfo.transport.kind,
+			assertDirectAdapterHandoff: params.opts.assertDirectAdapterHandoff
 		}))?.timestamp
 	};
 }

package/dist/{rpc-context-dXSy4NtF.js → .setup/rpc-context-CwwADZ1b.mjs}

@@ -1,4 +1,4 @@
-import "./accounts-DO4HMqaK.js";
+import "./accounts-BV6tDOTc.mjs";
 //#region extensions/signal/src/rpc-context.ts
 function resolveSignalRpcContext(opts, accountInfo) {
 	const baseUrlOverride = opts.baseUrl?.trim();

package/dist/{send-Bz0x0JC1.js → .setup/send-CcetN4rk.mjs}

@@ -1,8 +1,8 @@
-import { i as resolveSignalAccount } from "./accounts-DO4HMqaK.js";
-import { n as normalizeSignalMessagingTarget } from "./normalize-l_b99hap.js";
-import { n as registerSignalReplyContext, u as markdownToSignalText } from "./transport-detection-Do2pYMAH.js";
-import { n as signalRpcRequest } from "./client-adapter-CNc5wzzs.js";
-import { t as resolveSignalRpcContext } from "./rpc-context-dXSy4NtF.js";
+import { i as resolveSignalAccount } from "./accounts-BV6tDOTc.mjs";
+import { n as normalizeSignalMessagingTarget } from "./normalize-l_b99hap.mjs";
+import { n as registerSignalReplyContext, u as markdownToSignalText } from "./transport-detection-CqyR2vG8.mjs";
+import { n as signalRpcRequest } from "./client-adapter-dvFa47YL.mjs";
+import { t as resolveSignalRpcContext } from "./rpc-context-CwwADZ1b.mjs";
 import { createMessageReceiptFromOutboundResults } from "openclaw/plugin-sdk/channel-outbound";
 import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
@@ -189,7 +189,8 @@ async function sendMessageSignal(to, text, opts) {
 		baseUrl,
 		timeoutMs: opts.timeoutMs,
 		transportKind: opts.transportKind ?? accountInfo.transport.kind,
-		maxAttachmentBytes: maxBytes
+		maxAttachmentBytes: maxBytes,
+		assertDirectAdapterHandoff: opts.assertDirectAdapterHandoff
 	};
 	let nativeReplyStatus;
 	let result;

package/dist/{send.runtime-CeV1p7Sq.js → .setup/send.runtime-B7C4IP23.mjs}

@@ -1,2 +1,2 @@
-import { r as sendTypingSignal, t as sendMessageSignal } from "./send-Bz0x0JC1.js";
+import { r as sendTypingSignal, t as sendMessageSignal } from "./send-CcetN4rk.mjs";
 export { sendMessageSignal, sendTypingSignal };

package/dist/{transport-detection-Do2pYMAH.js → .setup/transport-detection-CqyR2vG8.mjs}

@@ -1,8 +1,8 @@
-import { u as normalizeSignalTransportUrl } from "./transport-policy-DxvSMHp9.js";
-import { i as resolveSignalAccount, n as listSignalAccountIds, r as resolveDefaultSignalAccountId, t as listEnabledSignalAccounts } from "./accounts-DO4HMqaK.js";
-import { n as normalizeSignalMessagingTarget, r as normalizeSignalReactionRecipient } from "./normalize-l_b99hap.js";
-import { n as signalApprovalAuth, t as getSignalApprovalApprovers } from "./approval-auth-pNCKKotV.js";
-import { n as sendReactionSignal, t as removeReactionSignal } from "./reaction-runtime-api-CWqDv5-q.js";
+import { a as normalizeSignalTransportUrl } from "./transport-url-CAC0JcuI.mjs";
+import { i as resolveSignalAccount, n as listSignalAccountIds, r as resolveDefaultSignalAccountId, t as listEnabledSignalAccounts } from "./accounts-BV6tDOTc.mjs";
+import { n as normalizeSignalMessagingTarget, r as normalizeSignalReactionRecipient } from "./normalize-l_b99hap.mjs";
+import { n as signalApprovalAuth, t as getSignalApprovalApprovers } from "./approval-auth-BBI9BTRm.mjs";
+import { n as sendReactionSignal, t as removeReactionSignal } from "./reaction-runtime-api-BnQGHcrB.mjs";
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
 import { questionGatewayRuntime } from "openclaw/plugin-sdk/question-gateway-runtime";
 import { parseAgentSessionKey } from "openclaw/plugin-sdk/routing";
@@ -74,7 +74,7 @@ const signalApproval = createApproverRestrictedNativeApprovalCapabilityFromForwa
 			approvalKind,
 			request
 		}),
-		load: async () => (await import("./approval-handler.runtime-DCPJkIqo.js")).signalApprovalNativeRuntime
+		load: async () => (await import("./approval-handler.runtime-Clf_1IZj.mjs")).signalApprovalNativeRuntime
 	})
 });
 const signalApprovalRouting = signalApproval.routing;
@@ -170,6 +170,7 @@ function markdownToSignalText(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,
@@ -235,7 +236,8 @@ async function mutateSignalReaction(params) {
 		accountId: params.accountId,
 		groupId: params.target.groupId,
 		targetAuthor: params.targetAuthor,
-		targetAuthorUuid: params.targetAuthorUuid
+		targetAuthorUuid: params.targetAuthorUuid,
+		...params.assertDirectAdapterHandoff ? { assertDirectAdapterHandoff: params.assertDirectAdapterHandoff } : {}
 	};
 	await (params.remove ? removeReactionSignal : sendReactionSignal)(params.target.recipient ?? "", params.timestamp, params.emoji, options);
 	return jsonResult({
@@ -264,7 +266,7 @@ const signalMessageActions = {
 			replyToId: normalizedReplyToId
 		};
 	},
-	handleAction: async ({ action, params, cfg, accountId, toolContext }) => {
+	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({
@@ -306,7 +308,8 @@ const signalMessageActions = {
 				emoji,
 				remove: Boolean(remove),
 				targetAuthor,
-				targetAuthorUuid
+				targetAuthorUuid,
+				assertDirectAdapterHandoff
 			});
 		}
 		throw new Error(`Action ${action} not supported for ${providerId}.`);
@@ -405,6 +408,7 @@ function resolveSourceTimestamp(value) {
 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 {
@@ -450,7 +454,8 @@ async function registerSignalReplyContext(params) {
 		pruneMemoryReplyContexts(registeredAt);
 		return;
 	}
-	if (!store.update) {
+	const usesComparisons = Boolean(store.observe && store.compareAndApply);
+	if (!store.update && !usesComparisons) {
 		const next = mergeReplyContext(memoryReplyContexts.get(key), record);
 		memoryReplyContexts.set(key, {
 			...next,
@@ -464,18 +469,46 @@ async function registerSignalReplyContext(params) {
 		}).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 {
-		if (await store.update(key, (current) => {
+		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;
-		}) && nextRecord) memoryReplyContexts.set(key, {
-			...nextRecord,
-			expiresAt
 		});
-		else memoryReplyContexts.delete(key);
+		cacheReplyContext(updated ? nextRecord : void 0);
 		pruneMemoryReplyContexts(registeredAt);
 	} catch (error) {
 		if (!updateEvaluated) try {
@@ -484,11 +517,7 @@ async function registerSignalReplyContext(params) {
 			nextRecord = void 0;
 		}
 		const next = nextRecord;
-		if (next) memoryReplyContexts.set(key, {
-			...next,
-			expiresAt
-		});
-		else if (updateEvaluated) memoryReplyContexts.delete(key);
+		if (next || updateEvaluated) cacheReplyContext(next);
 		pruneMemoryReplyContexts(registeredAt);
 		getOptionalSignalRuntime()?.logging.getChildLogger({
 			plugin: "signal",
@@ -523,7 +552,7 @@ const DEFAULT_PROBE_TIMEOUT_MS = 1e4;
 async function detectSignalTransport(params) {
 	const url = normalizeSignalTransportUrl(params.url);
 	const timeoutMs = params.timeoutMs ?? DEFAULT_PROBE_TIMEOUT_MS;
-	const probes = params.probeNative && params.probeContainer ? void 0 : await import("./transport-probes.runtime-DV7x4VWu.js");
+	const probes = params.probeNative && params.probeContainer ? void 0 : await import("./transport-probes.runtime-WprAyBbL.mjs");
 	const probeNative = params.probeNative ?? probes?.nativeCheck;
 	const probeContainer = params.probeContainer ?? probes?.containerCheck;
 	if (!probeNative || !probeContainer) throw new Error("Signal transport probes are unavailable");

package/dist/{transport-detection.runtime-QasZp3BE.js → .setup/transport-detection.runtime-CW1lp2d9.mjs}

@@ -1,2 +1,2 @@
-import { t as detectSignalTransport } from "./transport-detection-Do2pYMAH.js";
+import { t as detectSignalTransport } from "./transport-detection-CqyR2vG8.mjs";
 export { detectSignalTransport };

package/dist/{transport-policy-DxvSMHp9.js → .setup/transport-policy-5VSnj5ma.mjs}

@@ -1,35 +1,4 @@
-import { isIP } from "node:net";
-//#region extensions/signal/src/transport-url.ts
-function normalizeSignalTransportUrl(value) {
-	const trimmed = value.trim();
-	if (!trimmed) throw new Error("Signal transport URL is required");
-	if (/^https?:/i.test(trimmed) && !/^https?:\/\/[^/]/i.test(trimmed)) throw new Error("Signal transport URL has a malformed HTTP scheme");
-	const explicitScheme = /^([a-z][a-z0-9+.-]*):\/\//i.exec(trimmed)?.[1]?.toLowerCase();
-	if (explicitScheme && explicitScheme !== "http" && explicitScheme !== "https") throw new Error(`Signal transport URL unsupported protocol: ${explicitScheme}:`);
-	const parsed = new URL(/^https?:\/\//i.test(trimmed) ? trimmed : `http://${trimmed}`);
-	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new Error(`Signal transport URL unsupported protocol: ${parsed.protocol}`);
-	if (parsed.username || parsed.password) throw new Error("Signal transport URL must not include credentials");
-	const pathname = parsed.pathname === "/" ? "" : parsed.pathname.replace(/\/+$/, "");
-	return `${parsed.protocol}//${parsed.host}${pathname}`;
-}
-function normalizeSignalTransportHost(host) {
-	const trimmedHost = host.trim();
-	const hasOpeningBracket = trimmedHost.startsWith("[");
-	if (hasOpeningBracket !== trimmedHost.endsWith("]")) throw new Error("Signal transport host has mismatched IPv6 brackets");
-	const normalizedHost = hasOpeningBracket ? trimmedHost.slice(1, -1) : trimmedHost;
-	if (!normalizedHost || /[\s/\\?#@]/.test(normalizedHost)) throw new Error("Signal transport host must be a hostname or IP address");
-	if (isIP(normalizedHost) === 0) {
-		const hostname = normalizedHost.endsWith(".") ? normalizedHost.slice(0, -1) : normalizedHost;
-		const labels = hostname.split(".");
-		if (hostname.length > 253 || labels.some((label) => !label || label.length > 63 || !/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i.test(label))) throw new Error("Signal transport host must be a hostname or IP address");
-	}
-	return normalizedHost;
-}
-function buildSignalTransportHttpUrl(host, port) {
-	const normalizedHost = normalizeSignalTransportHost(host);
-	return normalizeSignalTransportUrl(`http://${normalizedHost.includes(":") ? `[${normalizedHost}]` : normalizedHost}:${port}`);
-}
-//#endregion
+import { a as normalizeSignalTransportUrl } from "./transport-url-CAC0JcuI.mjs";
 //#region extensions/signal/src/transport-policy.ts
 const DEFAULT_SIGNAL_MANAGED_NATIVE_PORT = 8080;
 const DEFAULT_SIGNAL_MANAGED_NATIVE_HOST = "127.0.0.1";
@@ -96,4 +65,4 @@ function assignSignalManagedNativePort(transport, httpPort) {
 	};
 }
 //#endregion
-export { isSignalManagedNativeConnectionUrlForBind as a, buildSignalTransportHttpUrl as c, assignSignalManagedNativePort as i, normalizeSignalTransportHost as l, DEFAULT_SIGNAL_MANAGED_NATIVE_PORT as n, isValidSignalManagedNativePort as o, allocateSignalManagedNativePort as r, resolveLocalSignalTransportPort as s, DEFAULT_SIGNAL_MANAGED_NATIVE_HOST as t, normalizeSignalTransportUrl as u };
+export { isSignalManagedNativeConnectionUrlForBind as a, assignSignalManagedNativePort as i, DEFAULT_SIGNAL_MANAGED_NATIVE_PORT as n, isValidSignalManagedNativePort as o, allocateSignalManagedNativePort as r, resolveLocalSignalTransportPort as s, DEFAULT_SIGNAL_MANAGED_NATIVE_HOST as t };

package/dist/.setup/transport-probes.runtime-WprAyBbL.mjs

@@ -0,0 +1,2 @@
+import { n as signalCheck, o as containerCheck } from "./client-BseAt7F7.mjs";
+export { containerCheck, signalCheck as nativeCheck };