cli-wechat-bridge 1.1.6 → 1.1.8

package/dist/daemon/wechat-daemon.js

@@ -17,12 +17,19 @@ import { BRIDGE_LOCK_FILE, BRIDGE_LOG_FILE, appendBoundedLog, ensureChannelDataD
 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 { getPendingWechatMessagesFile, PendingWechatMessageStore, } from "../channels/wechat/wechat-outbound-queue.js";
+import { getPendingChannelMessagesFile, getPendingWechatMessagesFile, PendingWechatMessageStore, } from "../channels/wechat/wechat-outbound-queue.js";
 import { createRuntimeHost, } from "../runtime/create-runtime-host.js";
 import { toChannelInboundMessage } from "../channels/wechat/channel-message.js";
 import { routeBridgeMessage } from "../core/bridge-message-router.js";
+import { clearTurn, InboundConversationContext, resolveConversationTarget, rollbackTurn, tryBeginTurn, } from "../core/conversation-routing.js";
+import { 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 { 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);
@@ -40,11 +47,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();
@@ -55,6 +66,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";
 }
@@ -76,6 +129,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) {
@@ -84,10 +138,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);
@@ -100,6 +154,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)"}`);
@@ -122,7 +184,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();
@@ -151,8 +219,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
@@ -165,9 +238,6 @@ export function resolveDaemonSessionStartMode(params) {
     if (params.reuseExistingVisible && params.visibleConnected) {
         return "restore";
     }
-    if (params.adapter === "codex") {
-        return "restore";
-    }
     if (params.slotCreated) {
         return "new";
     }
@@ -221,7 +291,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),
@@ -269,6 +339,7 @@ function openVisibleClient(params) {
                 adapter: params.adapter,
                 cwd: params.cwd,
                 args,
+                channelId: params.channelId,
             }),
         ];
         const child = spawn(command, launchArgs, {
@@ -289,13 +360,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,
@@ -486,6 +557,10 @@ class WechatDaemon {
     profile;
     authorizedUserId;
     transport;
+    channelId;
+    wecomTransport;
+    inboundConversationContext = new InboundConversationContext();
+    fallbackConversation;
     slots = new Map();
     // Per-adapter serialization chains for ensureSlot (see ensureSlot comment).
     slotEnsureChains = new Map();
@@ -506,7 +581,17 @@ class WechatDaemon {
         this.profile = params.profile;
         this.authorizedUserId = params.authorizedUserId;
         this.transport = params.transport;
-        this.pendingWechatMessages = new PendingWechatMessageStore(getPendingWechatMessagesFile(this.cwd));
+        this.channelId = params.channelId ?? "wechat";
+        this.wecomTransport = params.wecomTransport ?? null;
+        this.fallbackConversation = {
+            channelId: this.channelId,
+            conversationId: params.authorizedUserId,
+            recipientId: params.authorizedUserId,
+            metadata: this.channelId === "wecom" ? { chatType: "direct" } : undefined,
+        };
+        this.pendingWechatMessages = new PendingWechatMessageStore(this.channelId === "wechat"
+            ? getPendingWechatMessagesFile(this.cwd)
+            : getPendingChannelMessagesFile(this.cwd, this.channelId));
     }
     async startIpcServer() {
         this.endpointToken = buildDaemonToken();
@@ -554,6 +639,7 @@ class WechatDaemon {
                     token: this.endpointToken,
                     cwd: this.cwd,
                     startedAt: this.startedAt,
+                    channelId: this.channelId,
                 });
                 resolve();
             });
@@ -562,6 +648,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) => {
@@ -590,10 +677,47 @@ 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;
+                    }
+                    await this.inboundConversationContext.run(channelMessage.conversation, async () => {
+                        if (this.pendingWechatMessages.list().length > 0) {
+                            await this.flushPendingWechatMessages();
+                        }
+                        await this.handleInboundMessage(toLegacyInboundWechatMessage(channelMessage));
+                    });
+                },
+                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,
@@ -601,6 +725,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 {
@@ -694,6 +825,23 @@ 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 {
+            this.wecomTransport?.stop();
+        }
+        catch {
+            // Best effort shutdown.
+        }
+        clearDaemonEndpoint();
         for (const slot of this.slots.values()) {
             try {
                 await slot.outputBatcher.flushNow();
@@ -736,7 +884,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,
@@ -826,8 +974,12 @@ class WechatDaemon {
             const launch = 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)}`);
                 },
@@ -868,6 +1020,9 @@ 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;
         }
         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}`);
@@ -898,7 +1053,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,
@@ -924,7 +1079,7 @@ class WechatDaemon {
         slot.outputBatcher.clear();
         slot.pendingConfirmations = [];
         slot.pendingUserInput = null;
-        slot.activeTask = null;
+        clearTurn(slot);
         if (slot.adapter === "codex" || slot.adapter === "claude") {
             await slot.runtime.reset();
         }
@@ -937,6 +1092,16 @@ 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 })),
@@ -956,6 +1121,10 @@ class WechatDaemon {
         slot.controller.syncLocalClientEndpoint();
         const adapterState = slot.runtime.getState();
         const channelPort = this.createWechatChannelPort(slot.adapter);
+        const eventTarget = this.channelId === "wecom"
+            ? this.resolveSlotOutputTarget(slot)
+            : this.fallbackConversation;
+        const eventTask = slot.activeTask;
         if (slot.pendingConfirmations.length > 0 && !adapterState.pendingApproval) {
             slot.pendingConfirmations = [];
         }
@@ -981,11 +1150,7 @@ class WechatDaemon {
                 appendDaemonLog(`final_reply: adapter=${slot.adapter} text=${truncatePreview(next.text)}`);
                 this.trackWechatForwardTask(slot.outputBatcher.flushNow().then(async () => {
                     await channelPort.send({
-                        target: {
-                            channelId: "wechat",
-                            conversationId: this.authorizedUserId,
-                            recipientId: this.authorizedUserId,
-                        },
+                        target: eventTarget,
                         kind: "final_reply",
                         text: next.text,
                         adapter: slot.adapter,
@@ -1003,7 +1168,7 @@ class WechatDaemon {
                 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, next.text), "notice");
+                        await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(slot.adapter, next.text), "notice", eventTarget);
                     }));
                 }
             },
