cli-wechat-bridge 1.1.8 → 1.2.0

package/dist/bridge/wechat-bridge.js

@@ -1,18 +1,26 @@
 #!/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 { ResumeSessionCoordinator, isWechatResumeEnabled, shouldForwardSessionSwitchEvent, } from "./bridge-session-resume.js";
-import { WECHAT_SEND_MAX_ATTEMPTS, computeWechatSendRetryDelayMs, formatUserFacingBridgeFatalError, formatUserFacingInboundError, formatWechatContextTokenStaleLogEntry, formatWechatSendFailureLogEntry, formatWechatSendRetryLogEntry, isWechatContextUnavailableError, isRetryableWechatSendError, shouldForwardBridgeEventToWechat, shouldSuppressCodexLocalThreadNotice, } from "../channels/wechat/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 { clearTurn, resolveConversationTarget, rollbackTurn, tryBeginTurn, } from "../core/conversation-routing.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";
@@ -20,9 +28,10 @@ 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 { buildWecomInboundPrompt, formatWecomVisibleText, } from "../channels/wecom/wecom-message.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";
@@ -80,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;
@@ -191,24 +176,6 @@ export function parseCliArgs(argv) {
         channelId,
     };
 }
-function toWecomOutputKind(context) {
-    const known = new Set([
-        "status",
-        "notice",
-        "thinking",
-        "final_reply",
-        "approval_required",
-        "user_input_required",
-        "mirrored_input",
-        "task_failed",
-        "fatal_error",
-    ]);
-    return known.has(context)
-        ? context
-        : context === "mirrored_user_input"
-            ? "mirrored_input"
-            : "notice";
-}
 function toWechatSendContext(kind) {
     if (kind === "mirrored_input") {
         return "mirrored_user_input";
@@ -285,6 +252,18 @@ async function main() {
             },
         })
         : 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 竞态。
