cli-wechat-bridge 1.1.8 → 1.2.0

package/dist/daemon/wechat-daemon.js

@@ -1,4 +1,10 @@
 #!/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 fs from "node:fs";
 import net from "node:net";
 import path from "node:path";
@@ -12,16 +18,19 @@ import { readBridgeLockFile, } from "../bridge/bridge-state.js";
 import { getProcessRecordByPid, isWechatDaemonCommandLine, killProcessTreeSync, listWechatDaemonProcesses, reapOrphanedOpencodeProcesses, reapPeerBridgeProcesses, } from "../bridge/bridge-process-reaper.js";
 import { buildOneTimeCode, buildWechatInboundPrompt, formatApprovalMessage, formatDuration, formatMirroredUserInputMessage, formatPendingApprovalReminder, formatPendingUserInputReminder, formatSessionSwitchMessage, formatTaskFailedMessage, formatUserInputRequestMessage, MESSAGE_START_GRACE_MS, nowIso, OutputBatcher, parsePendingUserInputAnswerCommand, parseWechatControlCommand, truncatePreview, } from "../bridge/bridge-utils.js";
 import { ResumeSessionCoordinator, isWechatResumeEnabled, shouldForwardSessionSwitchEvent, } from "../bridge/bridge-session-resume.js";
-import { WECHAT_SEND_MAX_ATTEMPTS, computeWechatSendRetryDelayMs, formatUserFacingBridgeFatalError, formatUserFacingInboundError, formatWechatContextTokenStaleLogEntry, formatWechatSendFailureLogEntry, isWechatContextUnavailableError, isRetryableWechatSendError, shouldForwardBridgeEventToWechat, shouldSuppressCodexLocalThreadNotice, } from "../channels/wechat/wechat-forwarding.js";
+import { WECHAT_SEND_CONTEXTS, formatUserFacingBridgeFatalError, formatUserFacingInboundError, isWechatSendContext, shouldForwardBridgeEventToWechat, shouldSuppressCodexLocalThreadNotice, } from "../channels/wechat/wechat-forwarding.js";
 import { BRIDGE_LOCK_FILE, BRIDGE_LOG_FILE, appendBoundedLog, ensureChannelDataDir, migrateLegacyChannelFiles, } from "../wechat/channel-config.js";
 import { ensureWechatCredentials } from "../wechat/setup.js";
 import { formatBindCommandUsage, formatBindingsListMessage, isBindCommandPrefix, listBindings, loadEmojiBindings, parseEmojiBindingsCommand, removeBinding, resolveEmojiCommand, setBinding, } from "./emoji-bindings.js";
-import { classifyWechatTransportError, DEFAULT_LONG_POLL_TIMEOUT_MS, describeWechatTransportError, isWechatContextTokenStaleError, WeChatTransport, } from "../wechat/wechat-transport.js";
+import { classifyWechatTransportError, DEFAULT_LONG_POLL_TIMEOUT_MS, describeWechatTransportError, WeChatTransport, } from "../wechat/wechat-transport.js";
 import { getPendingChannelMessagesFile, getPendingWechatMessagesFile, PendingWechatMessageStore, } from "../channels/wechat/wechat-outbound-queue.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, InboundConversationContext, resolveConversationTarget, rollbackTurn, tryBeginTurn, } from "../core/conversation-routing.js";
+import { canDrainDeferredCodexInboundQueue, formatDeferredCodexInboundQueueMessage, isRetryableDeferredCodexDrainError, shouldDeferCodexInboundMessage, } from "../core/bridge-defer.js";
+import { InboundConversationContext } from "../core/conversation-routing.js";
+import { TurnCoordinator } from "../core/turn-coordinator.js";
+import { resolveDaemonOutboundTarget } from "../core/outbound-target.js";
 import { handleAdapterControl, invalidateModelSnapshot } from "../bridge/adapter-control.js";
 import { forwardBridgeEvent } from "../core/bridge-event-forwarder.js";
 import { isDirectModuleRun } from "../core/direct-run.js";
@@ -29,7 +38,8 @@ 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 { clearLocalCompanionEndpoint, clearLocalCompanionOccupancy, readLocalCompanionEndpoint, } from "../companion/local-companion-link.js";
 import { attachDaemonRequestListener, buildDaemonToken, clearDaemonEndpoint, DAEMON_PROTOCOL_VERSION, isPidAlive, readDaemonEndpoint, sendDaemonRequest, sendDaemonResponse, writeDaemonEndpoint, } from "./daemon-link.js";
 const MODULE_FILE = fileURLToPath(import.meta.url);
@@ -46,6 +56,7 @@ const DAEMON_TAKEOVER_FORCE_STOP_TIMEOUT_MS = 3_000;
 const DAEMON_TAKEOVER_STOP_POLL_MS = 250;
 const VISIBLE_CLIENT_CONNECT_TIMEOUT_MS = 15_000;
 const VISIBLE_CLIENT_CONNECT_POLL_MS = 250;
