@unlinearity/cli-wechat-bridge 1.1.4 → 1.1.6

package/dist/daemon/wechat-daemon.js

@@ -8,17 +8,21 @@ 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 { WECHAT_SEND_MAX_ATTEMPTS, computeWechatSendRetryDelayMs, formatUserFacingBridgeFatalError, formatUserFacingInboundError, formatWechatContextTokenStaleLogEntry, formatWechatSendFailureLogEntry, isRetryableWechatSendError, shouldForwardBridgeEventToWechat, } from "../bridge/wechat-forwarding.js";
+import { ResumeSessionCoordinator, isWechatResumeEnabled, shouldForwardSessionSwitchEvent, } from "../bridge/bridge-session-resume.js";
+import { WECHAT_SEND_MAX_ATTEMPTS, computeWechatSendRetryDelayMs, formatUserFacingBridgeFatalError, formatUserFacingInboundError, formatWechatContextTokenStaleLogEntry, formatWechatSendFailureLogEntry, isWechatContextUnavailableError, isRetryableWechatSendError, shouldForwardBridgeEventToWechat, shouldSuppressCodexLocalThreadNotice, } from "../channels/wechat/wechat-forwarding.js";
 import { 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 { formatResumeSessionList } from "../bridge/bridge-utils.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 { 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 { WechatChannelPort } from "../channels/wechat/wechat-channel-port.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);
@@ -493,6 +497,7 @@ class WechatDaemon {
     textSendChain = Promise.resolve();
     attachmentSendChain = Promise.resolve();
     pendingWechatForwardTasks = new Set();
+    pendingWechatMessages;
     shutdownPromise = null;
     ipcServer = null;
     endpointToken = "";
@@ -501,6 +506,7 @@ class WechatDaemon {
         this.profile = params.profile;
         this.authorizedUserId = params.authorizedUserId;
         this.transport = params.transport;
+        this.pendingWechatMessages = new PendingWechatMessageStore(getPendingWechatMessagesFile(this.cwd));
     }
     async startIpcServer() {
         this.endpointToken = buildDaemonToken();
@@ -624,6 +630,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) {
@@ -893,8 +902,14 @@ class WechatDaemon {
             }),
             pendingConfirmations: [],
             pendingUserInput: null,
+            resumeCoordinator: new ResumeSessionCoordinator({
+                adapter,
+                runtime,
+            }),
             activeTask: null,
             lastOutputAt: 0,
+            lastFinalReplyAtMs: 0,
+            eventForwardChain: Promise.resolve(),
         };
         runtime.setEventSink((event) => {
             this.handleSlotEvent(slot, event);
@@ -921,154 +936,163 @@ class WechatDaemon {
         }
         slot.controller.syncLocalClientEndpoint();
     }
+    createWechatChannelPort(adapter) {
+        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, {
-                                recipientId: this.authorizedUserId,
-                            })),
+                    await channelPort.send({
+                        target: {
+                            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":
-                appendDaemonLog(`session_switched: adapter=${slot.adapter} session=${event.sessionId} source=${event.source} reason=${event.reason}`);
-                if (shouldForwardBridgeEventToWechat(slot.adapter, event.type)) {
+            },
+            sessionSwitched: (next) => {
+                if (next.source === "local")
+                    slot.resumeCoordinator.clear();
+                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":
-                appendDaemonLog(`thread_switched: adapter=${slot.adapter} thread=${event.threadId} source=${event.source} reason=${event.reason}`);
-                if (shouldForwardBridgeEventToWechat(slot.adapter, event.type)) {
+            },
+            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;
+                }
+                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;
                 }));
-                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");
+                    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;
                 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}`);
+        });
     }
     async handleInboundMessage(message) {
         if (message.senderId !== this.authorizedUserId) {
@@ -1139,21 +1163,47 @@ class WechatDaemon {
             await this.queueWechatMessage(message.senderId, formatNoActiveAdapterMessage());
             return;
         }
+        const routeCurrentMessage = async (currentSlot, command) => {
+            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);
+                },
+            });
+        };
         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, {
@@ -1165,21 +1215,7 @@ 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);
+        await routeCurrentMessage(slot, null);
     }
     async handleEmojiBindingsCommand(senderId, cmd) {
         switch (cmd.type) {
@@ -1207,29 +1243,33 @@ class WechatDaemon {
                 await this.queueWechatMessage(message.senderId, formatDaemonStatus(this.getStatus()));
                 return;
             case "resume": {
-                if (activeSlot.adapter !== "opencode") {
+                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.`);
                     return;
                 }