@@ -363,17 +342,13 @@ async function main() {
     let textSendChain = Promise.resolve();
     let attachmentSendChain = Promise.resolve();
     const pendingWechatForwardTasks = new Set();
-    const defaultWecomConversation = {
-        channelId: "wecom",
-        accountId: wecomAccount?.botId,
-        conversationId: credentials.userId,
-        recipientId: credentials.userId,
-        metadata: { chatType: "direct" },
-    };
-    const turnState = {
-        activeTask: null,
-        lastConversation: defaultWecomConversation,
-    };
+    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;
@@ -389,101 +364,28 @@ async function main() {
         return run;
     };
     const sendWechatMessageNow = async (senderId, text, context = "message", targetOverride) => {
-        if (options.channelId === "wecom") {
-            const target = targetOverride ??
-                (senderId === credentials.userId
-                    ? resolveConversationTarget({
-                        active: turnState.activeConversation,
-                        last: turnState.lastConversation,
-                        fallback: defaultWecomConversation,
-                    })
-                    : {
-                        channelId: "wecom",
-                        accountId: wecomAccount?.botId,
-                        conversationId: senderId,
-                        recipientId: senderId,
-                        metadata: { chatType: "direct" },
-                    });
-            const startedAtMs = Date.now();
-            stateStore.appendLog(`wecom_send_started: context=${context} recipient=${target.recipientId} chars=${Array.from(text).length}`);
-            try {
-                await wecomTransport.sendText(target, formatWecomVisibleText(text), toWecomOutputKind(context));
-                stateStore.appendLog(`wecom_send_completed: context=${context} recipient=${target.recipientId} elapsed_ms=${Date.now() - startedAtMs}`);
-                return { status: "sent" };
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                stateStore.appendLog(`wecom_send_failed: context=${context} recipient=${target.recipientId} error=${truncatePreview(message, 400)}`);
-                logError(`Failed to send WeCom ${context}: ${message}`);
-                return { status: "context_unavailable", error, target };
-            }
-        }
-        const startedAtMs = Date.now();
-        stateStore.appendLog(`wechat_send_started: context=${context} recipient=${senderId} chars=${Array.from(text).length}`);
-        for (let attempt = 1; attempt <= WECHAT_SEND_MAX_ATTEMPTS; attempt += 1) {
-            try {
-                await transport.sendText(senderId, text);
-                stateStore.appendLog(`wechat_send_completed: context=${context} recipient=${senderId} attempt=${attempt} elapsed_ms=${Date.now() - startedAtMs}`);
-                return { status: "sent" };
-            }
-            catch (err) {
-                if (err instanceof Error && err.name === "AbortError") {
-                    stateStore.appendLog(`wechat_send_timeout: context=${context} recipient=${senderId} attempt=${attempt} elapsed_ms=${Date.now() - startedAtMs}`);
-                }
-                if (isWechatContextUnavailableError(err)) {
-                    if (isWechatContextTokenStaleError(err)) {
-                        transport.clearCachedContextToken(senderId);
-                    }
-                    const hint = "WeChat conversation context is stale or unavailable. 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(isWechatContextTokenStaleError(err)
-                        ? formatWechatContextTokenStaleLogEntry({
-                            context,
-                            recipientId: senderId,
-                            error: err,
-                        })
-                        : formatWechatSendFailureLogEntry({
-                            context,
-                            recipientId: senderId,
-                            error: err,
-                        }));
-                    return { status: "context_unavailable", error: err };
-                }
-                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 { status: "failed" };
-            }
-        }
-        return { status: "failed" };
+        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 = options.channelId === "wecom" && senderId === credentials.userId
-            ? targetOverride ?? resolveConversationTarget({
-                active: turnState.activeConversation,
-                last: turnState.lastConversation,
-                fallback: defaultWecomConversation,
-            })
+        const queuedTarget = senderId === operatorId && channelDriver.capabilities.multiConversation
+            ? targetOverride ?? turns.resolveTarget(operatorConversation)
             : targetOverride;
         return queueWechatTextAction(async () => {
             const result = await sendWechatMessageNow(senderId, text, context, queuedTarget);
-            if (result.status === "context_unavailable") {
+            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}`);
@@ -501,7 +403,7 @@ async function main() {
                     stateStore.appendLog(`wechat_pending_sent: id=${pending.id} context=${pending.context} recipient=${pending.recipientId}`);
                     continue;
                 }
-                if (result.status === "context_unavailable") {
+                if (result.status === "target_stale") {
                     break;
                 }
                 stateStore.appendLog(`wechat_pending_retryable_failure: id=${pending.id} context=${pending.context} recipient=${pending.recipientId}`);
@@ -526,12 +428,8 @@ async function main() {
         }
     };
     const outputBatcher = new OutputBatcher(async (text) => {
-        await queueWechatMessage(stateStore.getState().authorizedUserId, text, "message", options.channelId === "wecom"
-            ? resolveConversationTarget({
-                active: turnState.activeConversation,
-                last: turnState.lastConversation,
-                fallback: defaultWecomConversation,
-            })
+        await queueWechatMessage(stateStore.getState().authorizedUserId, text, "message", channelDriver.capabilities.multiConversation
+            ? turns.resolveTarget(operatorConversation)
             : undefined);
     });
     const maybeDrainDeferredInboundMessages = async () => {
@@ -547,7 +445,7 @@ async function main() {
             hasPendingConfirmation: Boolean(stateStore.getState().pendingConfirmation),
             hasPendingUserInput: Boolean(stateStore.getState().pendingUserInput),
             hasPendingApproval: Boolean(adapterState.pendingApproval),
-            hasActiveTask: Boolean(turnState.activeTask),
+            hasActiveTask: turns.hasActiveTask,
         })) {
             return;
         }
@@ -559,7 +457,7 @@ async function main() {
         try {
             stateStore.appendLog(`draining_deferred_inbound_input: remaining=${deferredInboundMessages.length} text=${truncatePreview(nextDeferred.message.text)}`);
             const nextTask = createActiveTask(nextDeferred.message);
-            const lease = tryBeginTurn(turnState, nextTask, nextDeferred.channelMessage?.conversation);
+            const lease = turns.beginTurn(nextTask, nextDeferred.channelMessage?.conversation);
             if (!lease) {
                 deferredInboundMessages.unshift(nextDeferred);
                 return;
@@ -567,6 +465,7 @@ async function main() {
             try {
                 await dispatchInboundWechatText({
                     message: nextDeferred.message,
+                    channelDriver,
                     options,
                     stateStore,
                     adapter,
@@ -574,7 +473,7 @@ async function main() {
                 });
             }
             catch (error) {
-                rollbackTurn(turnState, lease);
+                turns.rollback(lease);
                 throw error;
             }
         }
@@ -664,6 +563,12 @@ async function main() {
         catch {
             // Best effort shutdown.
         }
+        try {
+            await channelDriver.endAllTyping?.();
+        }
+        catch {
+            // Best effort shutdown.
+        }
         controller.clearLocalClientEndpoint();
         stateStore.releaseLock();
     };
@@ -732,6 +637,7 @@ async function main() {
     try {
         wireAdapterEvents({
             adapter,
+            channelDriver,
             resumeCoordinator,
             options,
             transport,
@@ -741,10 +647,10 @@ async function main() {
             queueWechatMessage,
             trackWechatForwardTask,
             maybeDrainDeferredInboundMessages,
-            getActiveTask: () => turnState.activeTask,
+            getActiveTask: () => turns.activeTask,
             clearActiveTask: (expectedTask) => {
                 if (expectedTask) {
-                    clearTurn(turnState, expectedTask);
+                    turns.complete(expectedTask);
                 }
             },
             syncSharedSessionState: () => {
@@ -755,11 +661,7 @@ async function main() {
             },
             requestShutdown,
             wecomTransport,
-            getWecomTarget: () => resolveConversationTarget({
-                active: turnState.activeConversation,
-                last: turnState.lastConversation,
-                fallback: defaultWecomConversation,
-            }),
+            getWecomTarget: () => turns.resolveTarget(operatorConversation),
         });
         await adapter.start();
         if (!ensureRuntimeOwnership()) {
@@ -768,24 +670,25 @@ async function main() {
         syncSharedSessionState(stateStore, adapter);
         controller.syncLocalClientEndpoint();
         stateStore.appendLog(`Bridge started with channel=${options.channelId} adapter=${options.adapter} command=${options.command} cwd=${options.cwd}`);
-        if (wecomTransport) {
-            wecomTransport.setHandlers({
-                onMessage: async (channelMessage) => {
+        if (channelDriver.start) {
+            await channelDriver.start({
+                onInboundMessage: async (channelMessage) => {
                     if (shutdownPromise || !ensureRuntimeOwnership()) {
                         return;
                     }
-                    turnState.lastConversation = channelMessage.conversation;
+                    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 = turnState.activeTask;
+                    const taskAtMessageStart = turns.activeTask;
                     stateStore.touchActivity(message.createdAt);
                     try {
                         await handleInboundMessage({
                             message,
                             channelMessage,
+                            channelDriver,
                             options,
                             stateStore,
                             adapter,
@@ -794,30 +697,32 @@ async function main() {
                             outputBatcher,
                             clearActiveTask: () => {
                                 if (taskAtMessageStart) {
-                                    clearTurn(turnState, taskAtMessageStart);
+                                    turns.complete(taskAtMessageStart);
                                 }
                             },
                             dispatchInboundText: async () => {
                                 const nextActiveTask = createActiveTask(message);
-                                const lease = tryBeginTurn(turnState, nextActiveTask, channelMessage.conversation);
-                                if (!lease) {
-                                    await queueInboundReply(message.senderId, `${options.adapter} is still working. Wait for the current reply or use /stop.`);
-                                    return null;
-                                }
-                                try {
-                                    await dispatchInboundWechatText({
-                                        message,
-                                        options,
-                                        stateStore,
-                                        adapter,
-                                        activeTask: nextActiveTask,
-                                    });
-                                    return nextActiveTask;
-                                }
-                                catch (error) {
-                                    rollbackTurn(turnState, lease);
-                                    throw error;
+                                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({
@@ -842,37 +747,38 @@ async function main() {
                     syncSharedSessionState(stateStore, adapter);
                     await maybeDrainDeferredInboundMessages();
                 },
-                onUnauthorized: async (senderId, chatType) => {
+                onUnauthorizedSender: async (senderId, chatType) => {
                     stateStore.appendLog(`wecom_unauthorized: sender=${senderId} chat_type=${chatType}`);
                     if (chatType === "direct") {
-                        await wecomTransport.sendText({
-                            channelId: "wecom",
-                            accountId: wecomAccount.botId,
-                            conversationId: senderId,
-                            recipientId: senderId,
-                            metadata: { chatType: "direct" },
-                        }, "Unauthorized.", "notice");
+                        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}`);
+                        }
                     }
                 },
