@unlinearity/cli-wechat-bridge 1.1.5 → 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";
@@ -8,17 +14,32 @@ import { resolveDefaultAdapterCommand, } from "../bridge/bridge-adapters.js";
 import { t } from "../i18n/index.js";
 import { delay, getSharedSessionIdFromAdapterState, quoteWindowsCommandArg, } from "../bridge/bridge-adapters.shared.js";
 import { BridgeController } from "../bridge/bridge-controller.js";
-import { forwardWechatFinalReply } from "../bridge/bridge-final-reply.js";
 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, isRetryableWechatSendError, shouldForwardBridgeEventToWechat, } from "../bridge/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 { 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";
+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 { 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);
@@ -35,12 +56,17 @@ 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");
+    return index >= 0 && argv[index + 1] === "wecom" ? "wecom" : "wechat";
+}
 function log(message) {
-    process.stderr.write(`[wechat-daemon] ${message}\n`);
+    process.stderr.write(`[${getCliChannelId()}-daemon] ${message}\n`);
 }
 function logError(message) {
-    process.stderr.write(`[wechat-daemon] ERROR: ${message}\n`);
+    process.stderr.write(`[${getCliChannelId()}-daemon] ERROR: ${message}\n`);
 }
 function appendDaemonLog(message) {
     ensureChannelDataDir();
@@ -51,6 +77,32 @@ function computePollRetryDelayMs(consecutiveFailures) {
     const exponent = Math.min(normalizedFailures - 1, 5);
     return Math.min(POLL_RETRY_MAX_MS, POLL_RETRY_BASE_MS * 2 ** exponent);
 }
+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 isDaemonAdapterKind(value) {
     return value === "codex" || value === "claude" || value === "opencode" || value === "pi";
 }
@@ -72,6 +124,7 @@ export function parseDaemonCliArgs(argv) {
     let profile;
     let initialAdapter;
     let openVisible = true;
+    let channelId = "wechat";
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
         if (!arg) {
@@ -80,10 +133,10 @@ export function parseDaemonCliArgs(argv) {
         const next = argv[i + 1];
         if (arg === "--help" || arg === "-h") {
             process.stdout.write([
-                "Usage: wechat-daemon [--cwd <path>] [--adapter <codex|claude|opencode|pi>] [--profile <name-or-path>] [--no-open]",
+                `Usage: ${channelId}-daemon [--cwd <path>] [--adapter <codex|claude|opencode|pi>] [--profile <name-or-path>] [--no-open]`,
                 "",
-                "Keeps one WeChat connection alive and switches between Codex, Claude Code, OpenCode, and Pi from WeChat.",
-                "Send /codex, /claude, /opencode, or /pi in WeChat to switch the active terminal.",
+                `Keeps one ${channelId === "wecom" ? "WeCom" : "WeChat"} connection alive and switches between Codex, Claude Code, OpenCode, and Pi.`,
+                `Send /codex, /claude, /opencode, or /pi in ${channelId === "wecom" ? "WeCom" : "WeChat"} to switch the active terminal.`,
                 "",
             ].join("\n"));
             process.exit(0);
@@ -96,6 +149,14 @@ export function parseDaemonCliArgs(argv) {
             i += 1;
             continue;
         }
+        if (arg === "--channel") {
+            if (!next || (next !== "wechat" && next !== "wecom")) {
+                throw new Error(`Invalid channel: ${next ?? "(missing)"}`);
+            }
+            channelId = next;
+            i += 1;
+            continue;
+        }
         if (arg === "--adapter") {
             if (!isDaemonAdapterKind(next)) {
                 throw new Error(`Invalid adapter: ${next ?? "(missing)"}`);
@@ -118,7 +179,13 @@ export function parseDaemonCliArgs(argv) {
         }
         throw new Error(`Unknown argument: ${arg}`);
     }
-    return { cwd, profile, initialAdapter, openVisible };
+    return {
+        cwd,
+        profile,
+        initialAdapter,
+        openVisible,
+        ...(channelId === "wecom" ? { channelId } : {}),
+    };
 }
 export function parseDaemonSwitchCommand(text) {
     const normalized = text.trim().toLowerCase();
@@ -147,8 +214,13 @@ export function parseDaemonSwitchDirective(text) {
         remainder: match[2]?.trim() ?? "",
     };
 }
-export function defaultDaemonSessionStartMode(adapter) {
-    return adapter === "codex" ? "restore" : "new";
+export function defaultDaemonSessionStartMode(_adapter) {
+    // Codex 0.155+ persists app-server threads lazily, so resuming a freshly
+    // prepared (not yet persisted) thread crashes the visible TUI bootstrap
+    // with "no rollout found". Every adapter therefore opens a fresh session
+    // by default; explicit --session-start-mode restore and WeChat /resume
+    // remain available for deliberate restores of persisted threads.
+    return "new";
 }
 export function resolveDaemonSessionStartMode(params) {
     // An explicit --session-start-mode wins over visible-client reuse: the user
@@ -161,9 +233,6 @@ export function resolveDaemonSessionStartMode(params) {
     if (params.reuseExistingVisible && params.visibleConnected) {
         return "restore";
     }
-    if (params.adapter === "codex") {
-        return "restore";
-    }
     if (params.slotCreated) {
         return "new";
     }
@@ -217,7 +286,7 @@ export function buildVisibleClientLaunchArgs(params) {
 export function buildWindowsVisibleClientLaunchCommand(params) {
     return [
         "start",
-        quoteWindowsCommandArg(`wechat-${params.adapter}`),
+        quoteWindowsCommandArg(`${params.channelId ?? "wechat"}-${params.adapter}`),
         "/D",
         quoteWindowsCommandArg(params.cwd),
         quoteWindowsCommandArg(process.execPath),
@@ -265,6 +334,7 @@ function openVisibleClient(params) {
                 adapter: params.adapter,
                 cwd: params.cwd,
                 args,
+                channelId: params.channelId,
             }),
         ];
         const child = spawn(command, launchArgs, {
@@ -285,13 +355,13 @@ function openVisibleClient(params) {
             pid: child.pid,
         };
     }
-    const title = `wechat-${params.adapter}`;
+    const title = `${params.channelId ?? "wechat"}-${params.adapter}`;
     const fullArgs = [process.execPath, ...args];
     if (process.platform === "darwin") {
         const cmdLine = fullArgs.map(shellQuotePosix).join(" ");
-        const script = `tell application "Terminal"
-activate
-do script "cd ${shellQuotePosix(params.cwd)} && exec ${cmdLine}"
+        const script = `tell application "Terminal"
+activate
+do script "cd ${shellQuotePosix(params.cwd)} && exec ${cmdLine}"
 end tell`;
         const child = spawn("osascript", ["-e", script], {
             cwd: params.cwd,
@@ -477,11 +547,16 @@ export function formatDaemonStatus(status) {
     }
     return lines.join("\n");
 }
-class WechatDaemon {
+export class WechatDaemon {
     cwd;
     profile;
     authorizedUserId;
     transport;
+    channelDriver;
+    channelId;
+    wecomTransport;
+    inboundConversationContext = new InboundConversationContext();
+    fallbackConversation;
     slots = new Map();
     // Per-adapter serialization chains for ensureSlot (see ensureSlot comment).
     slotEnsureChains = new Map();
@@ -489,10 +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 = "";
@@ -501,6 +580,39 @@ class WechatDaemon {
         this.profile = params.profile;
         this.authorizedUserId = params.authorizedUserId;
         this.transport = params.transport;
+        this.channelId = params.channelId ?? "wechat";
+        this.wecomTransport = params.wecomTransport ?? null;
+        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();
@@ -548,6 +660,7 @@ class WechatDaemon {
                     token: this.endpointToken,
                     cwd: this.cwd,
                     startedAt: this.startedAt,
+                    channelId: this.channelId,
                 });
                 resolve();
             });
@@ -556,6 +669,7 @@ class WechatDaemon {
     getStatus() {
         return {
             cwd: this.cwd,
+            channelId: this.channelId,
             activeAdapter: this.activeAdapter ?? undefined,
             startedAt: this.startedAt,
             slots: Array.from(this.slots.values()).map((slot) => {
@@ -584,10 +698,49 @@ class WechatDaemon {
     }
     async runPollLoop() {
         let consecutivePollFailures = 0;
-        log("WeChat daemon is ready.");
+        if (this.channelDriver.start) {
+            await this.channelDriver.start({
+                onInboundMessage: async (channelMessage) => {
+                    if (this.shutdownPromise) {
+                        return;
+                    }
+                    await this.inboundConversationContext.run(channelMessage.conversation, async () => {
+                        if (this.pendingWechatMessages.list().length > 0) {
+                            await this.flushPendingWechatMessages();
+                        }
+                        await this.handleInboundMessage(toLegacyInboundWechatMessage(channelMessage));
+                    });
+                },
+                onUnauthorizedSender: async (senderId, chatType) => {
+                    appendDaemonLog(`wecom_unauthorized: sender=${senderId} chat_type=${chatType}`);
+                    if (chatType === "direct") {
+                        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}`);
+                        }
+                    }
+                },
+                onChannelFatal: async (error) => {
+                    appendDaemonLog(`wecom_fatal_error: ${error.message}`);
+                    await this.shutdown();
+                },
+                onChannelConnected: async () => {
+                    if (this.pendingWechatMessages.list().length > 0) {
+                        await this.flushPendingWechatMessages();
+                    }
+                },
+            });
+            await this.channelDriver.waitUntilReady?.();
+        }
+        log(`${this.channelDriver.displayName} daemon is ready.`);
         log(`Working directory: ${this.cwd}`);
-        log("Switch from WeChat with /codex, /claude, /opencode, or /pi.");
-        appendDaemonLog(`started: cwd=${this.cwd}`);
+        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", {
             cwd: this.cwd,
@@ -595,6 +748,13 @@ class WechatDaemon {
             bindings: formatBindingsListMessage(listBindings()),
         });
         await this.queueWechatMessage(this.authorizedUserId, welcomeText);
+        if (this.channelDriver.capabilities.pushInbound) {
+            while (!this.shutdownPromise) {
+                await delay(1_000);
+            }
+            await this.shutdownPromise;
+            return;
+        }
         while (!this.shutdownPromise) {
             let pollResult;
             try {
@@ -624,6 +784,9 @@ class WechatDaemon {
                 appendDaemonLog(`poll_recovered: failures=${consecutivePollFailures}`);
                 consecutivePollFailures = 0;
             }
+            if (pollResult.messages.length > 0 && this.pendingWechatMessages.list().length > 0) {
+                await this.flushPendingWechatMessages();
+            }
             if (pollResult.ignoredBacklogCount > 0) {
                 appendDaemonLog(`ignored_startup_backlog: count=${pollResult.ignoredBacklogCount}`);
                 if (!this.backlogNoticeSent) {
@@ -685,6 +848,29 @@ class WechatDaemon {
     }
     async cleanup() {
         appendDaemonLog("shutdown_started");
+        // Stop accepting new channel work and abort an in-flight long poll before
+        // waiting for queued sends or adapter disposal. Otherwise Ctrl+C can leave
+        // the process alive until the 35-second poll timeout and retain the daemon
+        // endpoint for the next startup to clean up.
+        try {
+            this.transport.stop();
+        }
+        catch {
+            // Best effort shutdown.
+        }
+        try {
+            await this.channelDriver.endAllTyping?.();
+        }
+        catch {
+            // Best effort shutdown.
+        }
+        try {
+            this.wecomTransport?.stop();
+        }
+        catch {
+            // Best effort shutdown.
+        }
+        clearDaemonEndpoint();
         for (const slot of this.slots.values()) {
             try {
                 await slot.outputBatcher.flushNow();
@@ -727,7 +913,7 @@ class WechatDaemon {
                 return { shuttingDown: true };
             case "ensure_slot":
                 if (!isSameWorkspaceCwd(request.cwd, this.cwd)) {
-                    throw new Error(`wechat-daemon is bound to ${this.cwd}; requested cwd was ${request.cwd}.`);
+                    throw new Error(`${this.channelId}-daemon is bound to ${this.cwd}; requested cwd was ${request.cwd}.`);
                 }
                 return await this.ensureSlot(request.adapter, {
                     profile: request.profile,
@@ -744,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 = {}) {
@@ -784,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,
@@ -813,12 +1237,17 @@ 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
+                // the visible client must resume its id from the endpoint instead of
+                // creating a second thread of its own.
                 sessionStartMode,
                 cliArgs: options.cliArgs,
+                channelId: this.channelId,
                 onError: (error) => {
                     appendDaemonLog(`visible_client_open_error: adapter=${adapter} error=${truncatePreview(error.message, 400)}`);
                 },
@@ -828,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;
@@ -859,7 +1291,11 @@ class WechatDaemon {
         }
         const activated = options.openVisible === false || (visibleConnected && visibleReady);
         if (activated) {
+            const previousSlot = this.getActiveSlot();
+            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 {
@@ -869,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,
@@ -889,7 +1326,7 @@ class WechatDaemon {
             runtime,
             controller,
             outputBatcher: new OutputBatcher(async (text) => {
-                await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(adapter, text));
+                await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(adapter, text), "message", this.resolveSlotOutputTarget(slot));
             }),
             pendingConfirmations: [],
             pendingUserInput: null,
@@ -897,8 +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);
@@ -913,7 +1356,7 @@ class WechatDaemon {
         slot.outputBatcher.clear();
         slot.pendingConfirmations = [];
         slot.pendingUserInput = null;
-        slot.activeTask = null;
+        slot.turns.complete();
         if (slot.adapter === "codex" || slot.adapter === "claude") {
             await slot.runtime.reset();
         }
@@ -925,166 +1368,200 @@ class WechatDaemon {
         }
         slot.controller.syncLocalClientEndpoint();
     }
+    createWechatChannelPort(adapter) {
+        if (this.channelId === "wecom") {
+            return new WecomChannelPort({
+                transport: this.wecomTransport,
+                sendText: (target, text, kind) => this.queueWechatMessage(this.authorizedUserId, text, toWechatSendContext(kind), target),
+                prefixText: (currentAdapter, text) => prefixDaemonAdapterMessage(currentAdapter ?? adapter, text),
+                onEmptyVisibleReply: (currentAdapter, rawText) => {
+                    appendDaemonLog(`empty_visible_final_reply: adapter=${currentAdapter ?? adapter} raw=${truncatePreview(rawText)}`);
+                },
+            });
+        }
+        return new WechatChannelPort({
+            sendText: (recipientId, text, context) => this.queueWechatMessage(recipientId, text, context),
+            sendImage: (recipientId, filePath) => this.queueWechatAttachmentAction(() => this.transport.sendImage(filePath, { recipientId })),
+            sendFile: (recipientId, filePath) => this.queueWechatAttachmentAction(() => this.transport.sendFile(filePath, { recipientId })),
+            sendVoice: (recipientId, filePath) => this.queueWechatAttachmentAction(() => this.transport.sendVoice(filePath, recipientId)),
+            sendVideo: (recipientId, filePath) => this.queueWechatAttachmentAction(() => this.transport.sendVideo(filePath, { recipientId })),
+            prefixText: (currentAdapter, text) => prefixDaemonAdapterMessage(currentAdapter ?? adapter, text),
+            onEmptyVisibleReply: (currentAdapter, rawText) => {
+                appendDaemonLog(`empty_visible_final_reply: adapter=${currentAdapter ?? adapter} raw=${truncatePreview(rawText)}`);
+            },
+            onTextSent: (currentAdapter, text) => {
+                appendDaemonLog(`final_reply_sent: adapter=${currentAdapter ?? adapter} chars=${Array.from(text).length}`);
+            },
+        });
+    }
     handleSlotEvent(slot, event) {
         slot.controller.syncLocalClientEndpoint();
         const adapterState = slot.runtime.getState();
+        const channelPort = this.createWechatChannelPort(slot.adapter);
+        const eventTarget = this.channelDriver.capabilities.multiConversation
+            ? this.resolveSlotOutputTarget(slot)
+            : this.fallbackConversation;
+        const eventTask = slot.turns.activeTask;
         if (slot.pendingConfirmations.length > 0 && !adapterState.pendingApproval) {
             slot.pendingConfirmations = [];
         }
         if (slot.pendingUserInput && !adapterState.pendingUserInput) {
             slot.pendingUserInput = null;
         }
-        switch (event.type) {
-            case "stdout":
-            case "stderr":
+        slot.eventForwardChain = slot.eventForwardChain
+            .then(() => forwardBridgeEvent(event, {
+            stdout: (next) => {
                 slot.lastOutputAt = Date.now();
-                if (shouldForwardBridgeEventToWechat(slot.adapter, event.type)) {
-                    slot.outputBatcher.push(event.text);
+                if (shouldForwardBridgeEventToWechat(slot.adapter, next.type)) {
+                    slot.outputBatcher.push(next.text);
                 }
-                break;
-            case "final_reply":
-                appendDaemonLog(`final_reply: adapter=${slot.adapter} text=${truncatePreview(event.text)}`);
+            },
+            stderr: (next) => {
+                slot.lastOutputAt = Date.now();
+                if (shouldForwardBridgeEventToWechat(slot.adapter, next.type)) {
+                    slot.outputBatcher.push(next.text);
+                }
+            },
+            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 () => {
-                    await forwardWechatFinalReply({
+                    await channelPort.send({
+                        target: eventTarget,
+                        kind: "final_reply",
+                        text: next.text,
                         adapter: slot.adapter,
-                        rawText: event.text,
-                        onEmptyVisibleReply: ({ rawVisibleText }) => {
-                            appendDaemonLog(`empty_visible_final_reply: adapter=${slot.adapter} raw=${truncatePreview(rawVisibleText)}`);
-                        },
-                        sender: {
-                            sendText: async (text) => {
-                                const sent = await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(slot.adapter, text), "final_reply");
-                                if (sent) {
-                                    appendDaemonLog(`final_reply_sent: adapter=${slot.adapter} chars=${Array.from(text).length}`);
-                                }
-                                return sent;
-                            },
-                            sendImage: (imagePath) => this.queueWechatAttachmentAction(() => this.transport.sendImage(imagePath, {
-                                recipientId: this.authorizedUserId,
-                            })),
-                            sendFile: (filePath) => this.queueWechatAttachmentAction(() => this.transport.sendFile(filePath, {
-                                recipientId: this.authorizedUserId,
-                            })),
-                            sendVoice: (voicePath) => this.queueWechatAttachmentAction(() => this.transport.sendVoice(voicePath, this.authorizedUserId)),
-                            sendVideo: (videoPath) => this.queueWechatAttachmentAction(() => this.transport.sendVideo(videoPath, {
-                                recipientId: this.authorizedUserId,
-                            })),
-                        },
                     });
                 }));
-                break;
-            case "status":
-                if (event.message) {
-                    log(`${slot.adapter} ${event.status}: ${event.message}`);
-                    appendDaemonLog(`${slot.adapter}_${event.status}: ${event.message}`);
+            },
+            status: (next) => {
+                if (next.message) {
+                    log(`${slot.adapter} ${next.status}: ${next.message}`);
+                    appendDaemonLog(`${slot.adapter}_${next.status}: ${next.message}`);
                 }
-                break;
-            case "notice":
+            },
+            notice: (next) => {
                 slot.lastOutputAt = Date.now();
-                appendDaemonLog(`${slot.adapter}_${event.level}_notice: ${truncatePreview(event.text)}`);
-                if (shouldForwardBridgeEventToWechat(slot.adapter, event.type, { text: event.text })) {
+                appendDaemonLog(`${slot.adapter}_${next.level}_notice: ${truncatePreview(next.text)}`);
+                if (shouldForwardBridgeEventToWechat(slot.adapter, next.type, { text: next.text })) {
                     this.trackWechatForwardTask(slot.outputBatcher.flushNow().then(async () => {
-                        await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(slot.adapter, event.text), "notice");
+                        await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(slot.adapter, next.text), "notice", eventTarget);
                     }));
                 }
-                break;
-            case "approval_required":
+            },
+            approvalRequired: (next) => {
                 this.trackWechatForwardTask(slot.outputBatcher.flushNow().then(async () => {
-                    const pending = toPendingApproval(event);
+                    const pending = toPendingApproval(next);
                     slot.pendingConfirmations.push(pending);
                     appendDaemonLog(`approval_required: adapter=${slot.adapter} source=${pending.source} command=${truncatePreview(pending.commandPreview)}`);
-                    await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(slot.adapter, formatApprovalMessage(pending, adapterState)), "approval_required");
+                    await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(slot.adapter, formatApprovalMessage(pending, adapterState)), "approval_required", eventTarget);
                 }));
-                break;
-            case "user_input_required": {
-                // Mirror the pending request synchronously, before the async WeChat
-                // send (which retries with backoff). Otherwise a fast user reply can
-                // race past the still-unwritten mirror and be dispatched as plain
-                // input into a CLI that is waiting for a structured form answer.
-                const pending = toPendingUserInput(event.request);
+            },
+            userInputRequired: (next) => {
+                const pending = toPendingUserInput(next.request);
                 slot.pendingUserInput = pending;
                 appendDaemonLog(`user_input_required: adapter=${slot.adapter} questions=${pending.questions.length}`);
                 this.trackWechatForwardTask(slot.outputBatcher.flushNow().then(async () => {
-                    await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(slot.adapter, formatUserInputRequestMessage(pending, adapterState)), "user_input_required");
+                    await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(slot.adapter, formatUserInputRequestMessage(pending, adapterState)), "user_input_required", eventTarget);
                 }));
-                break;
-            }
-            case "mirrored_user_input":
-                appendDaemonLog(`mirrored_local_input: adapter=${slot.adapter} text=${truncatePreview(event.text)}`);
-                if (shouldForwardBridgeEventToWechat(slot.adapter, event.type, { text: event.text })) {
+            },
+            mirroredUserInput: (next) => {
+                appendDaemonLog(`mirrored_local_input: adapter=${slot.adapter} text=${truncatePreview(next.text)}`);
+                if (shouldForwardBridgeEventToWechat(slot.adapter, next.type, { text: next.text })) {
                     this.trackWechatForwardTask(slot.outputBatcher.flushNow().then(async () => {
-                        await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(slot.adapter, formatMirroredUserInputMessage(slot.adapter, event.text)), "mirrored_user_input");
+                        await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(slot.adapter, formatMirroredUserInputMessage(slot.adapter, next.text)), "mirrored_user_input", eventTarget);
                     }));
                 }
-                break;
-            case "session_switched":
-                if (event.source === "local") {
+            },
+            sessionSwitched: (next) => {
+                if (next.source === "local")
                     slot.resumeCoordinator.clear();
-                }
-                appendDaemonLog(`session_switched: adapter=${slot.adapter} session=${event.sessionId} source=${event.source} reason=${event.reason}`);
-                if (shouldForwardSessionSwitchEvent(event.reason) &&
-                    shouldForwardBridgeEventToWechat(slot.adapter, event.type)) {
+                appendDaemonLog(`session_switched: adapter=${slot.adapter} session=${next.sessionId} source=${next.source} reason=${next.reason}`);
+                if (shouldForwardSessionSwitchEvent(next.reason) && shouldForwardBridgeEventToWechat(slot.adapter, next.type)) {
                     this.trackWechatForwardTask(slot.outputBatcher.flushNow().then(async () => {
-                        await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(slot.adapter, formatSessionSwitchMessage({
-                            adapter: slot.adapter,
-                            sessionId: event.sessionId,
-                            source: event.source,
-                            reason: event.reason,
-                        })), "session_switched");
+                        await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(slot.adapter, formatSessionSwitchMessage({ adapter: slot.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")
                     slot.resumeCoordinator.clear();
+                appendDaemonLog(`thread_switched: adapter=${slot.adapter} thread=${next.threadId} source=${next.source} reason=${next.reason}`);
+                if (shouldSuppressCodexLocalThreadNotice({
+                    adapter: slot.adapter,
+                    source: next.source,
+                    activeTurnOrigin: slot.runtime.getState().activeTurnOrigin,
+                    lastFinalReplyAtMs: slot.lastFinalReplyAtMs,
+                })) {
+                    return;
                 }
-                appendDaemonLog(`thread_switched: adapter=${slot.adapter} thread=${event.threadId} source=${event.source} reason=${event.reason}`);
-                if (shouldForwardSessionSwitchEvent(event.reason) &&
-                    shouldForwardBridgeEventToWechat(slot.adapter, event.type)) {
+                if (shouldForwardSessionSwitchEvent(next.reason) && shouldForwardBridgeEventToWechat(slot.adapter, next.type)) {
                     this.trackWechatForwardTask(slot.outputBatcher.flushNow().then(async () => {
-                        await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(slot.adapter, formatSessionSwitchMessage({
-                            adapter: slot.adapter,
-                            sessionId: event.threadId,
-                            source: event.source,
-                            reason: event.reason,
-                        })), "thread_switched");
+                        await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(slot.adapter, formatSessionSwitchMessage({ adapter: slot.adapter, sessionId: next.threadId, source: next.source, reason: next.reason })), "thread_switched", eventTarget);
                     }));
                 }
-                break;
-            case "task_complete":
+            },
+            taskComplete: () => {
+                void this.channelDriver.endTyping?.(this.authorizedUserId);
                 this.trackWechatForwardTask(slot.outputBatcher.flushNow().then(() => {
                     slot.pendingConfirmations = [];
                     slot.pendingUserInput = null;
-                    slot.activeTask = null;
+                    if (eventTask) {
+                        slot.turns.complete(eventTask);
+                    }
+                    void this.maybeDrainDeferredInputs(slot);
                 }));
-                break;
-            case "task_failed":
+            },
+            taskFailed: (next) => {
+                void this.channelDriver.endTyping?.(this.authorizedUserId);
                 this.trackWechatForwardTask(slot.outputBatcher.flushNow().then(async () => {
                     slot.pendingConfirmations = [];
                     slot.pendingUserInput = null;
-                    slot.activeTask = null;
-                    await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(slot.adapter, formatTaskFailedMessage(slot.adapter, event.message)), "task_failed");
+                    if (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);
                 }));
-                break;
-            case "fatal_error":
-                logError(`${slot.adapter}: ${event.message}`);
-                appendDaemonLog(`fatal_error: adapter=${slot.adapter} message=${event.message}`);
+            },
+            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;
-                slot.activeTask = null;
+                if (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(event.message)), "fatal_error");
+                    await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(slot.adapter, formatUserFacingBridgeFatalError(next.message)), "fatal_error", eventTarget);
                 }));
-                break;
-            case "shutdown_requested":
-                appendDaemonLog(`slot_shutdown_requested: adapter=${slot.adapter} reason=${event.reason}`);
-                break;
+            },
+            shutdownRequested: (next) => {
+                appendDaemonLog(`slot_shutdown_requested: adapter=${slot.adapter} reason=${next.reason}`);
+            },
+        }))
+            .catch((error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            appendDaemonLog(`event_forward_failed: adapter=${slot.adapter} message=${message}`);
+        });
+    }
+    resolveSlotOutputTarget(slot) {
+        return slot.turns.resolveTarget(this.fallbackConversation);
+    }
+    bindCurrentWecomConversation(slot) {
+        const conversation = this.inboundConversationContext.get();
+        if (!this.channelDriver.capabilities.multiConversation || !slot || !conversation) {
+            return;
         }
+        slot.turns.observeConversation(conversation);
     }
     async handleInboundMessage(message) {
         if (message.senderId !== this.authorizedUserId) {
-            await this.queueWechatMessage(message.senderId, "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);
@@ -1096,6 +1573,7 @@ class WechatDaemon {
                     reuseExistingVisible: true,
                 });
                 if (result.activated) {
+                    this.bindCurrentWecomConversation(this.getActiveSlot());
                     message = { ...message, text: emojiMatch.remainder };
                 }
                 else {
@@ -1122,6 +1600,7 @@ class WechatDaemon {
                 await this.queueWechatMessage(message.senderId, `Could not activate terminal: ${switchDirective.adapter}.\n${detail}`);
                 return;
             }
+            this.bindCurrentWecomConversation(this.getActiveSlot());
             if (switchDirective.remainder) {
                 message = { ...message, text: switchDirective.remainder };
             }
@@ -1131,7 +1610,7 @@ class WechatDaemon {
             }
         }
         if (message.text.trim().toLowerCase() === "/daemon-stop") {
-            await this.queueWechatMessage(message.senderId, "Stopping wechat-daemon...");
+            await this.queueWechatMessage(message.senderId, `Stopping ${this.channelId}-daemon...`);
             setTimeout(() => {
                 void this.shutdown().finally(() => process.exit(0));
             }, 0);
@@ -1151,21 +1630,56 @@ class WechatDaemon {
             await this.queueWechatMessage(message.senderId, formatNoActiveAdapterMessage());
             return;
         }
+        this.bindCurrentWecomConversation(slot);
+        const routeCurrentMessage = async (currentSlot, command) => {
+            const previousTask = currentSlot.turns.activeTask;
+            await routeBridgeMessage({
+                message: toChannelInboundMessage(message),
+                authorized: true,
+                command,
+                adapterState: currentSlot.runtime.getState(),
+                hasPendingApproval: currentSlot.pendingConfirmations.length > 0,
+                hasPendingUserInput: Boolean(currentSlot.pendingUserInput),
+                onUnauthorized: async () => undefined,
+                handleCommand: async (nextCommand) => {
+                    await this.handleSystemCommand(message, currentSlot, nextCommand);
+                    return true;
+                },
+                remindPendingApproval: async () => {
+                    await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(currentSlot.adapter, formatPendingApprovalReminder(currentSlot.pendingConfirmations[0], currentSlot.runtime.getState())));
+                },
+                remindPendingUserInput: async () => {
+                    await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(currentSlot.adapter, currentSlot.pendingUserInput
+                        ? formatPendingUserInputReminder(currentSlot.pendingUserInput)
+                        : `${currentSlot.adapter} is waiting for structured input. Reply with /answer <key>=<value> ...`));
+                },
+                remindBusy: async () => {
+                    await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(currentSlot.adapter, `${currentSlot.adapter} is still working. Wait for the current reply or use /stop.`));
+                },
+                defer: async () => undefined,
+                dispatch: async () => {
+                    await this.dispatchInboundWechatText(message, currentSlot);
+                },
+            });
+            if (this.channelDriver.capabilities.multiConversation &&
+                this.inboundConversationContext.get() &&
+                currentSlot.turns.activeTask &&
+                currentSlot.turns.activeTask !== previousTask) {
+                const conversation = this.inboundConversationContext.get();
+                currentSlot.turns.bindConversation(conversation);
+            }
+        };
         const command = parseWechatControlCommand(message.text, {
             adapter: slot.adapter,
             hasPendingConfirmation: slot.pendingConfirmations.length > 0,
             hasPendingUserInput: Boolean(slot.pendingUserInput),
         });
-        if (command) {
-            await this.handleSystemCommand(message, slot, command);
-            return;
-        }
-        if (slot.pendingConfirmations.length > 0) {
-            await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(slot.adapter, formatPendingApprovalReminder(slot.pendingConfirmations[0], slot.runtime.getState())));
-            return;
-        }
-        if (slot.pendingUserInput) {
-            await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(slot.adapter, formatPendingUserInputReminder(slot.pendingUserInput)));
+        const slotState = slot.runtime.getState();
+        if (command ||
+            slot.pendingConfirmations.length > 0 ||
+            slot.pendingUserInput ||
+            slotState.status === "awaiting_input") {
+            await routeCurrentMessage(slot, command);
             return;
         }
         const visibleResult = await this.ensureSlot(slot.adapter, {
@@ -1177,21 +1691,8 @@ class WechatDaemon {
             return;
         }
         slot = this.getActiveSlot() ?? slot;
-        const adapterState = slot.runtime.getState();
-        if (adapterState.status === "awaiting_input") {
-            // Belt-and-braces with the pendingUserInput mirror above: the adapter
-            // state is authoritative even when the mirror was cleared or the WeChat
-            // notification is still queued.
-            await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(slot.adapter, slot.pendingUserInput
-                ? formatPendingUserInputReminder(slot.pendingUserInput)
-                : `${slot.adapter} is waiting for structured input. Reply with /answer <key>=<value> ...`));
-            return;
-        }
-        if (adapterState.status === "busy" || adapterState.status === "awaiting_approval") {
-            await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(slot.adapter, `${slot.adapter} is still working. Wait for the current reply or use /stop.`));
-            return;
-        }
-        await this.dispatchInboundWechatText(message, slot);
+        this.bindCurrentWecomConversation(slot);
+        await routeCurrentMessage(slot, null);
     }
     async handleEmojiBindingsCommand(senderId, cmd) {
         switch (cmd.type) {
@@ -1215,12 +1716,16 @@ class WechatDaemon {
     }
     async handleSystemCommand(message, activeSlot, command) {
         switch (command.type) {
+            case "model":
+            case "plan":
+                await this.queueWechatMessage(message.senderId, await handleAdapterControl(activeSlot.runtime, message.senderId, command));
+                return;
             case "status":
                 await this.queueWechatMessage(message.senderId, formatDaemonStatus(this.getStatus()));
                 return;
             case "resume": {
                 if (!isWechatResumeEnabled(activeSlot.adapter)) {
-                    await this.queueWechatMessage(message.senderId, `WeChat /resume is disabled for ${activeSlot.adapter} in daemon mode. Use /resume directly inside the visible terminal; WeChat 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 {
@@ -1238,9 +1743,10 @@ class WechatDaemon {
                     if (command.target) {
                         await resumeSlot.outputBatcher.flushNow();
                     }
+                    const taskBeforeResume = resumeSlot.turns.activeTask;
                     const result = await resumeSlot.resumeCoordinator.execute(command.target);
-                    if (result.kind === "resumed") {
-                        resumeSlot.activeTask = null;
+                    if (result.kind === "resumed" && taskBeforeResume) {
+                        resumeSlot.turns.complete(taskBeforeResume);
                     }
                     await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(resumeSlot.adapter, result.message));
                 }
@@ -1262,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
@@ -1303,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...`
@@ -1352,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..."));
     }
@@ -1377,14 +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);
-        slot.activeTask = {
+        const nextTask = {
             startedAt: Date.now(),
             inputPreview: truncatePreview(preview, 180),
         };
-        appendDaemonLog(`forwarded_input: adapter=${slot.adapter} text=${truncatePreview(preview)}`);
-        await slot.runtime.sendInput(buildWechatInboundPrompt(message.text, message.attachments));
+        const inboundConversation = this.channelDriver.capabilities.multiConversation
+            ? conversationOverride ?? this.inboundConversationContext.get()
+            : undefined;
+        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);
@@ -1396,39 +1970,60 @@ class WechatDaemon {
         this.attachmentSendChain = run.then(() => undefined, () => undefined);
         return run;
     }
-    queueWechatMessage(senderId, text, context = "message") {
+    async sendWechatMessageNow(senderId, text, context = "message", targetOverride) {
+        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.channelDriver.capabilities.multiConversation && senderId === this.authorizedUserId
+            ? targetOverride ??
+                this.inboundConversationContext.get() ??
+                (activeSlot ? this.resolveSlotOutputTarget(activeSlot) : this.fallbackConversation)
+            : targetOverride;
         return this.queueWechatTextAction(async () => {
-            for (let attempt = 1; attempt <= WECHAT_SEND_MAX_ATTEMPTS; attempt += 1) {
-                try {
-                    await this.transport.sendText(senderId, text);
-                    return true;
+            const result = await this.sendWechatMessageNow(senderId, text, context, queuedTarget);
+            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}`);
                 }
-                catch (error) {
-                    if (isWechatContextTokenStaleError(error)) {
-                        this.transport.clearCachedContextToken(senderId);
-                        appendDaemonLog(formatWechatContextTokenStaleLogEntry({
-                            context,
-                            recipientId: senderId,
-                            error,
-                        }));
-                        return false;
-                    }
-                    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 false;
+            }
+            return result.status === "sent";
+        });
+    }
+    flushPendingWechatMessages() {
+        return this.queueWechatTextAction(async () => {
+            for (const pending of this.pendingWechatMessages.list()) {
+                const result = await this.sendWechatMessageNow(pending.recipientId, pending.text, pending.context, pending.target);
+                if (result.status === "sent") {
+                    this.pendingWechatMessages.remove(pending.id);
+                    appendDaemonLog(`wechat_pending_sent: id=${pending.id} context=${pending.context} recipient=${pending.recipientId}`);
+                    continue;
+                }
+                if (result.status === "target_stale") {
+                    break;
                 }
+                appendDaemonLog(`wechat_pending_retryable_failure: id=${pending.id} context=${pending.context} recipient=${pending.recipientId}`);
+                break;
             }
-            return false;
         });
     }
     trackWechatForwardTask(task) {
@@ -1728,7 +2323,9 @@ export async function cleanupSingleBridgeBeforeDaemon(deps = {}) {
     return { action: "stopped", lock, forced };
 }
 export async function runDaemon(options) {
-    migrateLegacyChannelFiles((message) => log(message));
+    if ((options.channelId ?? "wechat") === "wechat") {
+        migrateLegacyChannelFiles((message) => log(message));
+    }
     loadEmojiBindings();
     await cleanupDaemonBeforeStart({ cwd: options.cwd });
     const cleanupResult = await cleanupSingleBridgeBeforeDaemon();
@@ -1744,19 +2341,37 @@ export async function runDaemon(options) {
     if (reapedOpencodePids.length > 0) {
         log(`Cleaned ${reapedOpencodePids.length} orphaned OpenCode process(es): ${reapedOpencodePids.join(", ")}`);
     }
-    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 daemon = new WechatDaemon({
         cwd: options.cwd,
         profile: options.profile,
         authorizedUserId: credentials.userId,
         transport: new WeChatTransport({ log, logError }),
+        channelId: options.channelId,
+        accountId: wecomAccount?.botId,
+        wecomTransport: wecomAccount
+            ? new WecomTransport({
+                account: wecomAccount,
+                logger: {
+                    log: (message) => log(message),
+                    error: (message) => logError(message),
+                },
+            })
+            : null,
     });
     if (cleanupResult.action === "stopped" && isDaemonAdapterKind(cleanupResult.lock.adapter)) {
         daemon.takenOverAdapter = cleanupResult.lock.adapter;
@@ -1772,6 +2387,9 @@ export async function runDaemon(options) {
             }
             shutdownInProgress = true;
             log(`Received ${signal}. Stopping daemon.`);
+            // Remove this process's endpoint synchronously so a new terminal can be
+            // started immediately even if asynchronous adapter cleanup takes time.
+            clearDaemonEndpoint();
             void daemon.shutdown().finally(() => process.exit(0));
         };
         process.on("SIGINT", () => handleSignal("SIGINT"));
@@ -1806,7 +2424,7 @@ export async function main(argv = process.argv.slice(2)) {
         process.exit(1);
     }
 }
-const isDirectRun = Boolean(import.meta.main);
+const isDirectRun = isDirectModuleRun(import.meta.url, process.argv, import.meta.main);
 if (isDirectRun) {
     void main();
 }