@unlinearity/cli-wechat-bridge 1.1.5 → 1.2.0

package/dist/bridge/wechat-bridge.js

@@ -1,21 +1,40 @@
 #!/usr/bin/env bun
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (c) 2026 UNLINEARITY <unlinearity@gmail.com>
+// Source: https://github.com/UNLINEARITY/CLI-WeChat-Bridge
+// This file is part of CLI-WeChat-Bridge. Modifications and derivative works
+// must be released under AGPL-3.0-or-later with full source code; see
+// LICENSE.txt. Network services built on it must offer source to users.
 import path from "node:path";
 import { resolveDefaultAdapterCommand, } from "./bridge-adapters.js";
 import { delay } from "./bridge-adapters.shared.js";
 import { t } from "../i18n/index.js";
 import { BridgeController } from "./bridge-controller.js";
-import { forwardWechatFinalReply } from "./bridge-final-reply.js";
 import { ResumeSessionCoordinator, isWechatResumeEnabled, shouldForwardSessionSwitchEvent, } from "./bridge-session-resume.js";
-import { WECHAT_SEND_MAX_ATTEMPTS, computeWechatSendRetryDelayMs, formatUserFacingBridgeFatalError, formatUserFacingInboundError, formatWechatContextTokenStaleLogEntry, formatWechatSendFailureLogEntry, formatWechatSendRetryLogEntry, isRetryableWechatSendError, shouldForwardBridgeEventToWechat, } from "./wechat-forwarding.js";
+import { formatUserFacingBridgeFatalError, formatUserFacingInboundError, shouldForwardBridgeEventToWechat, shouldSuppressCodexLocalThreadNotice, } from "../channels/wechat/wechat-forwarding.js";
 import { ensureWechatCredentials } from "../wechat/setup.js";
 import { BridgeStateStore } from "./bridge-state.js";
 import { getProcessRecordByPid, reapOrphanedOpencodeProcesses, reapPeerBridgeProcesses, } from "./bridge-process-reaper.js";
 import { createRuntimeHost } from "../runtime/create-runtime-host.js";
+import { toChannelInboundMessage } from "../channels/wechat/channel-message.js";
+import { routeBridgeMessage } from "../core/bridge-message-router.js";
+import { canDrainDeferredCodexInboundQueue, formatDeferredCodexInboundQueueMessage, isRetryableDeferredCodexDrainError, shouldDeferCodexInboundMessage, } from "../core/bridge-defer.js";
+import { TurnCoordinator } from "../core/turn-coordinator.js";
+import { resolveOutboundConversationTarget } from "../core/outbound-target.js";
+import { handleAdapterControl } from "./adapter-control.js";
+import { forwardBridgeEvent } from "../core/bridge-event-forwarder.js";
+import { isDirectModuleRun } from "../core/direct-run.js";
+import { WechatChannelPort } from "../channels/wechat/wechat-channel-port.js";
+import { ensureWecomAccount } from "../channels/wecom/setup.js";
+import { WecomChannelPort } from "../channels/wecom/wecom-channel-port.js";
+import { WecomTransport } from "../channels/wecom/wecom-transport.js";
+import { WecomChannelDriver } from "../channels/wecom/wecom-driver.js";
+import { WechatChannelDriver } from "../channels/wechat/wechat-driver.js";
 import { buildWechatInboundPrompt, buildOneTimeCode, formatApprovalMessage, formatPendingApprovalReminder, formatPendingUserInputReminder, formatDuration, formatMirroredUserInputMessage, formatSessionSwitchMessage, formatStatusReport, formatTaskFailedMessage, formatThinkingForWechat, formatUserInputRequestMessage, MESSAGE_START_GRACE_MS, nowIso, OutputBatcher, parsePendingUserInputAnswerCommand, parseWechatControlCommand, truncatePreview, } from "./bridge-utils.js";
-import { classifyWechatTransportError, DEFAULT_LONG_POLL_TIMEOUT_MS, WeChatTransport, describeWechatTransportError, isWechatContextTokenStaleError, } from "../wechat/wechat-transport.js";
+import { classifyWechatTransportError, DEFAULT_LONG_POLL_TIMEOUT_MS, WeChatTransport, describeWechatTransportError, } from "../wechat/wechat-transport.js";
+import { getPendingChannelMessagesFile, getPendingWechatMessagesFile, PendingWechatMessageStore, } from "../channels/wechat/wechat-outbound-queue.js";
 import { checkForUpdate, formatUpdateMessage, } from "../utils/version-checker.js";
 import { clearDaemonEndpoint, isDaemonEndpointAlive, readDaemonEndpoint, } from "../daemon/daemon-link.js";
-import { formatBindCommandUsage, formatBindingsListMessage, isBindCommandPrefix, listBindings, loadEmojiBindings, parseEmojiBindingsCommand, removeBinding, resolveEmojiCommand, setBinding, } from "../daemon/emoji-bindings.js";
 const POLL_RETRY_BASE_MS = 1_000;
 const POLL_RETRY_MAX_MS = 30_000;
 const PARENT_PROCESS_POLL_MS = 5_000;
@@ -70,31 +89,7 @@ function toPendingUserInput(request) {
         createdAt: nowIso(),
     };
 }