+const MAX_DAEMON_DEFERRED_INPUTS = 32;
 const DAEMON_ADAPTERS = ["codex", "claude", "opencode", "pi"];
 function getCliChannelId(argv = process.argv.slice(2)) {
     const index = argv.indexOf("--channel");
@@ -66,22 +77,6 @@ function computePollRetryDelayMs(consecutiveFailures) {
     const exponent = Math.min(normalizedFailures - 1, 5);
     return Math.min(POLL_RETRY_MAX_MS, POLL_RETRY_BASE_MS * 2 ** exponent);
 }
-function toWecomOutputKind(context) {
-    switch (context) {
-        case "notice":
-        case "thinking":
-        case "final_reply":
-        case "approval_required":
-        case "user_input_required":
-        case "task_failed":
-        case "fatal_error":
-            return context;
-        case "mirrored_user_input":
-            return "mirrored_input";
-        default:
-            return "notice";
-    }
-}
 function toWechatSendContext(kind) {
     if (kind === "mirrored_input") {
         return "mirrored_user_input";
@@ -552,11 +547,12 @@ export function formatDaemonStatus(status) {
     }
     return lines.join("\n");
 }
-class WechatDaemon {
+export class WechatDaemon {
     cwd;
     profile;
     authorizedUserId;
     transport;
+    channelDriver;
     channelId;
     wecomTransport;
     inboundConversationContext = new InboundConversationContext();
@@ -568,11 +564,14 @@ class WechatDaemon {
     bridgeStartedAtMs = Date.now();
     backlogNoticeSent = false;
     activeAdapter = null;
+    activeAdapterVersion = 0;
     takenOverAdapter;
     textSendChain = Promise.resolve();
     attachmentSendChain = Promise.resolve();
     pendingWechatForwardTasks = new Set();
+    slotInputChains = new Map();
     pendingWechatMessages;
+    deps;
     shutdownPromise = null;
     ipcServer = null;
     endpointToken = "";
@@ -583,15 +582,37 @@ class WechatDaemon {
         this.transport = params.transport;
         this.channelId = params.channelId ?? "wechat";
         this.wecomTransport = params.wecomTransport ?? null;
-        this.fallbackConversation = {
-            channelId: this.channelId,
-            conversationId: params.authorizedUserId,
-            recipientId: params.authorizedUserId,
-            metadata: this.channelId === "wecom" ? { chatType: "direct" } : undefined,
-        };
-        this.pendingWechatMessages = new PendingWechatMessageStore(this.channelId === "wechat"
-            ? getPendingWechatMessagesFile(this.cwd)
-            : getPendingChannelMessagesFile(this.cwd, this.channelId));
+        this.deps = params.deps ?? {};
+        this.channelDriver = this.wecomTransport
+            ? new WecomChannelDriver({
+                transport: this.wecomTransport,
+                accountId: params.accountId,
+                operatorId: params.authorizedUserId,
+                logError,
+            })
+            : new WechatChannelDriver({
+                transport: this.transport,
+                logError,
+                buildInboundPrompt: (text, attachments) => buildWechatInboundPrompt(text, attachments.filter((attachment) => attachment.kind === "image" || attachment.kind === "file")),
+            });
+        this.fallbackConversation = this.channelDriver.defaultConversation()
+            ?? this.channelDriver.directConversation(params.authorizedUserId);
+        this.pendingWechatMessages = this.deps.pendingWechatMessages ??
+            new PendingWechatMessageStore(this.channelId === "wechat"
+                ? getPendingWechatMessagesFile(this.cwd)
+                : getPendingChannelMessagesFile(this.cwd, this.channelId));
+    }
+    daemonLog(message) {
+        (this.deps.daemonLog ?? appendDaemonLog)(message);
+    }
+    createRuntime(options) {
+        return (this.deps.createRuntime ?? createRuntimeHost)(options);
+    }
+    isVisibleClientAlive(cwd, adapter) {
+        return (this.deps.isVisibleClientAlive ?? isVisibleClientAlive)(cwd, adapter);
+    }
+    openVisibleClient(options) {
+        return (this.deps.openVisibleClient ?? openVisibleClient)(options);
     }
     async startIpcServer() {
         this.endpointToken = buildDaemonToken();
@@ -677,9 +698,9 @@ class WechatDaemon {
     }
     async runPollLoop() {
         let consecutivePollFailures = 0;
-        if (this.wecomTransport) {
-            this.wecomTransport.setHandlers({
-                onMessage: async (channelMessage) => {
+        if (this.channelDriver.start) {
+            await this.channelDriver.start({
+                onInboundMessage: async (channelMessage) => {
                     if (this.shutdownPromise) {
                         return;
                     }
@@ -690,33 +711,35 @@ class WechatDaemon {
                         await this.handleInboundMessage(toLegacyInboundWechatMessage(channelMessage));
                     });
                 },
-                onUnauthorized: async (senderId, chatType) => {
+                onUnauthorizedSender: async (senderId, chatType) => {
                     appendDaemonLog(`wecom_unauthorized: sender=${senderId} chat_type=${chatType}`);
                     if (chatType === "direct") {
-                        await this.wecomTransport.sendText({
-                            channelId: "wecom",
-                            conversationId: senderId,
-                            recipientId: senderId,
-                            metadata: { chatType: "direct" },
-                        }, "Unauthorized.", "notice");
+                        const result = await this.channelDriver.sendText({
+                            target: this.channelDriver.directConversation(senderId),
+                            text: "Unauthorized.",
+                            context: "notice",
+                            log: appendDaemonLog,
+                        });
+                        if (result.status !== "sent") {
+                            logError(`Failed to reply unauthorized notice to ${senderId}`);
+                        }
                     }
                 },
-                onFatal: async (error) => {
+                onChannelFatal: async (error) => {
                     appendDaemonLog(`wecom_fatal_error: ${error.message}`);
                     await this.shutdown();
                 },
-                onConnected: async () => {
+                onChannelConnected: async () => {
                     if (this.pendingWechatMessages.list().length > 0) {
                         await this.flushPendingWechatMessages();
                     }
                 },
             });
-            this.wecomTransport.start();
-            await this.wecomTransport.waitUntilConnected();
+            await this.channelDriver.waitUntilReady?.();
         }
-        log(`${this.channelId === "wecom" ? "WeCom" : "WeChat"} daemon is ready.`);
+        log(`${this.channelDriver.displayName} daemon is ready.`);
         log(`Working directory: ${this.cwd}`);
-        log(`Switch from ${this.channelId === "wecom" ? "WeCom" : "WeChat"} with /codex, /claude, /opencode, or /pi.`);
+        log(`Switch from ${this.channelDriver.displayName} with /codex, /claude, /opencode, or /pi.`);
         appendDaemonLog(`started: channel=${this.channelId} cwd=${this.cwd}`);
         const activeSlot = this.getActiveSlot();
         const welcomeText = t("daemon.welcome", {
@@ -725,7 +748,7 @@ class WechatDaemon {
             bindings: formatBindingsListMessage(listBindings()),
         });
         await this.queueWechatMessage(this.authorizedUserId, welcomeText);
-        if (this.channelId === "wecom") {
+        if (this.channelDriver.capabilities.pushInbound) {
             while (!this.shutdownPromise) {
                 await delay(1_000);
             }
@@ -835,6 +858,12 @@ class WechatDaemon {
         catch {
             // Best effort shutdown.
         }
+        try {
+            await this.channelDriver.endAllTyping?.();
+        }
+        catch {
+            // Best effort shutdown.
+        }
         try {
             this.wecomTransport?.stop();
         }
@@ -901,6 +930,244 @@ class WechatDaemon {
                     sessionStartMode: request.sessionStartMode,
                     reuseExistingVisible: request.reuseExistingVisible ?? true,
                 });
+            case "send_text":
+                return await this.handleDaemonSendText(request);
+            case "forward_input":
+                return await this.handleDaemonForwardInput(request);
+        }
+    }
+    async handleDaemonSendText(request) {
+        if (!request.text.trim()) {
+            throw new Error("send_text requires non-empty text.");
+        }
+        if (request.channel && request.channel !== this.channelId) {
+            throw new Error(`${this.channelId}-daemon cannot send to ${request.channel}.`);
+        }
+        const context = request.context ?? "message";
+        if (!isWechatSendContext(context)) {
+            throw new Error(`Invalid send_text context: ${JSON.stringify(request.context)}. Valid contexts: ${WECHAT_SEND_CONTEXTS.join(", ")}.`);
+        }
+        const target = this.channelDriver.capabilities.multiConversation
+            ? {
+                ...this.channelDriver.directConversation(request.recipientId),
+                ...(request.conversationId && request.conversationId !== request.recipientId
+                    ? { conversationId: request.conversationId }
+                    : {}),
+                ...(request.metadata ? { metadata: request.metadata } : {}),
+            }
+            : undefined;
+        const sent = await this.queueWechatMessage(request.recipientId, request.text, context, target);
+        return {
+            sent,
+            recipientId: request.recipientId,
+            ...(request.conversationId ? { conversationId: request.conversationId } : {}),
+        };
+    }
+    getSlotState(adapter) {
+        const slot = this.slots.get(adapter);
+        if (!slot)
+            return null;
+        return {
+            active: this.activeAdapter === adapter,
+            hasActiveTask: slot.turns.hasActiveTask,
+            ...(slot.turns.activeConversation?.conversationId
+                ? { activeConversationId: slot.turns.activeConversation.conversationId }
+                : {}),
+            ...(slot.turns.lastConversation?.conversationId
+                ? { lastConversationId: slot.turns.lastConversation.conversationId }
+                : {}),
+        };
+    }
+    async handleDaemonForwardInput(request) {
+        if (!request.text.trim()) {
+            throw new Error("forward_input requires non-empty text.");
+        }
+        if (request.cwd && !isSameWorkspaceCwd(request.cwd, this.cwd)) {
+            throw new Error(`${this.channelId}-daemon is bound to ${this.cwd}; requested cwd was ${request.cwd}.`);
+        }
+        const adapter = request.adapter ?? this.activeAdapter;
+        if (!adapter) {
+            throw new Error("No active adapter slot is available.");
+        }
+        const senderId = request.senderId ?? this.authorizedUserId;
+        const conversationId = request.conversationId ?? senderId;
+        const conversation = {
+            channelId: this.channelId,
+            conversationId,
+            recipientId: request.recipientId ?? senderId,
+            ...(request.contextToken ? { opaqueRef: request.contextToken } : {}),
+            ...(request.metadata ? { metadata: request.metadata } : {}),
+        };
+        const previousActiveAdapter = this.activeAdapter;
+        const ensureResult = await this.ensureSlot(adapter, {
+            openVisible: true,
+            reuseExistingVisible: true,
+        });
+        if (!ensureResult.activated) {
+            return {
+                forwarded: false,
+                adapter,
+                conversationId,
+                reason: "not_activated",
+                message: formatDaemonSwitchResultDetail(ensureResult),
+            };
+        }
+        const slot = this.slots.get(adapter);
+        if (!slot) {
+            throw new Error(`Adapter slot ${adapter} is not available.`);
+        }
+        const inboundMessage = {
+            senderId,
+            sender: senderId,
+            sessionId: conversationId,
+            text: request.text,
+            attachments: [],
+            contextToken: request.contextToken,
+            createdAt: new Date().toISOString(),
+            createdAtMs: Date.now(),
+        };
+        try {
+            const routed = await this.serializeSlotInput(slot, () => this.inboundConversationContext.run(conversation, () => this.routeDaemonInput(slot, inboundMessage, conversation)));
+            if (routed.kind === "dispatched") {
+                return { forwarded: true, adapter, conversationId };
+            }
+            this.restoreActiveAdapterAfterRejectedInput(adapter, ensureResult.activationVersion, previousActiveAdapter);
+            return {
+                forwarded: false,
+                ...(routed.queued ? { queued: true } : {}),
+                ...(routed.queuePosition !== undefined ? { queuePosition: routed.queuePosition } : {}),
+                adapter,
+                conversationId,
+                reason: routed.reason,
+                message: routed.message,
+            };
+        }
+        catch (error) {
+            this.restoreActiveAdapterAfterRejectedInput(adapter, ensureResult.activationVersion, previousActiveAdapter);
+            throw error;
+        }
+    }
+    async routeDaemonInput(slot, inboundMessage, conversation) {
+        const runtimeState = slot.runtime.getState();
+        const adapterState = slot.turns.hasActiveTask && runtimeState.status === "idle"
+            ? { ...runtimeState, status: "busy" }
+            : runtimeState;
+        let reason;
+        let routeMessage;
+        let queued = false;
+        let queuePosition;
+        const sendReminder = (text, context) => this.queueWechatMessage(inboundMessage.senderId, text, context, conversation);
+        const routeResult = await routeBridgeMessage({
+            message: toChannelInboundMessage(inboundMessage),
+            authorized: true,
+            command: null,
+            adapterState,
+            hasPendingApproval: slot.pendingConfirmations.length > 0,
+            hasPendingUserInput: Boolean(slot.pendingUserInput),
+            shouldDefer: shouldDeferCodexInboundMessage({
+                adapter: slot.adapter,
+                status: adapterState.status,
+                activeTurnOrigin: adapterState.activeTurnOrigin,
+                hasPendingConfirmation: slot.pendingConfirmations.length > 0,
+                hasSystemCommand: false,
+            }),
+            onUnauthorized: async () => undefined,
+            handleCommand: async () => false,
+            remindPendingApproval: async () => {
+                routeMessage = prefixDaemonAdapterMessage(slot.adapter, formatPendingApprovalReminder(slot.pendingConfirmations[0], slot.runtime.getState()));
+                reason = "pending_approval";
+                await sendReminder(routeMessage, "approval_required");
+            },
+            remindPendingUserInput: async () => {
+                routeMessage = prefixDaemonAdapterMessage(slot.adapter, slot.pendingUserInput
+                    ? formatPendingUserInputReminder(slot.pendingUserInput)
+                    : `${slot.adapter} is waiting for structured input. Reply with /answer <key>=<value> ...`);
+                reason = "pending_user_input";
+                await sendReminder(routeMessage, "user_input_required");
+            },
+            remindBusy: async () => {
+                routeMessage = prefixDaemonAdapterMessage(slot.adapter, `${slot.adapter} is still working. Wait for the current reply or use /stop.`);
+                reason = "busy";
+                await sendReminder(routeMessage, "notice");
+            },
+            defer: async () => {
+                if (slot.deferredInputs.length >= MAX_DAEMON_DEFERRED_INPUTS) {
+                    routeMessage = prefixDaemonAdapterMessage(slot.adapter, `The deferred input queue is full (${MAX_DAEMON_DEFERRED_INPUTS}). Wait for the current local turn to finish before retrying.`);
+                    reason = "busy";
+                    await sendReminder(routeMessage, "notice");
+                    return;
+                }
+                slot.deferredInputs.push({ message: inboundMessage, conversation });
+                queuePosition = slot.deferredInputs.length;
+                queued = true;
+                reason = "deferred";
+                routeMessage = prefixDaemonAdapterMessage(slot.adapter, formatDeferredCodexInboundQueueMessage(queuePosition));
+                await sendReminder(routeMessage, "notice");
+                this.daemonLog(`deferred_inbound_input: adapter=${slot.adapter} position=${queuePosition} text=${truncatePreview(inboundMessage.text)}`);
+            },
+            dispatch: async () => {
+                await this.dispatchInboundWechatText(inboundMessage, slot, conversation);
+            },
+        });
+        if (routeResult.kind === "dispatched") {
+            return { kind: "dispatched" };
+        }
+        return {
+            kind: routeResult.kind,
+            reason: reason ?? (routeResult.kind === "deferred" ? "deferred" : "busy"),
+            message: routeMessage,
+            ...(queued ? { queued: true } : {}),
+            ...(queuePosition !== undefined ? { queuePosition } : {}),
+        };
+    }
+    restoreActiveAdapterAfterRejectedInput(adapter, activationVersion, previousActiveAdapter) {
+        if (this.activeAdapter === adapter && this.activeAdapterVersion === activationVersion) {
+            this.activeAdapter = previousActiveAdapter;
+            this.activeAdapterVersion += 1;
+        }
+    }
+    serializeSlotInput(slot, task) {
+        const tail = this.slotInputChains.get(slot.adapter) ?? Promise.resolve();
+        const run = tail.then(task, task);
+        this.slotInputChains.set(slot.adapter, run.then(() => undefined, () => undefined));
+        return run;
+    }
+    async maybeDrainDeferredInputs(slot) {
+        if (slot.drainingDeferredInputs)
+            return;
+        const state = slot.runtime.getState();
+        if (!canDrainDeferredCodexInboundQueue({
+            adapter: slot.adapter,
+            deferredCount: slot.deferredInputs.length,
+            status: state.status,
+            activeTurnId: state.activeTurnId,
+            hasPendingConfirmation: slot.pendingConfirmations.length > 0,
+            hasPendingUserInput: Boolean(slot.pendingUserInput),
+            hasPendingApproval: Boolean(state.pendingApproval),
+            hasActiveTask: slot.turns.hasActiveTask,
+        }))
+            return;
+        const next = slot.deferredInputs.shift();
+        if (!next)
+            return;
+        slot.drainingDeferredInputs = true;
+        try {
+            const routed = await this.inboundConversationContext.run(next.conversation ?? this.fallbackConversation, () => this.routeDaemonInput(slot, next.message, next.conversation ?? this.fallbackConversation));
+            if (routed.kind !== "dispatched") {
+                slot.deferredInputs.unshift(next);
+            }
+        }
+        catch (error) {
+            const errorText = error instanceof Error ? error.message : String(error);
+            if (isRetryableDeferredCodexDrainError(errorText)) {
+                slot.deferredInputs.unshift(next);
+            }
+            else {
+                await this.queueWechatMessage(next.message.senderId, formatUserFacingInboundError({ adapter: slot.adapter, cwd: this.cwd, errorText }), "inbound_error", next.conversation);
+            }
+        }
+        finally {
+            slot.drainingDeferredInputs = false;
         }
     }
     async ensureSlot(adapter, options = {}) {
@@ -941,7 +1208,7 @@ class WechatDaemon {
             visibleEndpointBeforeProbe?.companionConnectedAt ||
             visibleEndpointBeforeProbe?.sharedThreadId ||
             visibleEndpointBeforeProbe?.sharedSessionId);
-        let visibleConnected = isVisibleClientAlive(this.cwd, adapter);
+        let visibleConnected = this.isVisibleClientAlive(this.cwd, adapter);
         if (shouldRestartDeadCodexVisibleRuntime({
             adapter,
             slotCreated: created,
@@ -970,8 +1237,9 @@ class WechatDaemon {
             appendDaemonLog(`fresh_session_started: adapter=${adapter} source=start_command`);
         }
         if (options.openVisible !== false && !visibleConnected) {
+            const visibleClientTimeoutMs = this.deps.visibleClientConnectTimeoutMs ?? VISIBLE_CLIENT_CONNECT_TIMEOUT_MS;
             slot.controller.syncLocalClientEndpoint();
-            const launch = openVisibleClient({
+            const launch = this.openVisibleClient({
                 adapter,
                 cwd: this.cwd,
                 // A freshly prepared blank thread is semantically a new session, but
@@ -989,14 +1257,17 @@ class WechatDaemon {
             visibleConnected = await waitForVisibleClientConnection({
                 cwd: this.cwd,
                 adapter,
+                timeoutMs: this.deps.visibleClientConnectTimeoutMs,
+            }, {
+                isAlive: (cwd, adapter) => this.isVisibleClientAlive(cwd, adapter),
             });
             if (visibleConnected) {
                 appendDaemonLog(`visible_client_connected: adapter=${adapter} cwd=${this.cwd}`);
             }
             else {
-                log(`${adapter} visible CLI did not connect within ${formatDuration(VISIBLE_CLIENT_CONNECT_TIMEOUT_MS)}. Check ${BRIDGE_LOG_FILE}.`);
+                log(`${adapter} visible CLI did not connect within ${formatDuration(visibleClientTimeoutMs)}. Check ${BRIDGE_LOG_FILE}.`);
                 const cleanedLauncher = cleanupVisibleClientLauncher(launch);
-                appendDaemonLog(`visible_client_connect_timeout: adapter=${adapter} cwd=${this.cwd} timeout_ms=${VISIBLE_CLIENT_CONNECT_TIMEOUT_MS} cleaned_launcher=${cleanedLauncher}`);
+                appendDaemonLog(`visible_client_connect_timeout: adapter=${adapter} cwd=${this.cwd} timeout_ms=${visibleClientTimeoutMs} cleaned_launcher=${cleanedLauncher}`);
             }
         }
         let visibleReady = visibleConnected;
@@ -1024,6 +1295,7 @@ class WechatDaemon {
             if (previousSlot && this.activeAdapter !== adapter)
                 invalidateModelSnapshot(previousSlot.runtime);
             this.activeAdapter = adapter;
+            this.activeAdapterVersion += 1;
         }
         appendDaemonLog(`switch_adapter: adapter=${adapter} created=${created} opened_visible=${openedVisible} visible_connected=${visibleConnected} visible_ready=${visibleReady} activated=${activated} previous_active=${previousActiveAdapter ?? "(none)"} session_start_mode=${sessionStartMode}`);
         return {
@@ -1033,12 +1305,13 @@ class WechatDaemon {
             visibleConnected,
             visibleReady,
             activated,
+            activationVersion: this.activeAdapterVersion,
             previousActiveAdapter,
         };
     }
     async createSlot(adapter, options) {
         clearLocalCompanionEndpoint(this.cwd, undefined, { adapter });
-        const runtime = createRuntimeHost({
+        const runtime = this.createRuntime({
             kind: adapter,
             command: resolveDefaultAdapterCommand(adapter),
             cwd: this.cwd,
@@ -1061,10 +1334,14 @@ class WechatDaemon {
                 adapter,
                 runtime,
             }),
-            activeTask: null,
+            turns: new TurnCoordinator({
+                restoreLastConversationOnFailure: true,
+            }),
             lastOutputAt: 0,
             lastFinalReplyAtMs: 0,
             eventForwardChain: Promise.resolve(),
+            deferredInputs: [],
+            drainingDeferredInputs: false,
         };
         runtime.setEventSink((event) => {
             this.handleSlotEvent(slot, event);
@@ -1079,7 +1356,7 @@ class WechatDaemon {
         slot.outputBatcher.clear();
         slot.pendingConfirmations = [];
         slot.pendingUserInput = null;
-        clearTurn(slot);
+        slot.turns.complete();
         if (slot.adapter === "codex" || slot.adapter === "claude") {
             await slot.runtime.reset();
         }
@@ -1121,10 +1398,10 @@ class WechatDaemon {
         slot.controller.syncLocalClientEndpoint();
         const adapterState = slot.runtime.getState();
         const channelPort = this.createWechatChannelPort(slot.adapter);
-        const eventTarget = this.channelId === "wecom"
+        const eventTarget = this.channelDriver.capabilities.multiConversation
             ? this.resolveSlotOutputTarget(slot)
             : this.fallbackConversation;
-        const eventTask = slot.activeTask;
+        const eventTask = slot.turns.activeTask;
         if (slot.pendingConfirmations.length > 0 && !adapterState.pendingApproval) {
             slot.pendingConfirmations = [];
         }
@@ -1146,6 +1423,7 @@ class WechatDaemon {
                 }
             },
             finalReply: (next) => {
+                void this.channelDriver.endTyping?.(this.authorizedUserId);
                 slot.lastFinalReplyAtMs = Date.now();
                 appendDaemonLog(`final_reply: adapter=${slot.adapter} text=${truncatePreview(next.text)}`);
                 this.trackWechatForwardTask(slot.outputBatcher.flushNow().then(async () => {
@@ -1225,32 +1503,38 @@ class WechatDaemon {
                 }
             },
             taskComplete: () => {
+                void this.channelDriver.endTyping?.(this.authorizedUserId);
                 this.trackWechatForwardTask(slot.outputBatcher.flushNow().then(() => {
                     slot.pendingConfirmations = [];
                     slot.pendingUserInput = null;
                     if (eventTask) {
-                        clearTurn(slot, eventTask);
+                        slot.turns.complete(eventTask);
                     }
+                    void this.maybeDrainDeferredInputs(slot);
                 }));
             },
             taskFailed: (next) => {
+                void this.channelDriver.endTyping?.(this.authorizedUserId);
                 this.trackWechatForwardTask(slot.outputBatcher.flushNow().then(async () => {
                     slot.pendingConfirmations = [];
                     slot.pendingUserInput = null;
                     if (eventTask) {
-                        clearTurn(slot, eventTask);
+                        slot.turns.complete(eventTask);
                     }
+                    void this.maybeDrainDeferredInputs(slot);
                     await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(slot.adapter, formatTaskFailedMessage(slot.adapter, next.message)), "task_failed", eventTarget);
                 }));
             },
             fatalError: (next) => {
+                void this.channelDriver.endTyping?.(this.authorizedUserId);
                 logError(`${slot.adapter}: ${next.message}`);
                 appendDaemonLog(`fatal_error: adapter=${slot.adapter} message=${next.message}`);
                 slot.pendingConfirmations = [];
                 slot.pendingUserInput = null;
                 if (eventTask) {
-                    clearTurn(slot, eventTask);
+                    slot.turns.complete(eventTask);
                 }
+                void this.maybeDrainDeferredInputs(slot);
                 this.disposeDeadSlot(slot);
                 this.trackWechatForwardTask(slot.outputBatcher.flushNow().then(async () => {
                     await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(slot.adapter, formatUserFacingBridgeFatalError(next.message)), "fatal_error", eventTarget);
@@ -1266,24 +1550,18 @@ class WechatDaemon {
         });
     }
     resolveSlotOutputTarget(slot) {
-        return resolveConversationTarget({
-            active: slot.activeConversation,
-            last: slot.lastConversation,
-            fallback: this.fallbackConversation,
-        });
+        return slot.turns.resolveTarget(this.fallbackConversation);
     }
     bindCurrentWecomConversation(slot) {
         const conversation = this.inboundConversationContext.get();
-        if (this.channelId !== "wecom" || !slot || !conversation) {
+        if (!this.channelDriver.capabilities.multiConversation || !slot || !conversation) {
             return;
         }
-        slot.lastConversation = conversation;
+        slot.turns.observeConversation(conversation);
     }
     async handleInboundMessage(message) {
         if (message.senderId !== this.authorizedUserId) {
-            await this.queueWechatMessage(message.senderId, this.channelId === "wecom"
-                ? "Unauthorized. This daemon only accepts messages from the paired WeCom operator."
-                : "Unauthorized. This daemon only accepts messages from the configured WeChat owner.");
+            await this.queueWechatMessage(message.senderId, `Unauthorized. This daemon only accepts messages from ${this.channelDriver.operatorDescription}.`);
             return;
         }
         const emojiMatch = resolveEmojiCommand(message.text);
@@ -1354,7 +1632,7 @@ class WechatDaemon {
         }
         this.bindCurrentWecomConversation(slot);
         const routeCurrentMessage = async (currentSlot, command) => {
-            const previousTask = currentSlot.activeTask;
+            const previousTask = currentSlot.turns.activeTask;
             await routeBridgeMessage({
                 message: toChannelInboundMessage(message),
                 authorized: true,
@@ -1383,13 +1661,12 @@ class WechatDaemon {
                     await this.dispatchInboundWechatText(message, currentSlot);
                 },
             });
-            if (this.channelId === "wecom" &&
+            if (this.channelDriver.capabilities.multiConversation &&
                 this.inboundConversationContext.get() &&
-                currentSlot.activeTask &&
-                currentSlot.activeTask !== previousTask) {
+                currentSlot.turns.activeTask &&
+                currentSlot.turns.activeTask !== previousTask) {
                 const conversation = this.inboundConversationContext.get();
-                currentSlot.activeConversation = conversation;
-                currentSlot.lastConversation = conversation;
+                currentSlot.turns.bindConversation(conversation);
             }
         };
         const command = parseWechatControlCommand(message.text, {
@@ -1448,7 +1725,7 @@ class WechatDaemon {
                 return;
             case "resume": {
                 if (!isWechatResumeEnabled(activeSlot.adapter)) {
-                    await this.queueWechatMessage(message.senderId, `${this.channelId === "wecom" ? "WeCom" : "WeChat"} /resume is disabled for ${activeSlot.adapter} in daemon mode. Use /resume directly inside the visible terminal; the remote channel will follow that local session.`);
+                    await this.queueWechatMessage(message.senderId, `${this.channelDriver.displayName} /resume is disabled for ${activeSlot.adapter} in daemon mode. Use /resume directly inside the visible terminal; the remote channel will follow that local session.`);
                     return;
                 }
                 try {
@@ -1466,10 +1743,10 @@ class WechatDaemon {
                     if (command.target) {
                         await resumeSlot.outputBatcher.flushNow();
                     }
-                    const taskBeforeResume = resumeSlot.activeTask;
+                    const taskBeforeResume = resumeSlot.turns.activeTask;
                     const result = await resumeSlot.resumeCoordinator.execute(command.target);
                     if (result.kind === "resumed" && taskBeforeResume) {
-                        clearTurn(resumeSlot, taskBeforeResume);
+                        resumeSlot.turns.complete(taskBeforeResume);
                     }
                     await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(resumeSlot.adapter, result.message));
                 }
@@ -1491,6 +1768,9 @@ class WechatDaemon {
                 await activeSlot.runtime.createSession();
                 appendDaemonLog(`new_session: adapter=${activeSlot.adapter}`);
                 return;
+            case "broadcast":
+                await this.handleBroadcastCommand(message, command.text);
+                return;
             case "stop": {
                 const interrupted = await activeSlot.runtime.interrupt();
                 await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(activeSlot.adapter, interrupted
@@ -1532,10 +1812,10 @@ class WechatDaemon {
         }
         const preview = slot.pendingConfirmations[0]?.commandPreview ?? "";
         slot.pendingConfirmations = [];
-        slot.activeTask = {
+        slot.turns.setActiveTask({
             startedAt: Date.now(),
             inputPreview: preview,
-        };
+        });
         appendDaemonLog(`approval_confirmed: adapter=${slot.adapter} count=${count} command=${truncatePreview(preview)}`);
         await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(slot.adapter, count > 1
             ? `${count} approvals confirmed. Continuing...`
@@ -1581,10 +1861,10 @@ class WechatDaemon {
             return;
         }
         slot.pendingUserInput = null;
-        slot.activeTask = {
+        slot.turns.setActiveTask({
             startedAt: Date.now(),
             inputPreview: parsed.preview,
-        };
+        });
         appendDaemonLog(`user_input_answered: adapter=${slot.adapter} preview=${parsed.preview}`);
         await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(slot.adapter, "Answer submitted. Continuing..."));
     }
@@ -1606,30 +1886,79 @@ class WechatDaemon {
         }
         return this.slots.get(this.activeAdapter) ?? null;
     }
-    async dispatchInboundWechatText(message, slot) {
+    isSlotBusyForBroadcast(slot) {
+        const state = slot.runtime.getState();
+        if (slot.turns.hasActiveTask)
+            return true;
+        if (slot.pendingConfirmations.length > 0 || slot.pendingUserInput)
+            return true;
+        if (slot.deferredInputs.length > 0)
+            return true;
+        if (state.status === "busy" || state.status === "awaiting_approval" || state.status === "awaiting_input") {
+            return true;
+        }
+        return false;
+    }
+    async handleBroadcastCommand(message, text) {
+        const startedSlots = DAEMON_ADAPTERS
+            .map((adapter) => this.slots.get(adapter))
+            .filter((slot) => Boolean(slot));
+        if (startedSlots.length === 0) {
+            await this.queueWechatMessage(message.senderId, "/all needs at least one running adapter. Open one first with /codex, /claude, /opencode, or /pi.");
+            return;
+        }
+        const busySlots = startedSlots.filter((slot) => this.isSlotBusyForBroadcast(slot));
+        if (busySlots.length > 0) {
+            const names = busySlots.map((slot) => slot.adapter).join(", ");
+            appendDaemonLog(`broadcast_canceled_busy: busy=[${names}]`);
+            await this.queueWechatMessage(message.senderId, `/all canceled: ${busySlots.length > 1 ? "these workers are" : "this worker is"} still busy — ${names}. Wait for the current replies or use /stop first.`);
+            return;
+        }
+        const broadcastMessage = { ...message, text };
+        const dispatched = [];
+        const skipped = [];
+        for (const adapter of DAEMON_ADAPTERS) {
+            const slot = this.slots.get(adapter);
+            if (!slot) {
+                skipped.push(adapter);
+                continue;
+            }
+            appendDaemonLog(`broadcast_input: adapter=${adapter} text=${truncatePreview(text)}`);
+            await this.dispatchInboundWechatText(broadcastMessage, slot);
+            dispatched.push(adapter);
+        }
+        const lines = [
+            `Broadcast dispatched to ${dispatched.length} ${dispatched.length > 1 ? "workers" : "worker"}: ${dispatched.join(", ")}. Each reply arrives prefixed with its adapter name.`,
+        ];
+        if (skipped.length > 0) {
+            lines.push(`Not started (skipped): ${skipped.join(", ")}. Start them with their /command to include them next time.`);
+        }
+        await this.queueWechatMessage(message.senderId, lines.join("\n"));
+    }
+    async dispatchInboundWechatText(message, slot, conversationOverride) {
         const preview = formatInboundMessagePreview(message);
         const nextTask = {
             startedAt: Date.now(),
             inputPreview: truncatePreview(preview, 180),
         };
-        const inboundConversation = this.channelId === "wecom"
-            ? this.inboundConversationContext.get()
+        const inboundConversation = this.channelDriver.capabilities.multiConversation
+            ? conversationOverride ?? this.inboundConversationContext.get()
             : undefined;
-        const lease = tryBeginTurn(slot, nextTask, inboundConversation);
-        if (!lease) {
-            await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(slot.adapter, `${slot.adapter} is still working. Wait for the current reply or use /stop.`));
-            return;
-        }
-        appendDaemonLog(`forwarded_input: adapter=${slot.adapter} text=${truncatePreview(preview)}`);
-        try {
-            await slot.runtime.sendInput(this.channelId === "wecom"
-                ? buildWecomInboundPrompt(message.text, message.attachments)
-                : buildWechatInboundPrompt(message.text, message.attachments));
-        }
-        catch (error) {
-            rollbackTurn(slot, lease);
-            throw error;
+        const dispatchResult = await slot.turns.dispatch({
+            task: nextTask,
+            conversation: inboundConversation,
+            onBusy: async () => {
+                await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(slot.adapter, `${slot.adapter} is still working. Wait for the current reply or use /stop.`), "notice", conversationOverride);
+            },
+            forward: async () => {
+                appendDaemonLog(`forwarded_input: adapter=${slot.adapter} text=${truncatePreview(preview)}`);
+                await slot.runtime.sendInput(this.channelDriver.buildInboundPrompt(message.text, message.attachments));
+            },
+        });
+        if (dispatchResult.status === "dispatched") {
+            void this.channelDriver.beginTyping?.(message.senderId);
         }
+        return dispatchResult;
     }
     queueWechatTextAction(action) {
         const run = this.textSendChain.then(action);
@@ -1642,88 +1971,36 @@ class WechatDaemon {
         return run;
     }
     async sendWechatMessageNow(senderId, text, context = "message", targetOverride) {
-        if (this.channelId === "wecom") {
-            const activeSlot = this.getActiveSlot();
-            const target = targetOverride ??
-                (senderId === this.authorizedUserId
-                    ? this.inboundConversationContext.get() ??
-                        (activeSlot ? this.resolveSlotOutputTarget(activeSlot) : this.fallbackConversation)
-                    : {
-                        channelId: "wecom",
-                        conversationId: senderId,
-                        recipientId: senderId,
-                        metadata: { chatType: "direct" },
-                    });
-            const startedAtMs = Date.now();
-            appendDaemonLog(`wecom_send_started: context=${context} recipient=${target.recipientId} chars=${Array.from(text).length}`);
-            try {
-                await this.wecomTransport.sendText(target, formatWecomVisibleText(text), toWecomOutputKind(context));
-                appendDaemonLog(`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);
-                appendDaemonLog(`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();
-        appendDaemonLog(`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 this.transport.sendText(senderId, text);
-                appendDaemonLog(`wechat_send_completed: context=${context} recipient=${senderId} attempt=${attempt} elapsed_ms=${Date.now() - startedAtMs}`);
-                return { status: "sent" };
-            }
-            catch (error) {
-                if (error instanceof Error && error.name === "AbortError") {
-                    appendDaemonLog(`wechat_send_timeout: context=${context} recipient=${senderId} attempt=${attempt} elapsed_ms=${Date.now() - startedAtMs}`);
-                }
-                if (isWechatContextUnavailableError(error)) {
-                    if (isWechatContextTokenStaleError(error)) {
-                        this.transport.clearCachedContextToken(senderId);
-                    }
-                    appendDaemonLog(isWechatContextTokenStaleError(error)
-                        ? formatWechatContextTokenStaleLogEntry({
-                            context,
-                            recipientId: senderId,
-                            error,
-                        })
-                        : formatWechatSendFailureLogEntry({
-                            context,
-                            recipientId: senderId,
-                            error,
-                        }));
-                    return { status: "context_unavailable", error };
-                }
-                if (attempt < WECHAT_SEND_MAX_ATTEMPTS && isRetryableWechatSendError(error)) {
-                    const delayMs = computeWechatSendRetryDelayMs(attempt);
-                    appendDaemonLog(`wechat_send_retry: context=${context} recipient=${senderId} attempt=${attempt} delay_ms=${delayMs} error=${truncatePreview(describeWechatTransportError(error), 400)}`);
-                    await delay(delayMs);
-                    continue;
-                }
-                logError(`Failed to send WeChat ${context}: ${describeWechatTransportError(error)}`);
-                appendDaemonLog(formatWechatSendFailureLogEntry({
-                    context,
-                    recipientId: senderId,
-                    error,
-                }));
-                return { status: "failed" };
-            }
-        }
-        return { status: "failed" };
+        const activeSlot = this.getActiveSlot();
+        const target = resolveDaemonOutboundTarget({
+            senderId,
+            operatorId: this.authorizedUserId,
+            override: targetOverride,
+            multiConversation: this.channelDriver.capabilities.multiConversation,
+            inboundConversation: this.channelDriver.capabilities.multiConversation
+                ? this.inboundConversationContext.get()
+                : null,
+            activeSlotTarget: activeSlot ? this.resolveSlotOutputTarget(activeSlot) : null,
+            fallbackConversation: this.fallbackConversation,
+            directConversation: (id) => this.channelDriver.directConversation(id),
+        });
+        return this.channelDriver.sendText({
+            target,
+            text,
+            context,
+            log: appendDaemonLog,
+        });
     }
     queueWechatMessage(senderId, text, context = "message", targetOverride) {
         const activeSlot = this.getActiveSlot();
-        const queuedTarget = this.channelId === "wecom" && senderId === this.authorizedUserId
+        const queuedTarget = this.channelDriver.capabilities.multiConversation && senderId === this.authorizedUserId
             ? targetOverride ??
                 this.inboundConversationContext.get() ??
                 (activeSlot ? this.resolveSlotOutputTarget(activeSlot) : this.fallbackConversation)
             : targetOverride;
         return this.queueWechatTextAction(async () => {
             const result = await this.sendWechatMessageNow(senderId, text, context, queuedTarget);
-            if (result.status === "context_unavailable") {
+            if (result.status === "target_stale") {
                 const pending = this.pendingWechatMessages.enqueue(senderId, text, context, result.target);
                 if (pending) {
                     appendDaemonLog(`wechat_send_queued: id=${pending.id} context=${context} recipient=${senderId} pending=${this.pendingWechatMessages.list().length}`);
@@ -1741,7 +2018,7 @@ class WechatDaemon {
                     appendDaemonLog(`wechat_pending_sent: id=${pending.id} context=${pending.context} recipient=${pending.recipientId}`);
                     continue;
                 }
-                if (result.status === "context_unavailable") {
+                if (result.status === "target_stale") {
                     break;
                 }
                 appendDaemonLog(`wechat_pending_retryable_failure: id=${pending.id} context=${pending.context} recipient=${pending.recipientId}`);
@@ -2085,6 +2362,7 @@ export async function runDaemon(options) {
         authorizedUserId: credentials.userId,
         transport: new WeChatTransport({ log, logError }),
         channelId: options.channelId,
+        accountId: wecomAccount?.botId,
         wecomTransport: wecomAccount
             ? new WecomTransport({
                 account: wecomAccount,