cli-wechat-bridge 1.1.2 → 1.1.4

package/dist/daemon/wechat-daemon.js

@@ -12,10 +12,11 @@ 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 { formatUserFacingBridgeFatalError, formatUserFacingInboundError, formatWechatContextTokenStaleLogEntry, formatWechatSendFailureLogEntry, isRetryableWechatSendError, shouldForwardBridgeEventToWechat, } from "../bridge/wechat-bridge.js";
+import { WECHAT_SEND_MAX_ATTEMPTS, computeWechatSendRetryDelayMs, formatUserFacingBridgeFatalError, formatUserFacingInboundError, formatWechatContextTokenStaleLogEntry, formatWechatSendFailureLogEntry, isRetryableWechatSendError, shouldForwardBridgeEventToWechat, } from "../bridge/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 { createRuntimeHost, } from "../runtime/create-runtime-host.js";
 import { clearLocalCompanionEndpoint, clearLocalCompanionOccupancy, readLocalCompanionEndpoint, } from "../companion/local-companion-link.js";
@@ -26,8 +27,6 @@ const RUNTIME_ENTRY_EXTENSION = path.extname(MODULE_FILE) === ".ts" ? ".ts" : ".
 const DAEMON_HOST = "127.0.0.1";
 const POLL_RETRY_BASE_MS = 1_000;
 const POLL_RETRY_MAX_MS = 30_000;
-const WECHAT_SEND_MAX_ATTEMPTS = 3;
-const WECHAT_SEND_RETRY_BASE_MS = 750;
 const SINGLE_BRIDGE_STOP_TIMEOUT_MS = 10_000;
 const SINGLE_BRIDGE_FORCE_STOP_TIMEOUT_MS = 3_000;
 const SINGLE_BRIDGE_STOP_POLL_MS = 250;
@@ -36,7 +35,7 @@ const DAEMON_TAKEOVER_FORCE_STOP_TIMEOUT_MS = 3_000;
 const DAEMON_TAKEOVER_STOP_POLL_MS = 250;
 const VISIBLE_CLIENT_CONNECT_TIMEOUT_MS = 15_000;
 const VISIBLE_CLIENT_CONNECT_POLL_MS = 250;
-const DAEMON_ADAPTERS = ["codex", "claude", "opencode"];
+const DAEMON_ADAPTERS = ["codex", "claude", "opencode", "pi"];
 function log(message) {
     process.stderr.write(`[wechat-daemon] ${message}\n`);
 }
@@ -52,11 +51,8 @@ function computePollRetryDelayMs(consecutiveFailures) {
     const exponent = Math.min(normalizedFailures - 1, 5);
     return Math.min(POLL_RETRY_MAX_MS, POLL_RETRY_BASE_MS * 2 ** exponent);
 }
-function computeWechatSendRetryDelayMs(attempt) {
-    return WECHAT_SEND_RETRY_BASE_MS * attempt;
-}
 function isDaemonAdapterKind(value) {
-    return value === "codex" || value === "claude" || value === "opencode";
+    return value === "codex" || value === "claude" || value === "opencode" || value === "pi";
 }
 function isSameWorkspaceCwd(left, right) {
     const normalizedLeft = path.resolve(left);
@@ -84,10 +80,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>] [--profile <name-or-path>] [--no-open]",
+                "Usage: wechat-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, and OpenCode from WeChat.",
-                "Send /codex, /claude, or /opencode in WeChat to switch the active terminal.",
+                "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.",
                 "",
             ].join("\n"));
             process.exit(0);
@@ -133,20 +129,38 @@ export function parseDaemonSwitchCommand(text) {
             return "claude";
         case "/opencode":
             return "opencode";
+        case "/pi":
+            return "pi";
         default:
             return null;
     }
 }
