cli-wechat-bridge 1.1.5 → 1.1.7

package/dist/daemon/wechat-daemon.js

@@ -8,17 +8,26 @@ 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_MAX_ATTEMPTS, computeWechatSendRetryDelayMs, formatUserFacingBridgeFatalError, formatUserFacingInboundError, formatWechatContextTokenStaleLogEntry, formatWechatSendFailureLogEntry, isWechatContextUnavailableError, isRetryableWechatSendError, 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 { 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 { 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 { buildWecomInboundPrompt, formatWecomVisibleText, } from "../channels/wecom/wecom-message.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);
@@ -36,11 +45,15 @@ const DAEMON_TAKEOVER_STOP_POLL_MS = 250;
 const VISIBLE_CLIENT_CONNECT_TIMEOUT_MS = 15_000;
 const VISIBLE_CLIENT_CONNECT_POLL_MS = 250;
 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 +64,48 @@ 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";
+    }
+    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 +127,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 +136,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 +152,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 +182,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();
@@ -217,7 +287,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 +335,7 @@ function openVisibleClient(params) {
                 adapter: params.adapter,
                 cwd: params.cwd,
                 args,
+                channelId: params.channelId,
             }),
         ];
         const child = spawn(command, launchArgs, {
@@ -285,7 +356,7 @@ 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(" ");
@@ -482,6 +553,10 @@ class WechatDaemon {
     profile;
     authorizedUserId;
     transport;
+    channelId;
+    wecomTransport;
+    currentInboundConversation = null;
+    handlingInboundMessage = false;
     slots = new Map();
     // Per-adapter serialization chains for ensureSlot (see ensureSlot comment).
     slotEnsureChains = new Map();
@@ -493,6 +568,7 @@ class WechatDaemon {
     textSendChain = Promise.resolve();
     attachmentSendChain = Promise.resolve();
     pendingWechatForwardTasks = new Set();
+    pendingWechatMessages;
     shutdownPromise = null;
     ipcServer = null;
     endpointToken = "";
@@ -501,6 +577,19 @@ class WechatDaemon {
         this.profile = params.profile;
         this.authorizedUserId = params.authorizedUserId;
         this.transport = params.transport;
+        this.channelId = params.channelId ?? "wechat";
+        this.wecomTransport = params.wecomTransport ?? null;
+        if (this.channelId === "wecom") {
+            this.currentInboundConversation = {
+                channelId: "wecom",
+                conversationId: params.authorizedUserId,
+                recipientId: params.authorizedUserId,
+                metadata: { chatType: "direct" },
+            };
+        }
+        this.pendingWechatMessages = new PendingWechatMessageStore(this.channelId === "wechat"
+            ? getPendingWechatMessagesFile(this.cwd)
+            : getPendingChannelMessagesFile(this.cwd, this.channelId));
     }
     async startIpcServer() {
         this.endpointToken = buildDaemonToken();
@@ -548,6 +637,7 @@ class WechatDaemon {
                     token: this.endpointToken,
                     cwd: this.cwd,
                     startedAt: this.startedAt,
+                    channelId: this.channelId,
                 });
                 resolve();
             });
@@ -556,6 +646,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 +675,52 @@ class WechatDaemon {
     }
     async runPollLoop() {
         let consecutivePollFailures = 0;
-        log("WeChat daemon is ready.");
+        if (this.wecomTransport) {
+            this.wecomTransport.setHandlers({
+                onMessage: async (channelMessage) => {
+                    if (this.shutdownPromise) {
+                        return;
+                    }
+                    this.currentInboundConversation = channelMessage.conversation;
+                    this.handlingInboundMessage = true;
+                    try {
+                        if (this.pendingWechatMessages.list().length > 0) {
+                            await this.flushPendingWechatMessages();
+                        }
+                        await this.handleInboundMessage(toLegacyInboundWechatMessage(channelMessage));
+                    }
+                    finally {
+                        this.handlingInboundMessage = false;
+                    }
+                },
+                onUnauthorized: 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");
+                    }
+                },
+                onFatal: async (error) => {
+                    appendDaemonLog(`wecom_fatal_error: ${error.message}`);
+                    await this.shutdown();
+                },
+                onConnected: async () => {
+                    if (this.pendingWechatMessages.list().length > 0) {
+                        await this.flushPendingWechatMessages();
+                    }
+                },
+            });
+            this.wecomTransport.start();
+            await this.wecomTransport.waitUntilConnected();
+        }
+        log(`${this.channelId === "wecom" ? "WeCom" : "WeChat"} 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.channelId === "wecom" ? "WeCom" : "WeChat"} 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 +728,13 @@ class WechatDaemon {
             bindings: formatBindingsListMessage(listBindings()),
         });
         await this.queueWechatMessage(this.authorizedUserId, welcomeText);
+        if (this.channelId === "wecom") {
+            while (!this.shutdownPromise) {
+                await delay(1_000);
+            }
+            await this.shutdownPromise;
+            return;
+        }
         while (!this.shutdownPromise) {
             let pollResult;
             try {
@@ -624,6 +764,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) {
@@ -696,6 +839,12 @@ class WechatDaemon {
         await this.waitForPendingWechatForwardTasks();
         await this.textSendChain.catch(() => undefined);
         await this.attachmentSendChain.catch(() => undefined);
+        try {
+            this.wecomTransport?.stop();
+        }
+        catch {
+            // Best effort shutdown.
+        }
         for (const slot of this.slots.values()) {
             try {
                 await slot.runtime.dispose();
@@ -727,7 +876,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,
@@ -819,6 +968,7 @@ class WechatDaemon {
                 cwd: this.cwd,
                 sessionStartMode,
                 cliArgs: options.cliArgs,
+                channelId: this.channelId,
                 onError: (error) => {
                     appendDaemonLog(`visible_client_open_error: adapter=${adapter} error=${truncatePreview(error.message, 400)}`);
                 },
@@ -899,6 +1049,8 @@ class WechatDaemon {
             }),
             activeTask: null,
             lastOutputAt: 0,
+            lastFinalReplyAtMs: 0,
+            eventForwardChain: Promise.resolve(),
         };
         runtime.setEventSink((event) => {
             this.handleSlotEvent(slot, event);
@@ -925,166 +1077,192 @@ 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);
         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) => {
+                slot.lastFinalReplyAtMs = Date.now();
+                appendDaemonLog(`final_reply: adapter=${slot.adapter} text=${truncatePreview(next.text)}`);
                 this.trackWechatForwardTask(slot.outputBatcher.flushNow().then(async () => {
-                    await forwardWechatFinalReply({
-                        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, {
+                    await channelPort.send({
+                        target: this.channelId === "wecom"
+                            ? slot.activeConversation ??
+                                slot.lastConversation ??
+                                this.currentInboundConversation
+                            : {
+                                channelId: "wechat",
+                                conversationId: this.authorizedUserId,
                                 recipientId: this.authorizedUserId,
-                            })),
-                        },
+                            },
+                        kind: "final_reply",
+                        text: next.text,
+                        adapter: slot.adapter,
                     });
                 }));
-                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");
                     }));
                 }
-                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");
                 }));
-                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");
                 }));
-                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");
                     }));
                 }
-                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");
                     }));
                 }
-                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");
                     }));
                 }
-                break;
-            case "task_complete":
+            },
+            taskComplete: () => {
                 this.trackWechatForwardTask(slot.outputBatcher.flushNow().then(() => {
                     slot.pendingConfirmations = [];
                     slot.pendingUserInput = null;
                     slot.activeTask = null;
+                    slot.activeConversation = undefined;
                 }));
-                break;
-            case "task_failed":
+            },
+            taskFailed: (next) => {
                 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");
+                    slot.activeConversation = undefined;
+                    await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(slot.adapter, formatTaskFailedMessage(slot.adapter, next.message)), "task_failed");
                 }));
-                break;
-            case "fatal_error":
-                logError(`${slot.adapter}: ${event.message}`);
-                appendDaemonLog(`fatal_error: adapter=${slot.adapter} message=${event.message}`);
+            },
+            fatalError: (next) => {
+                logError(`${slot.adapter}: ${next.message}`);
+                appendDaemonLog(`fatal_error: adapter=${slot.adapter} message=${next.message}`);
                 slot.pendingConfirmations = [];
                 slot.pendingUserInput = null;
                 slot.activeTask = null;
+                slot.activeConversation = undefined;
                 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");
                 }));
-                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}`);
+        });
+    }
+    bindCurrentWecomConversation(slot) {
+        if (this.channelId !== "wecom" || !slot || !this.currentInboundConversation) {
+            return;
         }
+        slot.lastConversation = this.currentInboundConversation;
     }
     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, 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.");
             return;
         }
         const emojiMatch = resolveEmojiCommand(message.text);