-                if (command.type !== "resume") {
-                    return;
-                }
                 try {
+                    let resumeSlot = activeSlot;
+                    if (activeSlot.adapter === "codex" && command.target) {
+                        const visible = await this.ensureSlot("codex", {
+                            openVisible: true,
+                            reuseExistingVisible: true,
+                        });
+                        if (!visible.activated) {
+                            throw new Error(formatDaemonSwitchResultDetail(visible));
+                        }
+                        resumeSlot = this.slots.get("codex") ?? activeSlot;
+                    }
                     if (command.target) {
-                        await activeSlot.runtime.resumeSession(command.target);
-                        await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(activeSlot.adapter, `Resumed OpenCode session ${command.target}.`));
+                        await resumeSlot.outputBatcher.flushNow();
                     }
-                    else {
-                        const candidates = await activeSlot.runtime.listResumeSessions(8);
-                        await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(activeSlot.adapter, formatResumeSessionList({
-                            adapter: activeSlot.adapter,
-                            candidates,
-                            currentSessionId: activeSlot.runtime.getState().sharedSessionId,
-                        })));
+                    const result = await resumeSlot.resumeCoordinator.execute(command.target);
+                    if (result.kind === "resumed") {
+                        resumeSlot.activeTask = null;
                     }
+                    await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(resumeSlot.adapter, result.message));
                 }
                 catch (error) {
-                    await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(activeSlot.adapter, `Failed to resume OpenCode session: ${error instanceof Error ? error.message : String(error)}`));
+                    await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(activeSlot.adapter, error instanceof Error ? error.message : String(error)));
                 }
                 return;
             }