@@ -1012,7 +1177,7 @@ class WechatDaemon {
                     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);
                 }));
             },
             userInputRequired: (next) => {
@@ -1020,14 +1185,14 @@ class WechatDaemon {
                 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);
                 }));
             },
             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, next.text)), "mirrored_user_input");
+                        await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(slot.adapter, formatMirroredUserInputMessage(slot.adapter, next.text)), "mirrored_user_input", eventTarget);
                     }));
                 }
             },
@@ -1037,7 +1202,7 @@ class WechatDaemon {
                 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: next.sessionId, source: next.source, reason: next.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);
                     }));
                 }
             },
@@ -1055,7 +1220,7 @@ class WechatDaemon {
                 }
                 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: next.threadId, source: next.source, reason: next.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);
                     }));
                 }
             },
@@ -1063,15 +1228,19 @@ class WechatDaemon {
                 this.trackWechatForwardTask(slot.outputBatcher.flushNow().then(() => {
                     slot.pendingConfirmations = [];
                     slot.pendingUserInput = null;
-                    slot.activeTask = null;
+                    if (eventTask) {
+                        clearTurn(slot, eventTask);
+                    }
                 }));
             },
             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, next.message)), "task_failed");
+                    if (eventTask) {
+                        clearTurn(slot, eventTask);
+                    }
+                    await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(slot.adapter, formatTaskFailedMessage(slot.adapter, next.message)), "task_failed", eventTarget);
                 }));
             },
             fatalError: (next) => {
@@ -1079,10 +1248,12 @@ class WechatDaemon {
                 appendDaemonLog(`fatal_error: adapter=${slot.adapter} message=${next.message}`);
                 slot.pendingConfirmations = [];
                 slot.pendingUserInput = null;
-                slot.activeTask = null;
+                if (eventTask) {
+                    clearTurn(slot, eventTask);
+                }
                 this.disposeDeadSlot(slot);
                 this.trackWechatForwardTask(slot.outputBatcher.flushNow().then(async () => {
-                    await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(slot.adapter, formatUserFacingBridgeFatalError(next.message)), "fatal_error");
+                    await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(slot.adapter, formatUserFacingBridgeFatalError(next.message)), "fatal_error", eventTarget);
                 }));
             },
             shutdownRequested: (next) => {
@@ -1094,9 +1265,25 @@ class WechatDaemon {
             appendDaemonLog(`event_forward_failed: adapter=${slot.adapter} message=${message}`);
         });
     }