@@ -1096,6 +1274,7 @@ class WechatDaemon {
                     reuseExistingVisible: true,
                 });
                 if (result.activated) {
+                    this.bindCurrentWecomConversation(this.getActiveSlot());
                     message = { ...message, text: emojiMatch.remainder };
                 }
                 else {
@@ -1122,6 +1301,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 +1311,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 +1331,56 @@ class WechatDaemon {
             await this.queueWechatMessage(message.senderId, formatNoActiveAdapterMessage());
             return;
         }
+        this.bindCurrentWecomConversation(slot);
+        const routeCurrentMessage = async (currentSlot, command) => {
+            const previousTask = currentSlot.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.channelId === "wecom" &&
+                this.currentInboundConversation &&
+                currentSlot.activeTask &&
+                currentSlot.activeTask !== previousTask) {
+                currentSlot.activeConversation = this.currentInboundConversation;
+                currentSlot.lastConversation = this.currentInboundConversation;
+            }
+        };
         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 +1392,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) {
@@ -1220,7 +1422,7 @@ class WechatDaemon {
                 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.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.`);
                     return;
                 }
                 try {
@@ -1384,7 +1586,9 @@ class WechatDaemon {
             inputPreview: truncatePreview(preview, 180),
         };
         appendDaemonLog(`forwarded_input: adapter=${slot.adapter} text=${truncatePreview(preview)}`);
-        await slot.runtime.sendInput(buildWechatInboundPrompt(message.text, message.attachments));
+        await slot.runtime.sendInput(this.channelId === "wecom"
+            ? buildWecomInboundPrompt(message.text, message.attachments)
+            : buildWechatInboundPrompt(message.text, message.attachments));
     }
     queueWechatTextAction(action) {
         const run = this.textSendChain.then(action);
@@ -1396,39 +1600,110 @@ class WechatDaemon {
         this.attachmentSendChain = run.then(() => undefined, () => undefined);
         return run;
     }
-    queueWechatMessage(senderId, text, context = "message") {
-        return this.queueWechatTextAction(async () => {
-            for (let attempt = 1; attempt <= WECHAT_SEND_MAX_ATTEMPTS; attempt += 1) {
-                try {
-                    await this.transport.sendText(senderId, text);
-                    return true;
+    async sendWechatMessageNow(senderId, text, context = "message", targetOverride) {
+        if (this.channelId === "wecom") {
+            const activeSlot = this.getActiveSlot();
+            const target = targetOverride ??
+                (senderId === this.authorizedUserId
+                    ? (this.handlingInboundMessage
+                        ? this.currentInboundConversation
+                        : null) ??
+                        activeSlot?.activeConversation ??
+                        activeSlot?.lastConversation ??
+                        this.currentInboundConversation
+                    : {
+                        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}`);
                 }