@@ -1242,6 +1282,7 @@ class WechatDaemon {
                 activeSlot.outputBatcher.clear();
                 activeSlot.pendingConfirmations = [];
                 activeSlot.pendingUserInput = null;
+                activeSlot.resumeCoordinator.clear();
                 await activeSlot.runtime.createSession();
                 appendDaemonLog(`new_session: adapter=${activeSlot.adapter}`);
                 return;
@@ -1257,6 +1298,7 @@ class WechatDaemon {
                 activeSlot.outputBatcher.clear();
                 activeSlot.pendingConfirmations = [];
                 activeSlot.pendingUserInput = null;
+                activeSlot.resumeCoordinator.clear();
                 await activeSlot.runtime.reset();
                 appendDaemonLog(`reset: adapter=${activeSlot.adapter}`);
                 await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(activeSlot.adapter, "Worker session has been reset."));
@@ -1378,39 +1420,80 @@ 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") {
+        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") {
+        return this.queueWechatTextAction(async () => {
+            const result = await this.sendWechatMessageNow(senderId, text, context);
+            if (result.status === "context_unavailable") {
+                const pending = this.pendingWechatMessages.enqueue(senderId, text, context);
+                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);
+                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) {

package/dist/i18n/messages-en.js

@@ -25,7 +25,7 @@ export const messages = {
     // === Hook health check ===
     "hook.healthCheck.warning": "[Warning] No hook events received from Claude after 15s.\nThe hook system may not be working — Claude output will not reach WeChat.",
     "hook.healthCheck.logHint": "\nCheck: {logPath}",
-    "hook.healthCheck.fixes": "\nCommon fixes:\n- Ensure Node.js >= 22.6.0: node --version\n- Reinstall: npm install -g cli-wechat-bridge@latest\n- Check firewall: allow localhost TCP connections",
+    "hook.healthCheck.fixes": "\nCommon fixes:\n- Ensure Node.js >= 22.13.0: node --version\n- Reinstall: npm install -g cli-wechat-bridge@latest\n- Check firewall: allow localhost TCP connections",
     // === PTY fallback ===
     "pty.fallback.warning": "[Warning] PTY unavailable — using fallback mode (TERM=dumb).\nCore features (messaging, approvals, session management) work normally; terminal rendering (colors, progress bars) may be degraded.\nFix: Linux install build-essential python3 | Windows run npm rebuild node-pty | macOS run xcode-select --install\nRun --doctor for detailed environment info.\n",
     // === Spawn diagnostic ===
@@ -36,7 +36,7 @@ export const messages = {
     "spawn.diagnostic.linuxBuildTools": "- Linux requires build tools for node-pty: sudo apt install build-essential python3\n- Then reinstall: npm install -g cli-wechat-bridge@latest",
     "spawn.diagnostic.notFound": "- The command \"{target}\" was not found on PATH.\n- Verify it is installed and accessible from your terminal.",
     "spawn.diagnostic.generic": "- Reinstall: npm install -g cli-wechat-bridge@latest",
-    "spawn.diagnostic.nodeVersion": "- Ensure Node.js >= 22.6.0: node --version",
+    "spawn.diagnostic.nodeVersion": "- Ensure Node.js >= 22.13.0: node --version",
     "spawn.diagnostic.winFull": "- Ensure Windows 10 build 18309+ (run 'winver' to check)\n- Install Visual C++ Redistributable: https://aka.ms/vs/17/release/vc_redist.x64.exe\n- Run: npm rebuild node-pty\n- Try running as Administrator",
     // === Emoji bindings ===
     "binding.usage": "Invalid format.\nUsage: /bind [emoji] command\nExample: /bind 🚀 deploy --prod",

package/dist/i18n/messages-zh.js

@@ -25,7 +25,7 @@ export const messages = {
     // === Hook 健康检查 ===
     "hook.healthCheck.warning": "[警告] 15 秒内未收到 Claude hook 事件。\nhook 系统可能未正常工作 — Claude 的输出将无法到达微信。",
     "hook.healthCheck.logHint": "\n查看日志: {logPath}",
-    "hook.healthCheck.fixes": "\n常见修复方法:\n- 确保 Node.js >= 22.6.0: node --version\n- 重新安装: npm install -g cli-wechat-bridge@latest\n- 检查防火墙: 允许 localhost TCP 连接",
+    "hook.healthCheck.fixes": "\n常见修复方法:\n- 确保 Node.js >= 22.13.0: node --version\n- 重新安装: npm install -g cli-wechat-bridge@latest\n- 检查防火墙: 允许 localhost TCP 连接",
     // === PTY 回退 ===
     "pty.fallback.warning": "[警告] PTY 不可用 — 已切换到回退模式（TERM=dumb）。\n核心功能（消息收发、审批、会话管理）正常工作；终端渲染（颜色、进度条）可能受限。\n修复方法: Linux 安装 build-essential python3 | Windows 运行 npm rebuild node-pty | macOS 运行 xcode-select --install\n运行 --doctor 查看详细环境信息。\n",
     // === 启动诊断 ===
@@ -36,7 +36,7 @@ export const messages = {
     "spawn.diagnostic.linuxBuildTools": "- Linux 需要编译工具来构建 node-pty: sudo apt install build-essential python3\n- 然后重新安装: npm install -g cli-wechat-bridge@latest",
     "spawn.diagnostic.notFound": "- 命令 \"{target}\" 未在 PATH 中找到。\n- 请确认已安装并可从终端访问。",
     "spawn.diagnostic.generic": "- 重新安装: npm install -g cli-wechat-bridge@latest",
-    "spawn.diagnostic.nodeVersion": "- 确保 Node.js >= 22.6.0: node --version",
+    "spawn.diagnostic.nodeVersion": "- 确保 Node.js >= 22.13.0: node --version",
     "spawn.diagnostic.winFull": "- 确保 Windows 10 build 18309+（运行 winver 查看）\n- 安装 Visual C++ Redistributable: https://aka.ms/vs/17/release/vc_redist.x64.exe\n- 运行: npm rebuild node-pty\n- 尝试以管理员身份运行",
     // === Emoji 绑定 ===
     "binding.usage": "格式错误。\n用法: /bind [表情] 命令\n示例: /bind 🚀 deploy --prod",