+    resolveSlotOutputTarget(slot) {
+        return resolveConversationTarget({
+            active: slot.activeConversation,
+            last: slot.lastConversation,
+            fallback: this.fallbackConversation,
+        });
+    }
+    bindCurrentWecomConversation(slot) {
+        const conversation = this.inboundConversationContext.get();
+        if (this.channelId !== "wecom" || !slot || !conversation) {
+            return;
+        }
+        slot.lastConversation = 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, 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);
@@ -1108,6 +1295,7 @@ class WechatDaemon {
                     reuseExistingVisible: true,
                 });
                 if (result.activated) {
+                    this.bindCurrentWecomConversation(this.getActiveSlot());
                     message = { ...message, text: emojiMatch.remainder };
                 }
                 else {
@@ -1134,6 +1322,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 };
             }
@@ -1143,7 +1332,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);
@@ -1163,7 +1352,9 @@ 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,
@@ -1192,6 +1383,14 @@ class WechatDaemon {
                     await this.dispatchInboundWechatText(message, currentSlot);
                 },
             });
+            if (this.channelId === "wecom" &&
+                this.inboundConversationContext.get() &&
+                currentSlot.activeTask &&
+                currentSlot.activeTask !== previousTask) {
+                const conversation = this.inboundConversationContext.get();
+                currentSlot.activeConversation = conversation;
+                currentSlot.lastConversation = conversation;
+            }
         };
         const command = parseWechatControlCommand(message.text, {
             adapter: slot.adapter,
@@ -1215,6 +1414,7 @@ class WechatDaemon {
             return;
         }
         slot = this.getActiveSlot() ?? slot;
+        this.bindCurrentWecomConversation(slot);
         await routeCurrentMessage(slot, null);
     }
     async handleEmojiBindingsCommand(senderId, cmd) {
@@ -1239,12 +1439,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.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 {
@@ -1262,9 +1466,10 @@ class WechatDaemon {
                     if (command.target) {
                         await resumeSlot.outputBatcher.flushNow();
                     }
+                    const taskBeforeResume = resumeSlot.activeTask;
                     const result = await resumeSlot.resumeCoordinator.execute(command.target);
-                    if (result.kind === "resumed") {
-                        resumeSlot.activeTask = null;
+                    if (result.kind === "resumed" && taskBeforeResume) {
+                        clearTurn(resumeSlot, taskBeforeResume);
                     }
                     await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(resumeSlot.adapter, result.message));
                 }
@@ -1403,12 +1608,28 @@ class WechatDaemon {
     }
     async dispatchInboundWechatText(message, slot) {
         const preview = formatInboundMessagePreview(message);
-        slot.activeTask = {
+        const nextTask = {
             startedAt: Date.now(),
             inputPreview: truncatePreview(preview, 180),
         };
+        const inboundConversation = this.channelId === "wecom"
+            ? this.inboundConversationContext.get()
+            : undefined;
+        const lease = tryBeginTurn(slot, nextTask, inboundConversation);
+        if (!lease) {
+            await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(slot.adapter, `${slot.adapter} is still working. Wait for the current reply or use /stop.`));
+            return;
+        }
         appendDaemonLog(`forwarded_input: adapter=${slot.adapter} text=${truncatePreview(preview)}`);
-        await slot.runtime.sendInput(buildWechatInboundPrompt(message.text, message.attachments));
+        try {
+            await slot.runtime.sendInput(this.channelId === "wecom"
+                ? buildWecomInboundPrompt(message.text, message.attachments)
+                : buildWechatInboundPrompt(message.text, message.attachments));
+        }
+        catch (error) {
+            rollbackTurn(slot, lease);
+            throw error;
+        }
     }
     queueWechatTextAction(action) {
         const run = this.textSendChain.then(action);
@@ -1420,7 +1641,33 @@ class WechatDaemon {
         this.attachmentSendChain = run.then(() => undefined, () => undefined);
         return run;
     }
-    async sendWechatMessageNow(senderId, text, context = "message") {
+    async sendWechatMessageNow(senderId, text, context = "message", targetOverride) {
+        if (this.channelId === "wecom") {
+            const activeSlot = this.getActiveSlot();
+            const target = targetOverride ??
+                (senderId === this.authorizedUserId
+                    ? this.inboundConversationContext.get() ??
+                        (activeSlot ? this.resolveSlotOutputTarget(activeSlot) : this.fallbackConversation)
+                    : {
+                        channelId: "wecom",
+                        conversationId: senderId,
+                        recipientId: senderId,
+                        metadata: { chatType: "direct" },
+                    });
+            const startedAtMs = Date.now();
+            appendDaemonLog(`wecom_send_started: context=${context} recipient=${target.recipientId} chars=${Array.from(text).length}`);
+            try {
+                await this.wecomTransport.sendText(target, formatWecomVisibleText(text), toWecomOutputKind(context));
+                appendDaemonLog(`wecom_send_completed: context=${context} recipient=${target.recipientId} elapsed_ms=${Date.now() - startedAtMs}`);
+                return { status: "sent" };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                appendDaemonLog(`wecom_send_failed: context=${context} recipient=${target.recipientId} error=${truncatePreview(message, 400)}`);
+                logError(`Failed to send WeCom ${context}: ${message}`);
+                return { status: "context_unavailable", error, target };
+            }
+        }
         const startedAtMs = Date.now();
         appendDaemonLog(`wechat_send_started: context=${context} recipient=${senderId} chars=${Array.from(text).length}`);
         for (let attempt = 1; attempt <= WECHAT_SEND_MAX_ATTEMPTS; attempt += 1) {
@@ -1467,11 +1714,17 @@ class WechatDaemon {
         }
         return { status: "failed" };
     }
-    queueWechatMessage(senderId, text, context = "message") {
+    queueWechatMessage(senderId, text, context = "message", targetOverride) {
+        const activeSlot = this.getActiveSlot();
+        const queuedTarget = this.channelId === "wecom" && senderId === this.authorizedUserId
+            ? targetOverride ??
+                this.inboundConversationContext.get() ??
+                (activeSlot ? this.resolveSlotOutputTarget(activeSlot) : this.fallbackConversation)
+            : targetOverride;
         return this.queueWechatTextAction(async () => {
-            const result = await this.sendWechatMessageNow(senderId, text, context);
+            const result = await this.sendWechatMessageNow(senderId, text, context, queuedTarget);
             if (result.status === "context_unavailable") {
-                const pending = this.pendingWechatMessages.enqueue(senderId, text, context);
+                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}`);
                 }
@@ -1482,7 +1735,7 @@ class WechatDaemon {
     flushPendingWechatMessages() {
         return this.queueWechatTextAction(async () => {
             for (const pending of this.pendingWechatMessages.list()) {
-                const result = await this.sendWechatMessageNow(pending.recipientId, pending.text, pending.context);
+                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}`);
@@ -1793,7 +2046,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();
@@ -1809,19 +2064,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;
@@ -1837,6 +2109,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"));
@@ -1871,7 +2146,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();
 }