+export function parseDaemonSwitchDirective(text) {
+    const match = text
+        .trim()
+        .match(/^\/(codex|claude|opencode|pi)(?:\s+([\s\S]+))?$/i);
+    if (!match) {
+        return null;
+    }
+    return {
+        adapter: match[1].toLowerCase(),
+        remainder: match[2]?.trim() ?? "",
+    };
+}
 export function defaultDaemonSessionStartMode(adapter) {
-    return adapter === "claude" || adapter === "opencode" ? "new" : "restore";
+    return adapter === "codex" ? "restore" : "new";
 }
 export function resolveDaemonSessionStartMode(params) {
-    if (params.reuseExistingVisible && params.visibleConnected) {
-        return "restore";
-    }
+    // An explicit --session-start-mode wins over visible-client reuse: the user
+    // asked for a fresh (or restored) session on purpose, so silently degrading
+    // "new" back to "restore" because a window happens to be connected would
+    // ignore the request.
     if (params.explicitSessionStartMode) {
         return params.explicitSessionStartMode;
     }
+    if (params.reuseExistingVisible && params.visibleConnected) {
+        return "restore";
+    }
     if (params.adapter === "codex") {
         return "restore";
     }
@@ -340,6 +354,12 @@ function isVisibleClientAlive(cwd, adapter) {
     clearLocalCompanionOccupancy(cwd, endpoint.instanceId, { adapter });
     return false;
 }
+export function shouldRestartDeadCodexVisibleRuntime(params) {
+    return (params.adapter === "codex" &&
+        !params.slotCreated &&
+        params.hadVisibleClient &&
+        !params.visibleConnected);
+}
 function cleanupVisibleClientLauncher(launch) {
     if (!launch.pid || !isPidAlive(launch.pid)) {
         return false;
@@ -370,6 +390,24 @@ export async function waitForVisibleClientConnection(params, deps = {}) {
         await sleepFn(Math.min(pollMs, remainingMs));
     }
 }
+export async function waitForCodexVisibleThread(params, deps = {}) {
+    const timeoutMs = params.timeoutMs ?? VISIBLE_CLIENT_CONNECT_TIMEOUT_MS;
+    const pollMs = params.pollMs ?? VISIBLE_CLIENT_CONNECT_POLL_MS;
+    const sleepFn = deps.sleep ?? sleep;
+    const now = deps.now ?? (() => Date.now());
+    const deadline = now() + timeoutMs;
+    while (true) {
+        const threadId = params.getThreadId();
+        if (threadId) {
+            return threadId;
+        }
+        const remainingMs = deadline - now();
+        if (remainingMs <= 0) {
+            return null;
+        }
+        await sleepFn(Math.min(pollMs, remainingMs));
+    }
+}
 function formatInboundMessagePreview(message) {
     if (message.text.trim()) {
         return message.text;
@@ -384,7 +422,7 @@ function formatInboundMessagePreview(message) {
 function formatNoActiveAdapterMessage() {
     return [
         "No active terminal is selected.",
-        "Send /codex, /claude, or /opencode to choose one.",
+        "Send /codex, /claude, /opencode, or /pi to choose one.",
     ].join("\n");
 }
 export function formatDaemonSwitchResultDetail(result) {
@@ -392,6 +430,9 @@ export function formatDaemonSwitchResultDetail(result) {
         const previous = result.previousActiveAdapter
             ? ` Active terminal remains ${result.previousActiveAdapter}.`
             : " No terminal is active yet.";
+        if (result.visibleConnected && result.visibleReady === false) {
+            return `The visible Codex CLI connected, but its active thread is not ready yet.${previous} Check ${BRIDGE_LOG_FILE}.`;
+        }
         if (result.openedVisible) {
             return result.created
                 ? `Started the bridge slot and tried to open the visible CLI, but it has not connected yet.${previous} Check ${BRIDGE_LOG_FILE}.`
@@ -442,6 +483,8 @@ class WechatDaemon {
     authorizedUserId;
     transport;
     slots = new Map();
+    // Per-adapter serialization chains for ensureSlot (see ensureSlot comment).
+    slotEnsureChains = new Map();
     startedAt = new Date().toISOString();
     bridgeStartedAtMs = Date.now();
     backlogNoticeSent = false;
@@ -543,7 +586,7 @@ class WechatDaemon {
         let consecutivePollFailures = 0;
         log("WeChat daemon is ready.");
         log(`Working directory: ${this.cwd}`);
-        log("Switch from WeChat with /codex, /claude, or /opencode.");
+        log("Switch from WeChat with /codex, /claude, /opencode, or /pi.");
         appendDaemonLog(`started: cwd=${this.cwd}`);
         const activeSlot = this.getActiveSlot();
         const welcomeText = t("daemon.welcome", {
@@ -597,14 +640,12 @@ class WechatDaemon {
                 }
                 catch (error) {
                     const errorText = error instanceof Error ? error.message : String(error);
-                    const isUserFacingShellRejection = error instanceof Error && error.name === "ShellCommandRejectedError";
                     logError(errorText);
-                    appendDaemonLog(`${isUserFacingShellRejection ? "inbound_rejected" : "inbound_error"}: ${errorText}`);
+                    appendDaemonLog(`inbound_error: ${errorText}`);
                     await this.queueWechatMessage(message.senderId, formatUserFacingInboundError({
                         adapter: this.activeAdapter ?? "codex",
                         cwd: this.cwd,
                         errorText,
-                        isUserFacingShellRejection,
                     }), "inbound_error");
                 }
             }
@@ -616,6 +657,32 @@ class WechatDaemon {
         }
         await this.shutdownPromise;
     }
+    /**
+     * Remove a slot whose runtime reported a fatal (terminal) error. The dead
+     * runtime would otherwise stay in the slot map forever: every later message
+     * would fail against it ("adapter is not running") with no path back to a
+     * working adapter short of a manual /reset or daemon restart. After removal,
+     * the next switch directive (/codex etc.) rebuilds the adapter from scratch.
+     */
+    disposeDeadSlot(slot) {
+        if (this.slots.get(slot.adapter) !== slot) {
+            return; // Already replaced by a newer ensureSlot run.
+        }
+        this.slots.delete(slot.adapter);
+        if (this.activeAdapter === slot.adapter) {
+            this.activeAdapter = null;
+        }
+        appendDaemonLog(`dead_slot_disposed: adapter=${slot.adapter}`);
+        void (async () => {
+            try {
+                await slot.runtime.dispose();
+            }
+            catch {
+                // Best effort: the runtime already reported a fatal error.
+            }
+            slot.controller.clearLocalClientEndpoint();
+        })();
+    }
     async cleanup() {
         appendDaemonLog("shutdown_started");
         for (const slot of this.slots.values()) {
@@ -680,6 +747,19 @@ class WechatDaemon {
         }
     }
     async ensureSlot(adapter, options = {}) {
+        // Serialize per-adapter ensureSlot runs. The IPC handler, the WeChat poll
+        // loop, and startup can all call this concurrently; without serialization
+        // two callers would both observe an empty slot map, create two runtimes,
+        // and the second slots.set would orphan the first (duplicate PTY child,
+        // double visible client, endpoint files overwriting each other).
+        const tail = this.slotEnsureChains.get(adapter) ?? Promise.resolve();
+        const run = tail.then(() => this.runEnsureSlot(adapter, options), 
+        // A rejected predecessor must not block this run — start fresh either way.
+        () => this.runEnsureSlot(adapter, options));
+        this.slotEnsureChains.set(adapter, run.then(() => undefined, () => undefined));
+        return run;
+    }
+    async runEnsureSlot(adapter, options = {}) {
         const previousActiveAdapter = this.activeAdapter ?? undefined;
         let slot = this.slots.get(adapter);
         let created = false;
@@ -697,7 +777,24 @@ class WechatDaemon {
             created = true;
         }
         let openedVisible = false;
+        const visibleEndpointBeforeProbe = readLocalCompanionEndpoint(this.cwd, {
+            adapter,
+        });
+        const hadVisibleClient = Boolean(visibleEndpointBeforeProbe?.companionPid ||
+            visibleEndpointBeforeProbe?.companionConnectedAt ||
+            visibleEndpointBeforeProbe?.sharedThreadId ||
+            visibleEndpointBeforeProbe?.sharedSessionId);
         let visibleConnected = isVisibleClientAlive(this.cwd, adapter);
+        if (shouldRestartDeadCodexVisibleRuntime({
+            adapter,
+            slotCreated: created,
+            hadVisibleClient,
+            visibleConnected,
+        })) {
+            await this.startFreshSlotSession(slot);
+            appendDaemonLog(`dead_visible_codex_runtime_restarted: cwd=${this.cwd}`);
+        }
+        const sharedSessionBeforeVisible = getSharedSessionIdFromAdapterState(slot.runtime.getState());
         const sessionStartMode = resolveDaemonSessionStartMode({
             adapter,
             explicitSessionStartMode: options.sessionStartMode,
@@ -707,9 +804,10 @@ class WechatDaemon {
             reuseExistingVisible: options.reuseExistingVisible !== false,
         });
         if (!created &&
-            options.reuseExistingVisible === false &&
+            (options.reuseExistingVisible === false ||
+                options.sessionStartMode === "new") &&
             sessionStartMode === "new" &&
-            (adapter === "claude" || adapter === "opencode") &&
+            (adapter === "claude" || adapter === "opencode" || adapter === "pi") &&
             visibleConnected) {
             await this.startFreshSlotSession(slot);
             appendDaemonLog(`fresh_session_started: adapter=${adapter} source=start_command`);
@@ -740,16 +838,36 @@ class WechatDaemon {
                 appendDaemonLog(`visible_client_connect_timeout: adapter=${adapter} cwd=${this.cwd} timeout_ms=${VISIBLE_CLIENT_CONNECT_TIMEOUT_MS} cleaned_launcher=${cleanedLauncher}`);
             }
         }
-        const activated = options.openVisible === false || visibleConnected;
+        let visibleReady = visibleConnected;
+        if (adapter === "codex" && visibleConnected && !sharedSessionBeforeVisible) {
+            const visibleThreadId = await waitForCodexVisibleThread({
+                getThreadId: () => {
+                    const state = slot.runtime.getState();
+                    if (state.lastThreadSwitchSource !== "local") {
+                        return undefined;
+                    }
+                    return state.sharedThreadId ?? state.sharedSessionId;
+                },
+            });
+            visibleReady = Boolean(visibleThreadId);
+            if (visibleThreadId) {
+                appendDaemonLog(`visible_codex_thread_ready: thread=${visibleThreadId} cwd=${this.cwd}`);
+            }
+            else {
+                appendDaemonLog(`visible_codex_thread_timeout: cwd=${this.cwd} timeout_ms=${VISIBLE_CLIENT_CONNECT_TIMEOUT_MS}`);
+            }
+        }
+        const activated = options.openVisible === false || (visibleConnected && visibleReady);
         if (activated) {
             this.activeAdapter = adapter;
         }
-        appendDaemonLog(`switch_adapter: adapter=${adapter} created=${created} opened_visible=${openedVisible} visible_connected=${visibleConnected} activated=${activated} previous_active=${previousActiveAdapter ?? "(none)"} session_start_mode=${sessionStartMode}`);
+        appendDaemonLog(`switch_adapter: adapter=${adapter} created=${created} opened_visible=${openedVisible} visible_connected=${visibleConnected} visible_ready=${visibleReady} activated=${activated} previous_active=${previousActiveAdapter ?? "(none)"} session_start_mode=${sessionStartMode}`);
         return {
             activeAdapter: adapter,
             created,
             openedVisible,
             visibleConnected,
+            visibleReady,
             activated,
             previousActiveAdapter,
         };
@@ -792,12 +910,12 @@ class WechatDaemon {
         slot.pendingConfirmations = [];
         slot.pendingUserInput = null;
         slot.activeTask = null;
-        if (slot.adapter === "claude") {
+        if (slot.adapter === "codex" || slot.adapter === "claude") {
             await slot.runtime.reset();
         }
-        else if (slot.adapter === "opencode") {
+        else if (slot.adapter === "opencode" || slot.adapter === "pi") {
             if (!slot.runtime.createSession) {
-                throw new Error("/new is not available in opencode mode.");
+                throw new Error(`/new is not available in ${slot.adapter} mode.`);
             }
             await slot.runtime.createSession();
         }
@@ -874,14 +992,19 @@ class WechatDaemon {
                     await this.queueWechatMessage(this.authorizedUserId, prefixDaemonAdapterMessage(slot.adapter, formatApprovalMessage(pending, adapterState)), "approval_required");
                 }));
                 break;
-            case "user_input_required":
+            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);
+                slot.pendingUserInput = pending;
+                appendDaemonLog(`user_input_required: adapter=${slot.adapter} questions=${pending.questions.length}`);
                 this.trackWechatForwardTask(slot.outputBatcher.flushNow().then(async () => {
-                    const pending = toPendingUserInput(event.request);
-                    slot.pendingUserInput = pending;
-                    appendDaemonLog(`user_input_required: adapter=${slot.adapter} questions=${pending.questions.length}`);
                     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 })) {
@@ -937,6 +1060,7 @@ class WechatDaemon {
                 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");
                 }));
@@ -975,18 +1099,24 @@ class WechatDaemon {
                 message = { ...message, text: rewritten };
             }
         }
-        const switchAdapter = parseDaemonSwitchCommand(message.text);
-        if (switchAdapter) {
-            const result = await this.ensureSlot(switchAdapter, {
+        const switchDirective = parseDaemonSwitchDirective(message.text);
+        if (switchDirective) {
+            const result = await this.ensureSlot(switchDirective.adapter, {
                 openVisible: true,
                 reuseExistingVisible: true,
             });
             const detail = formatDaemonSwitchResultDetail(result);
-            const heading = result.activated
-                ? `Active terminal: ${switchAdapter}.`
-                : `Could not activate terminal: ${switchAdapter}.`;
-            await this.queueWechatMessage(message.senderId, `${heading}\n${detail}`);
-            return;
+            if (!result.activated) {
+                await this.queueWechatMessage(message.senderId, `Could not activate terminal: ${switchDirective.adapter}.\n${detail}`);
+                return;
+            }
+            if (switchDirective.remainder) {
+                message = { ...message, text: switchDirective.remainder };
+            }
+            else {
+                await this.queueWechatMessage(message.senderId, `Active terminal: ${switchDirective.adapter}.\n${detail}`);
+                return;
+            }
         }
         if (message.text.trim().toLowerCase() === "/daemon-stop") {
             await this.queueWechatMessage(message.senderId, "Stopping wechat-daemon...");
@@ -1004,7 +1134,7 @@ class WechatDaemon {
             await this.queueWechatMessage(message.senderId, formatBindCommandUsage());
             return;
         }
-        const slot = this.getActiveSlot();
+        let slot = this.getActiveSlot();
         if (!slot) {
             await this.queueWechatMessage(message.senderId, formatNoActiveAdapterMessage());
             return;
@@ -1026,7 +1156,25 @@ class WechatDaemon {
             await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(slot.adapter, formatPendingUserInputReminder(slot.pendingUserInput)));
             return;
         }
+        const visibleResult = await this.ensureSlot(slot.adapter, {
+            openVisible: true,
+            reuseExistingVisible: true,
+        });
+        if (!visibleResult.activated) {
+            await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(slot.adapter, formatDaemonSwitchResultDetail(visibleResult)));
+            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;
@@ -1058,9 +1206,33 @@ class WechatDaemon {
             case "status":
                 await this.queueWechatMessage(message.senderId, formatDaemonStatus(this.getStatus()));
                 return;
-            case "resume":
-                await this.queueWechatMessage(message.senderId, `WeChat /resume is disabled in daemon mode. Use /resume directly inside the visible ${activeSlot.adapter} terminal; WeChat will follow that local session.`);
+            case "resume": {
+                if (activeSlot.adapter !== "opencode") {
+                    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 {
+                    if (command.target) {
+                        await activeSlot.runtime.resumeSession(command.target);
+                        await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(activeSlot.adapter, `Resumed OpenCode session ${command.target}.`));
+                    }
+                    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,
+                        })));
+                    }
+                }
+                catch (error) {
+                    await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(activeSlot.adapter, `Failed to resume OpenCode session: ${error instanceof Error ? error.message : String(error)}`));
+                }
                 return;
+            }
             case "new_session":
                 if (!activeSlot.runtime.createSession) {
                     await this.queueWechatMessage(message.senderId, `/new is not available in ${activeSlot.adapter} mode.`);
@@ -1138,28 +1310,42 @@ class WechatDaemon {
         await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(slot.adapter, count > 1 ? `${count} approvals denied.` : "Approval denied."));
     }
     async answerPendingUserInput(message, activeSlot, raw) {
-        const pending = activeSlot.pendingUserInput;
+        // Mirror the /confirm and /deny behavior: search every slot for a pending
+        // user-input request so the answer reaches the adapter that asked, even
+        // when the user has since switched the active adapter.
+        const slot = this.resolvePendingUserInputSlot(activeSlot);
+        if (!slot) {
+            await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(activeSlot.adapter, "No pending user input request."));
+            return;
+        }
+        const pending = slot.pendingUserInput;
         if (!pending) {
             await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(activeSlot.adapter, "No pending user input request."));
             return;
         }
         const parsed = parsePendingUserInputAnswerCommand(raw, pending);
         if ("error" in parsed) {
-            await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(activeSlot.adapter, parsed.error));
+            await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(slot.adapter, parsed.error));
             return;
         }
-        const submitted = await activeSlot.runtime.submitUserInput(parsed.answers);
+        const submitted = await slot.runtime.submitUserInput(parsed.answers);
         if (!submitted) {
-            await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(activeSlot.adapter, "The worker could not apply this answer."));
+            await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(slot.adapter, "The worker could not apply this answer."));
             return;
         }
-        activeSlot.pendingUserInput = null;
-        activeSlot.activeTask = {
+        slot.pendingUserInput = null;
+        slot.activeTask = {
             startedAt: Date.now(),
             inputPreview: parsed.preview,
         };
-        appendDaemonLog(`user_input_answered: adapter=${activeSlot.adapter} preview=${parsed.preview}`);
-        await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(activeSlot.adapter, "Answer submitted. Continuing..."));
+        appendDaemonLog(`user_input_answered: adapter=${slot.adapter} preview=${parsed.preview}`);
+        await this.queueWechatMessage(message.senderId, prefixDaemonAdapterMessage(slot.adapter, "Answer submitted. Continuing..."));
+    }
+    resolvePendingUserInputSlot(activeSlot) {
+        if (activeSlot.pendingUserInput) {
+            return activeSlot;
+        }
+        return (Array.from(this.slots.values()).find((slot) => slot.pendingUserInput !== null) ?? null);
     }
     resolvePendingApprovalSlot(activeSlot) {
         if (activeSlot.pendingConfirmations.length > 0) {
@@ -1167,13 +1353,6 @@ class WechatDaemon {
         }
         return (Array.from(this.slots.values()).find((slot) => slot.pendingConfirmations.length > 0) ?? null);
     }
-    countPendingApprovals() {
-        let count = 0;
-        for (const slot of this.slots.values()) {
-            count += slot.pendingConfirmations.length;
-        }
-        return count;
-    }
     getActiveSlot() {
         if (!this.activeAdapter) {
             return null;
@@ -1565,27 +1744,35 @@ export async function runDaemon(options) {
         daemon.takenOverAdapter = cleanupResult.lock.adapter;
     }
     await daemon.startIpcServer();
-    await daemon.runInitialAdapter(options);
-    let shutdownInProgress = false;
-    const handleSignal = (signal) => {
-        if (shutdownInProgress) {
-            log(`Received ${signal} during shutdown, forcing exit.`);
-            process.exit(1);
-        }
-        shutdownInProgress = true;
-        log(`Received ${signal}. Stopping daemon.`);
-        void daemon.shutdown().finally(() => process.exit(0));
-    };
-    process.on("SIGINT", () => handleSignal("SIGINT"));
-    process.on("SIGTERM", () => handleSignal("SIGTERM"));
-    process.on("SIGHUP", () => handleSignal("SIGHUP"));
-    if (process.platform === "win32") {
-        process.on("SIGBREAK", () => handleSignal("SIGBREAK"));
+    try {
+        await daemon.runInitialAdapter(options);
+        let shutdownInProgress = false;
+        const handleSignal = (signal) => {
+            if (shutdownInProgress) {
+                log(`Received ${signal} during shutdown, forcing exit.`);
+                process.exit(1);
+            }
+            shutdownInProgress = true;
+            log(`Received ${signal}. Stopping daemon.`);
+            void daemon.shutdown().finally(() => process.exit(0));
+        };
+        process.on("SIGINT", () => handleSignal("SIGINT"));
+        process.on("SIGTERM", () => handleSignal("SIGTERM"));
+        process.on("SIGHUP", () => handleSignal("SIGHUP"));
+        if (process.platform === "win32") {
+            process.on("SIGBREAK", () => handleSignal("SIGBREAK"));
+        }
+        process.on("exit", () => {
+            clearDaemonEndpoint();
+        });
+        await daemon.runPollLoop();
+    }
+    catch (error) {
+        // Abnormal exit (poll loop failure, initial adapter failure): dispose the
+        // slot runtimes so adapter child processes are not stranded as orphans.
+        await daemon.shutdown().catch(() => undefined);
+        throw error;
     }
-    process.on("exit", () => {
-        clearDaemonEndpoint();
-    });
-    await daemon.runPollLoop();
 }
 export async function main(argv = process.argv.slice(2)) {
     if (argv.includes("--doctor")) {

package/dist/i18n/index.js

@@ -5,9 +5,6 @@ const catalogs = {
     en: enMessages,
 };
 let currentLocale = "zh";
-export function getLocale() {
-    return currentLocale;
-}
 export function setLocale(locale) {
     currentLocale = locale;
 }

package/dist/i18n/messages-en.js

@@ -1,6 +1,6 @@
 export const messages = {
     // === Bridge welcome & control ===
-    "bridge.welcome": "WeChat Bridge ready ({adapter}).\nCWD: {cwd}\n\nCommands: /stop, /confirm, /deny, /status, /new\n{bindings}\n\nManage: /bind [emoji] cmd, /unbind [emoji], /bindings",
+    "bridge.welcome": "WeChat Bridge ready ({adapter}).\nCWD: {cwd}",
     "bridge.stopped": "Bridge stopped.",
     "bridge.interrupt.sent": "Interrupt signal sent.",
     "bridge.interrupt.notBusy": "No active task to interrupt.",
@@ -11,8 +11,8 @@ export const messages = {
     "bridge.fatalError": "Bridge error: {message}",
     "bridge.backlogIgnored": "Ignored {count} backlog message(s) sent before the bridge started (they will not be processed).\nIf you actually sent them after the bridge started, your system clock is likely skewed by more than {graceSeconds}s — sync the clock and restart the bridge.",
     // === Daemon welcome & control ===
-    "daemon.welcome": "WeChat Daemon ready.\nCWD: {cwd}\nActive: {adapter}\n\nCommands: /claude, /codex, /opencode, /stop, /confirm, /deny, /status\n{bindings}\n\nManage: /bind [emoji] cmd, /unbind [emoji], /bindings",
-    "daemon.noActiveAdapter": "No active terminal is selected. Send /codex, /claude, or /opencode to start one.",
+    "daemon.welcome": "WeChat Daemon ready.\nCWD: {cwd}\nActive: {adapter}\n\nCommands: /claude, /codex, /opencode, /pi, /stop, /confirm, /deny, /status\n{bindings}\n\nManage: /bind [emoji] cmd, /unbind [emoji], /bindings",
+    "daemon.noActiveAdapter": "No active terminal is selected. Send /codex, /claude, /opencode, or /pi to start one.",
     "daemon.switchResult.new": "Started a new visible CLI.",
     "daemon.switchResult.reused": "Reused the existing visible CLI.",
     // === Approval ===
@@ -66,7 +66,6 @@ export const messages = {
     "doctor.clock.ok": "~{skewSeconds}s skew vs server time",
     "doctor.clock.skewWarning": "~{skewSeconds}s skew vs server time (large skew makes the bridge treat fresh messages as pre-start backlog — sync the system clock)",
     "doctor.label.nodePty": "node-pty",
-    "doctor.label.shell": "shell",
     "doctor.label.dataDir": "Data dir",
     "doctor.label.credentials": "Credentials",
     "doctor.label.mode": "Mode",
@@ -79,7 +78,6 @@ export const messages = {
     "doctor.winBuildConpty": "(ConPTY requires build 18309+)",
     "doctor.nodePty.loaded": "loaded",
     "doctor.nodePty.fix": "Fix: {fix}",
-    "doctor.adapterCli.shellNative": "uses the local shell; no other adapter CLI is checked.",
     "doctor.adapterCli.notFound": "not found{optional}",
     "doctor.dataDirMissing": "(will be created on first run)",
     "doctor.credentialsFound": "found",
@@ -88,6 +86,7 @@ export const messages = {
     "doctor.mode.generic": "generic",
     "doctor.notSpecified": "(not specified)",
     "doctor.none": "none",
+    "doctor.endpoint.corrupted": "endpoint file exists but cannot be parsed; it will be replaced on the next successful write",
     "doctor.unknown": "unknown",
     "doctor.yes": "yes",
     "doctor.no": "no",