-                onFatal: async (error) => {
+                onChannelFatal: async (error) => {
                     stateStore.appendLog(`wecom_fatal_error: ${error.message}`);
                     requestShutdown(error.message, 1);
                 },
-                onConnected: async () => {
+                onChannelConnected: async () => {
                     if (pendingWechatMessages.list().length > 0) {
                         await flushPendingWechatMessages();
                     }
                 },
             });
-            wecomTransport.start();
-            await wecomTransport.waitUntilConnected();
+            await channelDriver.waitUntilReady?.();
         }
-        log(`${options.channelId === "wecom" ? "WeCom" : "WeChat"} bridge is ready for adapter "${options.adapter}".`);
+        log(`${channelDriver.displayName} bridge is ready for adapter "${options.adapter}".`);
         log(`Working directory: ${options.cwd}`);
         if (options.profile) {
             log(`Profile: ${options.profile}`);
         }
-        log(`Authorized ${options.channelId === "wecom" ? "WeCom" : "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");
         }
@@ -890,7 +796,7 @@ async function main() {
             cwd: options.cwd,
         });
         await queueWechatMessage(credentials.userId, welcomeText);
-        if (options.channelId === "wecom") {
+        if (channelDriver.capabilities.pushInbound) {
             while (!shutdownPromise && ensureRuntimeOwnership()) {
                 await delay(1_000);
             }
@@ -956,11 +862,12 @@ async function main() {
                 if (!ensureRuntimeOwnership()) {
                     break;
                 }
-                const taskAtMessageStart = turnState.activeTask;
+                const taskAtMessageStart = turns.activeTask;
                 stateStore.touchActivity(message.createdAt);
                 try {
                     await handleInboundMessage({
                         message,
+                        channelDriver,
                         options,
                         stateStore,
                         adapter,
@@ -969,30 +876,31 @@ async function main() {
                         outputBatcher,
                         clearActiveTask: () => {
                             if (taskAtMessageStart) {
-                                clearTurn(turnState, taskAtMessageStart);
+                                turns.complete(taskAtMessageStart);
                             }
                         },
                         dispatchInboundText: async () => {
                             const nextActiveTask = createActiveTask(message);
-                            const lease = tryBeginTurn(turnState, nextActiveTask);
-                            if (!lease) {
-                                await queueWechatMessage(message.senderId, `${options.adapter} is still working. Wait for the current reply or use /stop.`);
-                                return null;
-                            }
-                            try {
-                                await dispatchInboundWechatText({
-                                    message,
-                                    options,
-                                    stateStore,
-                                    adapter,
-                                    activeTask: nextActiveTask,
-                                });
-                                return nextActiveTask;
-                            }
-                            catch (error) {
-                                rollbackTurn(turnState, lease);
-                                throw error;
+                            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({
@@ -1047,7 +955,7 @@ function syncSharedSessionState(stateStore, adapter) {
     }
 }
 function wireAdapterEvents(params) {
-    const { adapter, resumeCoordinator, options, transport, stateStore, outputBatcher, queueWechatAttachmentAction, queueWechatMessage, trackWechatForwardTask, maybeDrainDeferredInboundMessages, getActiveTask, clearActiveTask, syncSharedSessionState, syncLocalClientEndpoint, requestShutdown, wecomTransport, getWecomTarget, } = 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,
@@ -1083,13 +991,9 @@ function wireAdapterEvents(params) {
             stateStore.clearPendingUserInput();
         }
         const authorizedUserId = stateStore.getState().authorizedUserId;
-        const eventTarget = options.channelId === "wecom"
+        const eventTarget = channelDriver.capabilities.multiConversation
             ? getWecomTarget()
-            : {
-                channelId: "wechat",
-                conversationId: authorizedUserId,
-                recipientId: authorizedUserId,
-            };
+            : channelDriver.directConversation(authorizedUserId);
         const eventTask = getActiveTask();
         eventForwardChain = eventForwardChain
             .then(() => forwardBridgeEvent(event, {
@@ -1104,6 +1008,7 @@ function wireAdapterEvents(params) {
                 }
             },
             finalReply: (next) => {
+                void channelDriver.endTyping?.(authorizedUserId);
                 lastFinalReplyAtMs = Date.now();
                 stateStore.appendLog(`final_reply: ${truncatePreview(next.text)}`);
                 trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
@@ -1136,7 +1041,7 @@ function wireAdapterEvents(params) {
                     if (thinkingPreview) {
                         stateStore.appendLog(`thinking: ${thinkingPreview}`);
                         trackWechatForwardTask((async () => {
-                            await queueWechatMessage(authorizedUserId, options.channelId === "wecom"
+                            await queueWechatMessage(authorizedUserId, channelDriver.id === "wecom"
                                 ? `Processing: ${thinkingPreview}`
                                 : `思考: ${thinkingPreview}`, "thinking", eventTarget);
                         })());
@@ -1197,6 +1102,7 @@ function wireAdapterEvents(params) {
                 void maybeDrainDeferredInboundMessages();
             },
             taskComplete: () => {
+                void channelDriver.endTyping?.(authorizedUserId);
                 trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                     stateStore.clearPendingConfirmation();
                     stateStore.clearPendingUserInput();
@@ -1205,6 +1111,7 @@ function wireAdapterEvents(params) {
                 }));
             },
             taskFailed: (next) => {
+                void channelDriver.endTyping?.(authorizedUserId);
                 trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                     stateStore.clearPendingConfirmation();
                     stateStore.clearPendingUserInput();
@@ -1214,6 +1121,7 @@ function wireAdapterEvents(params) {
                 }));
             },
             fatalError: (next) => {
+                void channelDriver.endTyping?.(authorizedUserId);
                 logError(next.message);
                 stateStore.appendLog(`fatal_error: ${next.message}`);
                 stateStore.clearPendingConfirmation();
@@ -1248,13 +1156,11 @@ function formatInboundMessagePreview(message) {
     return "(empty)";
 }
 async function handleInboundMessage(params) {
-    const { message, channelMessage, } = 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, options.channelId === "wecom"
-            ? "Unauthorized. This bridge only accepts messages from the paired WeCom operator."
-            : "Unauthorized. This bridge only accepts messages from the configured WeChat owner.");
+        await queueWechatMessage(message.senderId, `Unauthorized. This bridge only accepts messages from ${channelDriver.operatorDescription}.`);
         return null;
     }
     const systemCommand = parseWechatControlCommand(message.text, {
@@ -1267,12 +1173,15 @@ async function handleInboundMessage(params) {
         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, `${options.channelId === "wecom" ? "WeCom" : "WeChat"} /resume is disabled in ${options.adapter} mode. Use /resume directly inside "${options.channelId}-${options.adapter}"; the remote channel 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 {
@@ -1432,13 +1341,11 @@ function createActiveTask(message) {
     };
 }
 async function dispatchInboundWechatText(params) {
-    const { message, options, stateStore, adapter } = 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(options.channelId === "wecom"
-        ? buildWecomInboundPrompt(message.text, message.attachments)
-        : buildWechatInboundPrompt(message.text, message.attachments));
+    await adapter.sendInput(channelDriver.buildInboundPrompt(message.text, message.attachments));
     return activeTask;
 }
 const isDirectRun = isDirectModuleRun(import.meta.url, process.argv, import.meta.main);