-export function shouldDeferCodexInboundMessage(params) {
-    return (params.adapter === "codex" &&
-        !params.hasPendingConfirmation &&
-        !params.hasSystemCommand &&
-        params.activeTurnOrigin === "local" &&
-        (params.status === "busy" || params.status === "awaiting_approval"));
-}
-export function canDrainDeferredCodexInboundQueue(params) {
-    return (params.adapter === "codex" &&
-        params.deferredCount > 0 &&
-        !params.hasPendingConfirmation &&
-        !params.hasPendingUserInput &&
-        !params.hasPendingApproval &&
-        !params.hasActiveTask &&
-        !params.activeTurnId &&
-        params.status !== "busy" &&
-        params.status !== "awaiting_approval" &&
-        params.status !== "awaiting_input");
-}
-export function formatDeferredCodexInboundQueueMessage(queuePosition) {
-    return `Queued for delivery after the current local Codex turn finishes. Queue position: ${queuePosition}.`;
-}
-export function isRetryableDeferredCodexDrainError(errorText) {
-    return /still working|approval request is pending|waiting for local terminal input/i.test(errorText);
-}
+export { canDrainDeferredCodexInboundQueue, formatDeferredCodexInboundQueueMessage, isRetryableDeferredCodexDrainError, shouldDeferCodexInboundMessage, } from "../core/bridge-defer.js";
 export function parseCliArgs(argv) {
     let adapter = null;
     let commandOverride;
@@ -102,6 +97,7 @@ export function parseCliArgs(argv) {
     let profile;
     let lifecycle = "persistent";
     let sessionStartMode = "restore";
+    let channelId = "wechat";
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
         const next = argv[i + 1];
@@ -148,6 +144,13 @@ export function parseCliArgs(argv) {
                 sessionStartMode = next;
                 i += 1;
                 break;
+            case "--channel":
+                if (!next || (next !== "wechat" && next !== "wecom")) {
+                    throw new Error(`Invalid channel: ${next ?? "(missing)"}`);
+                }
+                channelId = next;
+                i += 1;
+                break;
             case "--shutdown-on-parent-exit":
                 lifecycle = "companion_bound";
                 break;
@@ -170,6 +173,33 @@ export function parseCliArgs(argv) {
         profile,
         lifecycle,
         sessionStartMode,
+        channelId,
+    };
+}
+function toWechatSendContext(kind) {
+    if (kind === "mirrored_input") {
+        return "mirrored_user_input";
+    }
+    if (kind === "status") {
+        return "message";
+    }
+    return kind;
+}
+function toLegacyInboundWechatMessage(message) {
+    return {
+        senderId: message.senderId,
+        sender: message.senderId,
+        sessionId: message.conversation.conversationId,
+        text: message.text,
+        attachments: message.attachments.map((attachment) => ({
+            kind: attachment.kind === "image" ? "image" : "file",
+            path: attachment.path,
+            fileName: attachment.fileName || path.basename(attachment.path),
+            sizeBytes: attachment.sizeBytes ?? 0,
+        })),
+        contextToken: message.conversation.opaqueRef,
+        createdAt: message.createdAt,
+        createdAtMs: Date.parse(message.createdAt),
     };
 }
 function printUsageAndExit() {
@@ -177,7 +207,7 @@ function printUsageAndExit() {
         "Internal bridge runtime usage:",
         "  npm run bridge -- --adapter <codex|claude|opencode|pi> [--cmd <executable>] [--cwd <path>] [--profile <name-or-path>] [--lifecycle <persistent|companion_bound>] [--session-start-mode <restore|new>]",
         "",
-        "This entry is internal. Users should run wechat-codex, wechat-claude, wechat-opencode, wechat-pi, or wechat-daemon.",
+        "This entry is internal. Users should run a wechat-* or wecom-* launcher.",
         "",
     ].join("\n"));
     process.exit(0);
@@ -191,21 +221,49 @@ async function main() {
     const options = parseCliArgs(process.argv.slice(2));
     const daemonEndpoint = readDaemonEndpoint();
     if (daemonEndpoint && await isDaemonEndpointAlive(daemonEndpoint, { timeoutMs: 500 })) {
-        throw new Error(`wechat-daemon is already running (pid=${daemonEndpoint.pid}, cwd=${daemonEndpoint.cwd}). Stop it before starting a standalone bridge.`);
+        throw new Error(`${daemonEndpoint.channelId ?? "wechat"}-daemon is already running (pid=${daemonEndpoint.pid}, cwd=${daemonEndpoint.cwd}). Stop it before starting a standalone bridge.`);
     }
     if (daemonEndpoint) {
         clearDaemonEndpoint(daemonEndpoint.pid);
         log(`Cleared stale wechat-daemon endpoint for pid=${daemonEndpoint.pid}.`);
     }
-    const credentials = await ensureWechatCredentials({
-        requireUserId: true,
-        validateExisting: true,
-        log,
-    });
+    const wecomAccount = options.channelId === "wecom"
+        ? await ensureWecomAccount({ log })
+        : null;
+    const credentials = wecomAccount
+        ? { userId: wecomAccount.operatorUserId }
+        : await ensureWechatCredentials({
+            requireUserId: true,
+            validateExisting: true,
+            log,
+        });
     if (!credentials.userId) {
-        throw new Error("Saved WeChat credentials are missing userId.");
+        throw new Error(options.channelId === "wecom"
+            ? "Saved WeCom credentials are missing operatorUserId."
+            : "Saved WeChat credentials are missing userId.");
     }
     const transport = new WeChatTransport({ log, logError });
+    const wecomTransport = wecomAccount
+        ? new WecomTransport({
+            account: wecomAccount,
+            logger: {
+                log: (message) => log(message),
+                error: (message) => logError(message),
+            },
+        })
+        : null;
+    const channelDriver = wecomTransport
+        ? new WecomChannelDriver({
+            transport: wecomTransport,
+            accountId: wecomAccount?.botId,
+            operatorId: credentials.userId,
+            logError,
+        })
+        : new WechatChannelDriver({
+            transport,
+            logError,
+            buildInboundPrompt: (text, attachments) => buildWechatInboundPrompt(text, attachments.filter((attachment) => attachment.kind === "image" || attachment.kind === "file")),
+        });
     // 非阻塞地检查更新（不影响启动速度，也避免首次登录时打断二维码输出）
     // unref：不能让这个延迟检查把 event loop 挂活（如 --doctor 或快速退出场景），
     // 否则会与强制退出 teardown 竞态。
@@ -224,6 +282,7 @@ async function main() {
     const stateStore = new BridgeStateStore({
         ...options,
         authorizedUserId: credentials.userId,
+        channelId: options.channelId,
     });
     const reapedPeerPids = await reapPeerBridgeProcesses({
         logger: (message) => stateStore.appendLog(message),
@@ -270,6 +329,9 @@ async function main() {
         initialResumeConversationId: stateStore.getState().resumeConversationId,
         initialTranscriptPath: stateStore.getState().transcriptPath,
     });
+    const pendingWechatMessages = new PendingWechatMessageStore(options.channelId === "wechat"
+        ? getPendingWechatMessagesFile(options.cwd)
+        : getPendingChannelMessagesFile(options.cwd, options.channelId));
     const resumeCoordinator = new ResumeSessionCoordinator({
         adapter: options.adapter,
         runtime: adapter,
@@ -280,7 +342,13 @@ async function main() {
     let textSendChain = Promise.resolve();
     let attachmentSendChain = Promise.resolve();
     const pendingWechatForwardTasks = new Set();
-    let activeTask = null;
+    const defaultConversation = channelDriver.defaultConversation();
+    const operatorId = credentials.userId;
+    const operatorConversation = defaultConversation
+        ?? channelDriver.directConversation(operatorId);
+    const turns = new TurnCoordinator({
+        initialLastConversation: defaultConversation,
+    });
     const deferredInboundMessages = [];
     let drainingDeferredInboundMessages = false;
     let consecutivePollFailures = 0;
@@ -295,48 +363,52 @@ async function main() {
         attachmentSendChain = run.then(() => undefined, () => undefined);
         return run;
     };
-    const queueWechatMessage = (senderId, text, context = "message") => {
+    const sendWechatMessageNow = async (senderId, text, context = "message", targetOverride) => {
+        const target = resolveOutboundConversationTarget({
+            senderId,
+            operatorId,
+            override: targetOverride,
+            multiConversation: channelDriver.capabilities.multiConversation,
+            operatorTarget: turns.resolveTarget(operatorConversation),
+            directConversation: (id) => channelDriver.directConversation(id),
+        });
+        return channelDriver.sendText({
+            target,
+            text,
+            context,
+            log: (entry) => stateStore.appendLog(entry),
+        });
+    };
+    const queueWechatMessage = (senderId, text, context = "message", targetOverride) => {
+        const queuedTarget = senderId === operatorId && channelDriver.capabilities.multiConversation
+            ? targetOverride ?? turns.resolveTarget(operatorConversation)
+            : targetOverride;
         return queueWechatTextAction(async () => {
-            for (let attempt = 1; attempt <= WECHAT_SEND_MAX_ATTEMPTS; attempt += 1) {
-                try {
-                    await transport.sendText(senderId, text);
-                    return true;
+            const result = await sendWechatMessageNow(senderId, text, context, queuedTarget);
+            if (result.status === "target_stale") {
+                const pending = pendingWechatMessages.enqueue(senderId, text, context, result.target);
+                if (pending) {
+                    stateStore.appendLog(`wechat_send_queued: id=${pending.id} context=${context} recipient=${senderId} pending=${pendingWechatMessages.list().length}`);
                 }
-                catch (err) {
-                    if (isWechatContextTokenStaleError(err)) {
-                        transport.clearCachedContextToken(senderId);
-                        const hint = "WeChat conversation context is stale. Ask the WeChat owner to send any message first, then local terminal replies can sync back to WeChat.";
-                        logError(`Failed to send WeChat ${context}: ${hint}`);
-                        stateStore.appendLog(formatWechatContextTokenStaleLogEntry({
-                            context,
-                            recipientId: senderId,
-                            error: err,
-                        }));
-                        return false;
-                    }
-                    if (attempt < WECHAT_SEND_MAX_ATTEMPTS && isRetryableWechatSendError(err)) {
-                        const delayMs = computeWechatSendRetryDelayMs(attempt);
-                        logError(`Failed to send WeChat ${context} (attempt ${attempt}). Retrying in ${formatDuration(delayMs)}. ${describeWechatTransportError(err)}`);
-                        stateStore.appendLog(formatWechatSendRetryLogEntry({
-                            context,
-                            recipientId: senderId,
-                            attempt,
-                            delayMs,
-                            error: err,
-                        }));
-                        await delay(delayMs);
-                        continue;
-                    }
-                    logError(`Failed to send WeChat ${context}: ${describeWechatTransportError(err)}`);
-                    stateStore.appendLog(formatWechatSendFailureLogEntry({
-                        context,
-                        recipientId: senderId,
-                        error: err,
-                    }));
-                    return false;
+            }
+            return result.status === "sent";
+        });
+    };
+    const flushPendingWechatMessages = () => {
+        return queueWechatTextAction(async () => {
+            for (const pending of pendingWechatMessages.list()) {
+                const result = await sendWechatMessageNow(pending.recipientId, pending.text, pending.context, pending.target);
+                if (result.status === "sent") {
+                    pendingWechatMessages.remove(pending.id);
+                    stateStore.appendLog(`wechat_pending_sent: id=${pending.id} context=${pending.context} recipient=${pending.recipientId}`);
+                    continue;
+                }
+                if (result.status === "target_stale") {
+                    break;
                 }
+                stateStore.appendLog(`wechat_pending_retryable_failure: id=${pending.id} context=${pending.context} recipient=${pending.recipientId}`);
+                break;
             }
-            return false;
         });
     };
     const trackWechatForwardTask = (task) => {
@@ -356,7 +428,9 @@ async function main() {
         }
     };
     const outputBatcher = new OutputBatcher(async (text) => {
-        await queueWechatMessage(stateStore.getState().authorizedUserId, text);
+        await queueWechatMessage(stateStore.getState().authorizedUserId, text, "message", channelDriver.capabilities.multiConversation
+            ? turns.resolveTarget(operatorConversation)
+            : undefined);
     });
     const maybeDrainDeferredInboundMessages = async () => {
         if (drainingDeferredInboundMessages || !ensureRuntimeOwnership()) {
@@ -371,7 +445,7 @@ async function main() {
             hasPendingConfirmation: Boolean(stateStore.getState().pendingConfirmation),
             hasPendingUserInput: Boolean(stateStore.getState().pendingUserInput),
             hasPendingApproval: Boolean(adapterState.pendingApproval),
-            hasActiveTask: Boolean(activeTask),
+            hasActiveTask: turns.hasActiveTask,
         })) {
             return;
         }
@@ -382,13 +456,26 @@ async function main() {
         drainingDeferredInboundMessages = true;
         try {
             stateStore.appendLog(`draining_deferred_inbound_input: remaining=${deferredInboundMessages.length} text=${truncatePreview(nextDeferred.message.text)}`);
-            const nextTask = await dispatchInboundWechatText({
-                message: nextDeferred.message,
-                options,
-                stateStore,
-                adapter,
-            });
-            activeTask = nextTask;
+            const nextTask = createActiveTask(nextDeferred.message);
+            const lease = turns.beginTurn(nextTask, nextDeferred.channelMessage?.conversation);
+            if (!lease) {
+                deferredInboundMessages.unshift(nextDeferred);
+                return;
+            }
+            try {
+                await dispatchInboundWechatText({
+                    message: nextDeferred.message,
+                    channelDriver,
+                    options,
+                    stateStore,
+                    adapter,
+                    activeTask: nextTask,
+                });
+            }
+            catch (error) {
+                turns.rollback(lease);
+                throw error;
+            }
         }
         catch (err) {
             const errorText = err instanceof Error ? err.message : String(err);
@@ -403,7 +490,7 @@ async function main() {
                 adapter: options.adapter,
                 cwd: options.cwd,
                 errorText,
-            }), "inbound_error");
+            }), "inbound_error", nextDeferred.channelMessage?.conversation);
         }
         finally {
             drainingDeferredInboundMessages = false;
@@ -470,6 +557,18 @@ async function main() {
         catch {
             // Best effort shutdown.
         }
+        try {
+            wecomTransport?.stop();
+        }
+        catch {
+            // Best effort shutdown.
+        }
+        try {
+            await channelDriver.endAllTyping?.();
+        }
+        catch {
+            // Best effort shutdown.
+        }
         controller.clearLocalClientEndpoint();
         stateStore.releaseLock();
     };
@@ -538,6 +637,7 @@ async function main() {
     try {
         wireAdapterEvents({
             adapter,
+            channelDriver,
             resumeCoordinator,
             options,
             transport,
@@ -547,8 +647,11 @@ async function main() {
             queueWechatMessage,
             trackWechatForwardTask,
             maybeDrainDeferredInboundMessages,
-            clearActiveTask: () => {
-                activeTask = null;
+            getActiveTask: () => turns.activeTask,
+            clearActiveTask: (expectedTask) => {
+                if (expectedTask) {
+                    turns.complete(expectedTask);
+                }
             },
             syncSharedSessionState: () => {
                 syncSharedSessionState(stateStore, adapter);
@@ -557,6 +660,8 @@ async function main() {
                 controller.syncLocalClientEndpoint();
             },
             requestShutdown,
+            wecomTransport,
+            getWecomTarget: () => turns.resolveTarget(operatorConversation),
         });
         await adapter.start();
         if (!ensureRuntimeOwnership()) {
@@ -564,13 +669,116 @@ async function main() {
         }
         syncSharedSessionState(stateStore, adapter);
         controller.syncLocalClientEndpoint();
-        stateStore.appendLog(`Bridge started with adapter=${options.adapter} command=${options.command} cwd=${options.cwd}`);
-        log(`WeChat bridge is ready for adapter "${options.adapter}".`);
+        stateStore.appendLog(`Bridge started with channel=${options.channelId} adapter=${options.adapter} command=${options.command} cwd=${options.cwd}`);
+        if (channelDriver.start) {
+            await channelDriver.start({
+                onInboundMessage: async (channelMessage) => {
+                    if (shutdownPromise || !ensureRuntimeOwnership()) {
+                        return;
+                    }
+                    turns.observeConversation(channelMessage.conversation);
+                    const queueInboundReply = (senderId, text, context) => queueWechatMessage(senderId, text, context, channelMessage.conversation);
+                    if (pendingWechatMessages.list().length > 0) {
+                        await flushPendingWechatMessages();
+                    }
+                    const message = toLegacyInboundWechatMessage(channelMessage);
+                    const taskAtMessageStart = turns.activeTask;
+                    stateStore.touchActivity(message.createdAt);
+                    try {
+                        await handleInboundMessage({
+                            message,
+                            channelMessage,
+                            channelDriver,
+                            options,
+                            stateStore,
+                            adapter,
+                            resumeCoordinator,
+                            queueWechatMessage: queueInboundReply,
+                            outputBatcher,
+                            clearActiveTask: () => {
+                                if (taskAtMessageStart) {
+                                    turns.complete(taskAtMessageStart);
+                                }
+                            },
+                            dispatchInboundText: async () => {
+                                const nextActiveTask = createActiveTask(message);
+                                const result = await turns.dispatch({
+                                    task: nextActiveTask,
+                                    conversation: channelMessage.conversation,
+                                    onBusy: async () => {
+                                        await queueInboundReply(message.senderId, `${options.adapter} is still working. Wait for the current reply or use /stop.`);
+                                    },
+                                    forward: async () => {
+                                        await dispatchInboundWechatText({
+                                            message,
+                                            channelDriver,
+                                            options,
+                                            stateStore,
+                                            adapter,
+                                            activeTask: nextActiveTask,
+                                        });
+                                    },
+                                });
+                                if (result.status === "dispatched") {
+                                    void channelDriver.beginTyping?.(message.senderId);
+                                }
+                                return result.status === "dispatched" ? nextActiveTask : null;
+                            },
+                            deferInboundMessage: async (nextMessage) => {
+                                deferredInboundMessages.push({
+                                    message: nextMessage,
+                                    channelMessage,
+                                });
+                                stateStore.appendLog(`deferred_inbound_input: position=${deferredInboundMessages.length} text=${truncatePreview(nextMessage.text)}`);
+                                await queueInboundReply(nextMessage.senderId, formatDeferredCodexInboundQueueMessage(deferredInboundMessages.length));
+                            },
+                        });
+                    }
+                    catch (error) {
+                        const errorText = error instanceof Error ? error.message : String(error);
+                        logError(errorText);
+                        stateStore.appendLog(`inbound_error: ${errorText}`);
+                        await queueInboundReply(message.senderId, formatUserFacingInboundError({
+                            adapter: options.adapter,
+                            cwd: options.cwd,
+                            errorText,
+                        }), "inbound_error");
+                    }
+                    syncSharedSessionState(stateStore, adapter);
+                    await maybeDrainDeferredInboundMessages();
+                },
+                onUnauthorizedSender: async (senderId, chatType) => {
+                    stateStore.appendLog(`wecom_unauthorized: sender=${senderId} chat_type=${chatType}`);
+                    if (chatType === "direct") {
+                        const result = await channelDriver.sendText({
+                            target: channelDriver.directConversation(senderId),
+                            text: "Unauthorized.",
+                            context: "notice",
+                            log: (entry) => stateStore.appendLog(entry),
+                        });
+                        if (result.status !== "sent") {
+                            logError(`Failed to reply unauthorized notice to ${senderId}`);
+                        }
+                    }
+                },
+                onChannelFatal: async (error) => {
+                    stateStore.appendLog(`wecom_fatal_error: ${error.message}`);
+                    requestShutdown(error.message, 1);
+                },
+                onChannelConnected: async () => {
+                    if (pendingWechatMessages.list().length > 0) {
+                        await flushPendingWechatMessages();
+                    }
+                },
+            });
+            await channelDriver.waitUntilReady?.();
+        }
+        log(`${channelDriver.displayName} bridge is ready for adapter "${options.adapter}".`);
         log(`Working directory: ${options.cwd}`);
         if (options.profile) {
             log(`Profile: ${options.profile}`);
         }
-        log(`Authorized WeChat user: ${credentials.userId}`);
+        log(`Authorized ${channelDriver.displayName} user: ${credentials.userId}`);
         if (options.adapter === "codex") {
             log("For source-mode debugging, open the visible Codex client with: npm run codex:panel");
         }
@@ -583,15 +791,17 @@ async function main() {
         else if (options.adapter === "pi") {
             log("For source-mode debugging, open the visible Pi client with: npm run pi:companion");
         }
-        loadEmojiBindings();
-        // Keep the standalone bridge's WeChat welcome brief: command and emoji
-        // reference material belongs to /status and /bindings, which users can
-        // request on demand. The daemon sends its own, fuller welcome.
         const welcomeText = t("bridge.welcome", {
             adapter: options.adapter,
             cwd: options.cwd,
         });
         await queueWechatMessage(credentials.userId, welcomeText);
+        if (channelDriver.capabilities.pushInbound) {
+            while (!shutdownPromise && ensureRuntimeOwnership()) {
+                await delay(1_000);
+            }
+            return;
+        }
         while (true) {
             if (shutdownPromise) {
                 // Shutdown (e.g. SIGINT) was requested while we were awaiting the
@@ -634,6 +844,9 @@ async function main() {
                 log(`WeChat long poll recovered after ${recoveredFailures} transient error(s).`);
                 stateStore.appendLog(`poll_recovered: failures=${recoveredFailures}`);
             }
+            if (pollResult.messages.length > 0 && pendingWechatMessages.list().length > 0) {
+                await flushPendingWechatMessages();
+            }
             if (pollResult.ignoredBacklogCount > 0) {
                 stateStore.incrementIgnoredBacklog(pollResult.ignoredBacklogCount);
                 stateStore.appendLog(`ignored_startup_backlog: count=${pollResult.ignoredBacklogCount}`);
@@ -649,11 +862,12 @@ async function main() {
                 if (!ensureRuntimeOwnership()) {
                     break;
                 }
+                const taskAtMessageStart = turns.activeTask;
                 stateStore.touchActivity(message.createdAt);
-                let nextTask = null;
                 try {
-                    nextTask = await handleInboundMessage({
+                    await handleInboundMessage({
                         message,
+                        channelDriver,
                         options,
                         stateStore,
                         adapter,
@@ -661,7 +875,32 @@ async function main() {
                         queueWechatMessage,
                         outputBatcher,
                         clearActiveTask: () => {
-                            activeTask = null;
+                            if (taskAtMessageStart) {
+                                turns.complete(taskAtMessageStart);
+                            }
+                        },
+                        dispatchInboundText: async () => {
+                            const nextActiveTask = createActiveTask(message);
+                            const result = await turns.dispatch({
+                                task: nextActiveTask,
+                                onBusy: async () => {
+                                    await queueWechatMessage(message.senderId, `${options.adapter} is still working. Wait for the current reply or use /stop.`);
+                                },
+                                forward: async () => {
+                                    await dispatchInboundWechatText({
+                                        message,
+                                        channelDriver,
+                                        options,
+                                        stateStore,
+                                        adapter,
+                                        activeTask: nextActiveTask,
+                                    });
+                                },
+                            });
+                            if (result.status === "dispatched") {
+                                void channelDriver.beginTyping?.(message.senderId);
+                            }
+                            return result.status === "dispatched" ? nextActiveTask : null;
                         },
                         deferInboundMessage: async (nextMessage) => {
                             deferredInboundMessages.push({
@@ -682,9 +921,6 @@ async function main() {
                         errorText,
                     }), "inbound_error");
                 }
-                if (nextTask) {
-                    activeTask = nextTask;
-                }
                 syncSharedSessionState(stateStore, adapter);
                 await maybeDrainDeferredInboundMessages();
             }
@@ -719,7 +955,30 @@ function syncSharedSessionState(stateStore, adapter) {
     }
 }
 function wireAdapterEvents(params) {
-    const { adapter, resumeCoordinator, options, transport, stateStore, outputBatcher, queueWechatAttachmentAction, queueWechatMessage, trackWechatForwardTask, maybeDrainDeferredInboundMessages, clearActiveTask, syncSharedSessionState, syncLocalClientEndpoint, requestShutdown, } = params;
+    const { adapter, channelDriver, resumeCoordinator, options, transport, stateStore, outputBatcher, queueWechatAttachmentAction, queueWechatMessage, trackWechatForwardTask, maybeDrainDeferredInboundMessages, getActiveTask, clearActiveTask, syncSharedSessionState, syncLocalClientEndpoint, requestShutdown, wecomTransport, getWecomTarget, } = params;
+    const channelPort = options.channelId === "wecom"
+        ? new WecomChannelPort({
+            transport: wecomTransport,
+            sendText: (target, text, kind) => queueWechatMessage(stateStore.getState().authorizedUserId, text, toWechatSendContext(kind), target),
+            onEmptyVisibleReply: (adapter, rawText) => {
+                stateStore.appendLog(`empty_visible_final_reply: adapter=${adapter ?? options.adapter} raw=${truncatePreview(rawText)}`);
+            },
+        })
+        : new WechatChannelPort({
+            sendText: (recipientId, text, context) => queueWechatMessage(recipientId, text, context),
+            sendImage: (recipientId, filePath) => queueWechatAttachmentAction(() => transport.sendImage(filePath, { recipientId })),
+            sendFile: (recipientId, filePath) => queueWechatAttachmentAction(() => transport.sendFile(filePath, { recipientId })),
+            sendVoice: (recipientId, filePath) => queueWechatAttachmentAction(() => transport.sendVoice(filePath, recipientId)),
+            sendVideo: (recipientId, filePath) => queueWechatAttachmentAction(() => transport.sendVideo(filePath, { recipientId })),
+            onEmptyVisibleReply: (adapter, rawText) => {
+                stateStore.appendLog(`empty_visible_final_reply: adapter=${adapter ?? options.adapter} raw=${truncatePreview(rawText)}`);
+            },
+            onTextSent: (_adapter, text) => {
+                stateStore.appendLog(`final_reply_sent: chars=${Array.from(text).length}`);
+            },
+        });
+    let lastFinalReplyAtMs = 0;
+    let eventForwardChain = Promise.resolve();
     adapter.setEventSink((event) => {
         syncSharedSessionState();
         syncLocalClientEndpoint();
@@ -732,156 +991,157 @@ function wireAdapterEvents(params) {
             stateStore.clearPendingUserInput();
         }
         const authorizedUserId = stateStore.getState().authorizedUserId;
-        switch (event.type) {
-            case "stdout":
-            case "stderr":
-                if (shouldForwardBridgeEventToWechat(options.adapter, event.type)) {
-                    outputBatcher.push(event.text);
+        const eventTarget = channelDriver.capabilities.multiConversation
+            ? getWecomTarget()
+            : channelDriver.directConversation(authorizedUserId);
+        const eventTask = getActiveTask();
+        eventForwardChain = eventForwardChain
+            .then(() => forwardBridgeEvent(event, {
+            stdout: (next) => {
+                if (shouldForwardBridgeEventToWechat(options.adapter, next.type)) {
+                    outputBatcher.push(next.text);
                 }
-                break;
-            case "final_reply":
-                stateStore.appendLog(`final_reply: ${truncatePreview(event.text)}`);
+            },
+            stderr: (next) => {
+                if (shouldForwardBridgeEventToWechat(options.adapter, next.type)) {
+                    outputBatcher.push(next.text);
+                }
+            },
+            finalReply: (next) => {
+                void channelDriver.endTyping?.(authorizedUserId);
+                lastFinalReplyAtMs = Date.now();
+                stateStore.appendLog(`final_reply: ${truncatePreview(next.text)}`);
                 trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
-                    await forwardWechatFinalReply({
+                    await channelPort.send({
+                        target: eventTarget,
+                        kind: "final_reply",
+                        text: next.text,
                         adapter: options.adapter,
-                        rawText: event.text,
-                        onEmptyVisibleReply: ({ rawVisibleText }) => {
-                            stateStore.appendLog(`empty_visible_final_reply: adapter=${options.adapter} raw=${truncatePreview(rawVisibleText)}`);
-                        },
-                        sender: {
-                            sendText: async (text) => {
-                                const sent = await queueWechatMessage(authorizedUserId, text, "final_reply");
-                                if (sent) {
-                                    stateStore.appendLog(`final_reply_sent: chars=${Array.from(text).length}`);
-                                }
-                                return sent;
-                            },
-                            sendImage: (imagePath) => queueWechatAttachmentAction(() => transport.sendImage(imagePath, { recipientId: authorizedUserId })),
-                            sendFile: (filePath) => queueWechatAttachmentAction(() => transport.sendFile(filePath, { recipientId: authorizedUserId })),
-                            sendVoice: (voicePath) => queueWechatAttachmentAction(() => transport.sendVoice(voicePath, authorizedUserId)),
-                            sendVideo: (videoPath) => queueWechatAttachmentAction(() => transport.sendVideo(videoPath, { recipientId: authorizedUserId })),
-                        },
                     });
                 }));
-                break;
-            case "status":
-                if (event.message) {
-                    log(`${event.status}: ${event.message}`);
-                    stateStore.appendLog(`${event.status}: ${event.message}`);
+            },
+            status: (next) => {
+                if (next.message) {
+                    log(`${next.status}: ${next.message}`);
+                    stateStore.appendLog(`${next.status}: ${next.message}`);
                 }
                 void maybeDrainDeferredInboundMessages();
-                break;
-            case "notice":
-                stateStore.appendLog(`${event.level}_notice: ${truncatePreview(event.text)}`);
-                if (shouldForwardBridgeEventToWechat(options.adapter, event.type, { text: event.text })) {
+            },
+            notice: (next) => {
+                stateStore.appendLog(`${next.level}_notice: ${truncatePreview(next.text)}`);
+                if (shouldForwardBridgeEventToWechat(options.adapter, next.type, { text: next.text })) {
                     trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
-                        await queueWechatMessage(authorizedUserId, event.text, "notice");
+                        await queueWechatMessage(authorizedUserId, next.text, "notice", eventTarget);
                     }));
                 }
-                break;
-            case "thinking":
-                if (event.text) {
-                    const thinkingPreview = formatThinkingForWechat(event.text, 500);
+            },
+            thinking: (next) => {
+                if (next.text) {
+                    const thinkingPreview = formatThinkingForWechat(next.text, 500);
                     if (thinkingPreview) {
                         stateStore.appendLog(`thinking: ${thinkingPreview}`);
                         trackWechatForwardTask((async () => {
-                            await queueWechatMessage(authorizedUserId, `思考: ${thinkingPreview}`, "thinking");
+                            await queueWechatMessage(authorizedUserId, channelDriver.id === "wecom"
+                                ? `Processing: ${thinkingPreview}`
+                                : `思考: ${thinkingPreview}`, "thinking", eventTarget);
                         })());
                     }
                 }
-                break;
-            case "approval_required":
+            },
+            approvalRequired: (next) => {
                 trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
-                    const pending = toPendingApproval(event.request);
+                    const pending = toPendingApproval(next.request);
                     stateStore.setPendingConfirmation(pending);
                     stateStore.appendLog(`Approval requested (${pending.source}): ${pending.commandPreview}`);
-                    await queueWechatMessage(authorizedUserId, formatApprovalMessage(pending, adapterState), "approval_required");
+                    await queueWechatMessage(authorizedUserId, formatApprovalMessage(pending, adapterState), "approval_required", eventTarget);
                 }));
-                break;
-            case "user_input_required":
+            },
+            userInputRequired: (next) => {
                 trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
-                    const pending = toPendingUserInput(event.request);
+                    const pending = toPendingUserInput(next.request);
                     stateStore.setPendingUserInput(pending);
                     stateStore.appendLog(`User input requested: questions=${pending.questions.length}`);
-                    await queueWechatMessage(authorizedUserId, formatUserInputRequestMessage(pending, adapterState), "user_input_required");
+                    await queueWechatMessage(authorizedUserId, formatUserInputRequestMessage(pending, adapterState), "user_input_required", eventTarget);
                 }));
-                break;
-            case "mirrored_user_input":
-                stateStore.appendLog(`mirrored_local_input: ${truncatePreview(event.text)}`);
-                if (shouldForwardBridgeEventToWechat(options.adapter, event.type, { text: event.text })) {
+            },
+            mirroredUserInput: (next) => {
+                stateStore.appendLog(`mirrored_local_input: ${truncatePreview(next.text)}`);
+                if (shouldForwardBridgeEventToWechat(options.adapter, next.type, { text: next.text })) {
                     trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
-                        await queueWechatMessage(authorizedUserId, formatMirroredUserInputMessage(options.adapter, event.text), "mirrored_user_input");
+                        await queueWechatMessage(authorizedUserId, formatMirroredUserInputMessage(options.adapter, next.text), "mirrored_user_input", eventTarget);
                     }));
                 }
-                break;
-            case "session_switched":
-                if (event.source === "local") {
+            },
+            sessionSwitched: (next) => {
+                if (next.source === "local")
                     resumeCoordinator.clear();
-                }
-                stateStore.appendLog(`session_switched: ${event.sessionId} source=${event.source} reason=${event.reason}`);
-                if (shouldForwardSessionSwitchEvent(event.reason) &&
-                    shouldForwardBridgeEventToWechat(options.adapter, event.type)) {
+                stateStore.appendLog(`session_switched: ${next.sessionId} source=${next.source} reason=${next.reason}`);
+                if (shouldForwardSessionSwitchEvent(next.reason) && shouldForwardBridgeEventToWechat(options.adapter, next.type)) {
                     trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
-                        await queueWechatMessage(authorizedUserId, formatSessionSwitchMessage({
-                            adapter: options.adapter,
-                            sessionId: event.sessionId,
-                            source: event.source,
-                            reason: event.reason,
-                        }), "session_switched");
+                        await queueWechatMessage(authorizedUserId, formatSessionSwitchMessage({ adapter: options.adapter, sessionId: next.sessionId, source: next.source, reason: next.reason }), "session_switched", eventTarget);
                     }));
                 }
-                break;
-            case "thread_switched":
-                if (event.source === "local") {
+            },
+            threadSwitched: (next) => {
+                if (next.source === "local")
                     resumeCoordinator.clear();
+                stateStore.appendLog(`thread_switched: ${next.threadId} source=${next.source} reason=${next.reason}`);
+                if (shouldSuppressCodexLocalThreadNotice({
+                    adapter: options.adapter,
+                    source: next.source,
+                    activeTurnOrigin: adapter.getState().activeTurnOrigin,
+                    lastFinalReplyAtMs,
+                })) {
+                    return;
                 }
-                stateStore.appendLog(`thread_switched: ${event.threadId} source=${event.source} reason=${event.reason}`);
-                if (shouldForwardSessionSwitchEvent(event.reason) &&
-                    shouldForwardBridgeEventToWechat(options.adapter, event.type)) {
+                if (shouldForwardSessionSwitchEvent(next.reason) && shouldForwardBridgeEventToWechat(options.adapter, next.type)) {
                     trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
-                        await queueWechatMessage(authorizedUserId, formatSessionSwitchMessage({
-                            adapter: options.adapter,
-                            sessionId: event.threadId,
-                            source: event.source,
-                            reason: event.reason,
-                        }), "thread_switched");
+                        await queueWechatMessage(authorizedUserId, formatSessionSwitchMessage({ adapter: options.adapter, sessionId: next.threadId, source: next.source, reason: next.reason }), "thread_switched", eventTarget);
                     }));
                 }
                 void maybeDrainDeferredInboundMessages();
-                break;
-            case "task_complete":
+            },
+            taskComplete: () => {
+                void channelDriver.endTyping?.(authorizedUserId);
                 trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                     stateStore.clearPendingConfirmation();
                     stateStore.clearPendingUserInput();
-                    clearActiveTask();
+                    clearActiveTask(eventTask);
                     await maybeDrainDeferredInboundMessages();
                 }));
-                break;
-            case "task_failed":
+            },
+            taskFailed: (next) => {
+                void channelDriver.endTyping?.(authorizedUserId);
                 trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                     stateStore.clearPendingConfirmation();
                     stateStore.clearPendingUserInput();
-                    clearActiveTask();
-                    await queueWechatMessage(authorizedUserId, formatTaskFailedMessage(options.adapter, event.message), "task_failed");
+                    clearActiveTask(eventTask);
+                    await queueWechatMessage(authorizedUserId, formatTaskFailedMessage(options.adapter, next.message), "task_failed", eventTarget);
                     await maybeDrainDeferredInboundMessages();
                 }));
-                break;
-            case "fatal_error":
-                logError(event.message);
-                stateStore.appendLog(`fatal_error: ${event.message}`);
+            },
+            fatalError: (next) => {
+                void channelDriver.endTyping?.(authorizedUserId);
+                logError(next.message);
+                stateStore.appendLog(`fatal_error: ${next.message}`);
                 stateStore.clearPendingConfirmation();
                 stateStore.clearPendingUserInput();
-                clearActiveTask();
+                clearActiveTask(eventTask);
                 trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
-                    await queueWechatMessage(authorizedUserId, formatUserFacingBridgeFatalError(event.message), "fatal_error");
+                    await queueWechatMessage(authorizedUserId, formatUserFacingBridgeFatalError(next.message), "fatal_error", eventTarget);
                     await maybeDrainDeferredInboundMessages();
                 }));
-                break;
-            case "shutdown_requested":
-                stateStore.appendLog(`shutdown_requested: ${event.reason}`);
-                requestShutdown(event.message, event.exitCode ?? 0);
-                break;
-        }
+            },
+            shutdownRequested: (next) => {
+                stateStore.appendLog(`shutdown_requested: ${next.reason}`);
+                requestShutdown(next.message, next.exitCode ?? 0);
+            },
+        }))
+            .catch((error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            logError(`Bridge event handling failed: ${message}`);
+            stateStore.appendLog(`event_forward_failed: ${message}`);
+        });
     });
 }
 function formatInboundMessagePreview(message) {
@@ -896,42 +1156,11 @@ function formatInboundMessagePreview(message) {
     return "(empty)";
 }
 async function handleInboundMessage(params) {
-    let { message, } = params;
-    const { options, stateStore, adapter, resumeCoordinator, queueWechatMessage, outputBatcher, clearActiveTask, deferInboundMessage, } = params;
+    const { message, channelMessage, channelDriver, } = params;
+    const { options, stateStore, adapter, resumeCoordinator, queueWechatMessage, outputBatcher, clearActiveTask, dispatchInboundText, deferInboundMessage, } = params;
     const state = stateStore.getState();
     if (message.senderId !== state.authorizedUserId) {
-        await queueWechatMessage(message.senderId, "Unauthorized. This bridge only accepts messages from the configured WeChat owner.");
-        return null;
-    }
-    // Emoji resolution: rewrite message text if it starts with a bound emoji
-    const emojiMatch = resolveEmojiCommand(message.text);
-    if (emojiMatch) {
-        const rewritten = emojiMatch.remainder
-            ? `${emojiMatch.command} ${emojiMatch.remainder}`
-            : emojiMatch.command;
-        message = { ...message, text: rewritten };
-    }
-    // Emoji binding management commands
-    const bindingsCmd = parseEmojiBindingsCommand(message.text);
-    if (bindingsCmd) {
-        switch (bindingsCmd.type) {
-            case "list":
-                await queueWechatMessage(message.senderId, formatBindingsListMessage(listBindings()));
-                break;
-            case "bind":
-                setBinding(bindingsCmd.emoji, bindingsCmd.command);
-                await queueWechatMessage(message.senderId, `Bound ${bindingsCmd.emoji} → ${bindingsCmd.command}`);
-                break;
-            case "unbind": {
-                const removed = removeBinding(bindingsCmd.emoji);
-                await queueWechatMessage(message.senderId, removed ? `Unbound ${bindingsCmd.emoji}` : `No binding found for ${bindingsCmd.emoji}`);
-                break;
-            }
-        }
-        return null;
-    }
-    if (isBindCommandPrefix(message.text)) {
-        await queueWechatMessage(message.senderId, formatBindCommandUsage());
+        await queueWechatMessage(message.senderId, `Unauthorized. This bridge only accepts messages from ${channelDriver.operatorDescription}.`);
         return null;
     }
     const systemCommand = parseWechatControlCommand(message.text, {
@@ -940,12 +1169,19 @@ async function handleInboundMessage(params) {
         hasPendingUserInput: Boolean(state.pendingUserInput),
     });
     switch (systemCommand?.type) {
+        case "model":
+        case "plan":
+            await queueWechatMessage(message.senderId, await handleAdapterControl(adapter, message.senderId, systemCommand));
+            return null;
+        case "broadcast":
+            await queueWechatMessage(message.senderId, "/all is only available in daemon mode. Start the daemon with wechat-daemon or wecom-daemon to broadcast to all workers.");
+            return null;
         case "status":
             await queueWechatMessage(message.senderId, formatStatusReport(stateStore.getState(), adapter.getState()));
             return null;
         case "resume": {
             if (!isWechatResumeEnabled(options.adapter)) {
-                await queueWechatMessage(message.senderId, `WeChat /resume is disabled in ${options.adapter} mode. Use /resume directly inside "wechat-${options.adapter}"; WeChat will follow the active local session.`);
+                await queueWechatMessage(message.senderId, `${channelDriver.displayName} /resume is disabled in ${options.adapter} mode. Use /resume directly inside "${channelDriver.id}-${options.adapter}"; the remote channel will follow the active local session.`);
                 return null;
             }
             try {
@@ -1056,53 +1292,63 @@ async function handleInboundMessage(params) {
             };
         }
     }
-    if (state.pendingConfirmation) {
-        await queueWechatMessage(message.senderId, formatPendingApprovalReminder(state.pendingConfirmation, adapter.getState()));
-        return null;
-    }
-    if (state.pendingUserInput) {
-        await queueWechatMessage(message.senderId, formatPendingUserInputReminder(state.pendingUserInput));
-        return null;
-    }
     const adapterState = adapter.getState();
-    if (shouldDeferCodexInboundMessage({
-        adapter: options.adapter,
-        status: adapterState.status,
-        activeTurnOrigin: adapterState.activeTurnOrigin,
-        hasPendingConfirmation: Boolean(state.pendingConfirmation),
-        hasSystemCommand: Boolean(systemCommand),
-    })) {
-        await deferInboundMessage(message);
-        return null;
-    }
-    if (adapterState.status === "busy") {
-        if ((options.adapter === "codex" || options.adapter === "opencode" || options.adapter === "pi") &&
-            adapterState.activeTurnOrigin === "local") {
-            await queueWechatMessage(message.senderId, `${options.adapter === "opencode" ? "OpenCode" : options.adapter === "pi" ? "Pi" : "codex"} is currently busy with a local terminal turn. Wait for it to finish or use /stop.`);
-            return null;
-        }
-        await queueWechatMessage(message.senderId, `${options.adapter} is still working. Wait for the current reply or use /stop.`);
-        return null;
-    }
-    return dispatchInboundWechatText({
-        message,
-        options,
-        stateStore,
-        adapter,
+    const routeResult = await routeBridgeMessage({
+        message: channelMessage ?? toChannelInboundMessage(message),
+        authorized: true,
+        command: null,
+        adapterState,
+        hasPendingApproval: Boolean(state.pendingConfirmation),
+        hasPendingUserInput: Boolean(state.pendingUserInput),
+        shouldDefer: shouldDeferCodexInboundMessage({
+            adapter: options.adapter,
+            status: adapterState.status,
+            activeTurnOrigin: adapterState.activeTurnOrigin,
+            hasPendingConfirmation: Boolean(state.pendingConfirmation),
+            hasSystemCommand: Boolean(systemCommand),
+        }),
+        onUnauthorized: async () => undefined,
+        handleCommand: async () => false,
+        remindPendingApproval: async () => {
+            await queueWechatMessage(message.senderId, formatPendingApprovalReminder(stateStore.getState().pendingConfirmation, adapter.getState()));
+        },
+        remindPendingUserInput: async () => {
+            const pendingUserInput = stateStore.getState().pendingUserInput;
+            await queueWechatMessage(message.senderId, pendingUserInput
+                ? formatPendingUserInputReminder(pendingUserInput)
+                : `${options.adapter} is waiting for structured input. Reply with /answer <key>=<value> ...`);
+        },
+        remindBusy: async () => {
+            const currentState = adapter.getState();
+            if ((options.adapter === "codex" || options.adapter === "opencode" || options.adapter === "pi") &&
+                currentState.activeTurnOrigin === "local") {
+                await queueWechatMessage(message.senderId, `${options.adapter === "opencode" ? "OpenCode" : options.adapter === "pi" ? "Pi" : "codex"} is currently busy with a local terminal turn. Wait for it to finish or use /stop.`);
+                return;
+            }
+            await queueWechatMessage(message.senderId, `${options.adapter} is still working. Wait for the current reply or use /stop.`);
+        },
+        defer: async () => {
+            await deferInboundMessage(message);
+        },
+        dispatch: dispatchInboundText,
     });
+    return routeResult.kind === "dispatched" ? routeResult.result : null;
 }
-async function dispatchInboundWechatText(params) {
-    const { message, options, stateStore, adapter } = params;
-    const preview = formatInboundMessagePreview(message);
-    const activeTask = {
+function createActiveTask(message) {
+    return {
         startedAt: Date.now(),
-        inputPreview: truncatePreview(preview, 180),
+        inputPreview: truncatePreview(formatInboundMessagePreview(message), 180),
     };
+}
+async function dispatchInboundWechatText(params) {
+    const { message, options, channelDriver, stateStore, adapter } = params;
+    const preview = formatInboundMessagePreview(message);
+    const activeTask = params.activeTask ?? createActiveTask(message);
     stateStore.appendLog(`Forwarded input to ${options.adapter}: ${truncatePreview(preview)}`);
-    await adapter.sendInput(buildWechatInboundPrompt(message.text, message.attachments));
+    await adapter.sendInput(channelDriver.buildInboundPrompt(message.text, message.attachments));
     return activeTask;
 }
-const isDirectRun = Boolean(import.meta.main);
+const isDirectRun = isDirectModuleRun(import.meta.url, process.argv, import.meta.main);
 if (isDirectRun) {
     main().catch((err) => {
         logError(describeWechatTransportError(err));