-                catch (error) {
+                if (isWechatContextUnavailableError(error)) {
                     if (isWechatContextTokenStaleError(error)) {
                         this.transport.clearCachedContextToken(senderId);
-                        appendDaemonLog(formatWechatContextTokenStaleLogEntry({
+                    }
+                    appendDaemonLog(isWechatContextTokenStaleError(error)
+                        ? formatWechatContextTokenStaleLogEntry({
+                            context,
+                            recipientId: senderId,
+                            error,
+                        })
+                        : formatWechatSendFailureLogEntry({
                             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 { 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" };
+    }
+    queueWechatMessage(senderId, text, context = "message", targetOverride) {
+        return this.queueWechatTextAction(async () => {
+            const result = await this.sendWechatMessageNow(senderId, text, context, targetOverride);
+            if (result.status === "context_unavailable") {
+                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}`);
+                }
+            }
+            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 === "context_unavailable") {
+                    break;
+                }
+                appendDaemonLog(`wechat_pending_retryable_failure: id=${pending.id} context=${pending.context} recipient=${pending.recipientId}`);
+                break;
             }
-            return false;
         });
     }
     trackWechatForwardTask(task) {
@@ -1728,7 +2003,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 +2021,36 @@ 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,
+        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;
@@ -1806,7 +2100,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();
 }