cli-wechat-bridge 1.1.3 → 1.1.4

package/dist/companion/local-companion-start.js

@@ -16,7 +16,7 @@ const RUNTIME_ENTRY_EXTENSION = path.extname(MODULE_FILE) === ".ts" ? ".ts" : ".
 const DEFAULT_WAIT_TIMEOUT_MS = 15_000;
 const DEFAULT_ADAPTER = "codex";
 function log(adapter, message) {
-    process.stderr.write(`[wechat-${adapter}-start] ${message}\n`);
+    process.stderr.write(`[wechat-${adapter}] ${message}\n`);
 }
 export function normalizeComparablePath(cwd) {
     const normalized = path.resolve(cwd);
@@ -61,7 +61,8 @@ export function decideLaunchAction(input) {
     if (input.sessionStartMode === "new" &&
         (input.requestedAdapter === "claude" ||
             input.requestedAdapter === "opencode" ||
-            input.requestedAdapter === "pi")) {
+            input.requestedAdapter === "pi" ||
+            input.requestedAdapter === "codex")) {
         return {
             kind: "start_bridge",
             message: `Starting a fresh ${input.requestedAdapter} session for ${input.requestedCwd}...`,
@@ -106,22 +107,36 @@ export function parseCliArgs(argv) {
         }
         const next = argv[i + 1];
         if (arg === "--help" || arg === "-h") {
+            const helpAdapter = adapter;
+            const commandName = `wechat-${helpAdapter}`;
+            const adapterLabel = {
+                codex: "Codex",
+                claude: "Claude Code",
+                opencode: "OpenCode",
+                pi: "Pi",
+            }[helpAdapter];
             process.stdout.write([
-                "Usage: wechat-codex-start [--cwd <path>] [--profile <name-or-path>] [--timeout-ms <ms>] [...codex args]",
-                "       wechat-claude-start [--cwd <path>] [--profile <name-or-path>] [--timeout-ms <ms>] [...claude args]",
-                "       wechat-opencode-start [--cwd <path>] [--profile <name-or-path>] [--timeout-ms <ms>] [...opencode args]",
-                "       wechat-pi-start [--cwd <path>] [--profile <name-or-path>] [--timeout-ms <ms>] [...pi args]",
-                "       local-companion-start [--adapter <codex|claude|opencode|pi>] [--cwd <path>] [--profile <name-or-path>] [--timeout-ms <ms>] [...cli args]",
+                `Usage: ${commandName} [--cwd <path>] [--profile <name-or-path>] [--timeout-ms <ms>] [--session-start-mode <restore|new>] [...${helpAdapter} args]`,
                 "",
-                "Starts a bridge for the current directory, waits for the local endpoint, then opens the visible companion or panel.",
-                "Claude, OpenCode, and Pi launchers start a fresh CLI session by default.",
-                "Use --session-start-mode restore to explicitly restore the previous session.",
-                "All adapters are companion-bound: closing the companion/panel also stops the bridge.",
+                "Ensures the WeChat runtime for the current directory, then opens or reuses the visible CLI.",
+                "If a same-workspace daemon is running, the command delegates to that daemon.",
+                helpAdapter === "codex"
+                    ? "Codex restores the current session by default."
+                    : `${adapterLabel} starts a fresh session by default.`,
+                helpAdapter === "codex"
+                    ? "Use --session-start-mode new to explicitly start a fresh session."
+                    : "Use --session-start-mode restore to explicitly restore the previous session.",
+                "Use --doctor to check the selected adapter and workspace without starting it.",
+                "Without a daemon, the transient runtime is companion-bound and stops when the visible CLI closes.",
                 "Unknown arguments are forwarded to the visible CLI client.",
+                `Deprecated alias: ${commandName}-start.`,
                 "",
             ].join("\n"));
             process.exit(0);
         }
+        if (arg === "--doctor") {
+            continue;
+        }
         if (arg === "--adapter") {
             if (!next || !["codex", "claude", "opencode", "pi"].includes(next)) {
                 throw new Error(`Invalid adapter: ${next ?? "(missing)"}`);
@@ -375,6 +390,12 @@ async function ensureBridgeReady(options) {
     await waitForEndpoint(options.cwd, options.adapter, options.timeoutMs);
     return { shouldOpenVisibleClient: true };
 }
+// The daemon's ensure_slot can legitimately take a while: opening a visible
+// client waits up to 15s for it to connect, and codex waits another 15s for
+// the visible thread — all serialized per adapter. The default 2s IPC timeout
+// would expire on nearly every cold start, so delegation uses a generous
+// deadline and falls back to a local bridge when the daemon cannot deliver.
+const ENSURE_SLOT_DELEGATION_TIMEOUT_MS = 45_000;
 export async function tryDelegateToDaemon(options, deps = {}) {
     const readEndpoint = deps.readEndpoint ?? readDaemonEndpoint;
     const isEndpointAlive = deps.isEndpointAlive ?? isDaemonEndpointAlive;
@@ -400,9 +421,14 @@ export async function tryDelegateToDaemon(options, deps = {}) {
         openVisible: true,
         sessionStartMode: options.sessionStartMode,
         reuseExistingVisible: options.adapter !== "pi" || options.sessionStartMode !== "new",
-    });
+    }, { timeoutMs: ENSURE_SLOT_DELEGATION_TIMEOUT_MS });
     if (!response.ok) {
-        throw new Error(response.error);
+        // A daemon that cannot answer in time (or at all) must not abort the
+        // launch: fall back to a local companion-bound bridge so the user still
+        // gets a working terminal instead of an error for work the daemon may
+        // still complete.
+        log(options.adapter, `Daemon delegation failed (${response.error ?? "unknown error"}). Falling back to a local bridge.`);
+        return false;
     }
     log(options.adapter, `Delegated to running wechat-daemon for ${options.cwd}.`);
     return true;
@@ -414,6 +440,7 @@ export async function runVisibleClient(options, runners = {}) {
         return await (runners.codexRemoteClient ?? runCodexRemoteClient)({
             cwd: options.cwd,
             cliArgs: options.cliArgs,
+            sessionStartMode: options.sessionStartMode,
         });
     }
     return await (runners.localCompanion ?? runLocalCompanion)({
@@ -431,6 +458,11 @@ export async function ensureCompanionStartWechatCredentials(adapter, ensureCrede
     });
 }
 export async function runLocalCompanionStart(argv = process.argv.slice(2)) {
+    if (argv.includes("--doctor")) {
+        const { runDoctorCheck } = await import("../utils/doctor.js");
+        await runDoctorCheck(argv, { mode: "bridge" });
+        return 0;
+    }
     const options = parseCliArgs(argv);
     await ensureCompanionStartWechatCredentials(options.adapter);
     if (await tryDelegateToDaemon(options)) {

package/dist/companion/local-companion.js

@@ -23,9 +23,9 @@ function parseCliArgs(argv) {
         const next = argv[i + 1];
         if (arg === "--help" || arg === "-h") {
             process.stdout.write([
-                "Usage: local-companion --adapter <codex|claude|opencode|pi> [--cwd <path>] [...cli args]",
+                "Internal companion usage: local-companion --adapter <codex|claude|opencode|pi> [--cwd <path>] [...cli args]",
                 "",
-                'Starts the visible local companion and connects it to the matching running bridge for the current directory.',
+                "Connects a visible local CLI to the matching bridge runtime for the current directory.",
                 "Unknown arguments are forwarded to the visible CLI client.",
                 "",
             ].join("\n"));
@@ -73,7 +73,7 @@ function readMatchingEndpoint(options) {
         adapter: options.adapter,
     });
     if (!endpoint || endpoint.kind !== options.adapter) {
-        throw new Error(`No active ${options.adapter} bridge endpoint was found for ${options.cwd}. Start "wechat-bridge-${options.adapter}" in that directory first.`);
+        throw new Error(`No active ${options.adapter} runtime was found for ${options.cwd}. Run "wechat-${options.adapter}" in that directory to recreate it.`);
     }
     return endpoint;
 }
@@ -241,6 +241,9 @@ export async function runLocalCompanion(options) {
                 case "resolve_approval":
                     sendResponse(socket, message.id, true, await adapter.resolveApproval(message.payload.action));
                     break;
+                case "submit_user_input":
+                    sendResponse(socket, message.id, true, await adapter.submitUserInput(message.payload.answers));
+                    break;
                 case "dispose":
                     sendResponse(socket, message.id, true);
                     await closeCompanion(0, "bridge_dispose");

package/dist/daemon/daemon-link.js

@@ -65,8 +65,12 @@ export function isPidAlive(pid) {
         process.kill(pid, 0);
         return true;
     }
-    catch {
-        return false;
+    catch (error) {
+        // EPERM means the OS found the pid but denied access (e.g. a Windows
+        // process running under another privilege level). The process exists, so
+        // it must be treated as alive — returning false here would let callers
+        // delete a live daemon's endpoint file and break its singleton.
+        return error instanceof Error && error.code === "EPERM";
     }
 }
 export function sendDaemonResponse(socket, id, response) {
@@ -170,6 +174,11 @@ export async function sendDaemonRequest(endpoint, payload, options = {}) {
         socket.once("error", () => {
             finish({ ok: false, error: "Daemon endpoint is not reachable." });
         });
+        socket.once("close", () => {
+            // The daemon may die or be taken over mid-request; without this the
+            // caller waits out the full timeout for a socket that is already gone.
+            finish({ ok: false, error: "Daemon connection closed before a response." });
+        });
     });
 }
 export async function isDaemonEndpointAlive(endpoint, options = {}) {
@@ -177,5 +186,18 @@ export async function isDaemonEndpointAlive(endpoint, options = {}) {
         return false;
     }
     const response = await sendDaemonRequest(endpoint, { command: "status" }, options);
-    return response.ok;
+    if (response.ok) {
+        return true;
+    }
+    // A momentarily busy daemon (e.g. a synchronous session-directory scan
+    // blocking its event loop) can miss the short status deadline. Retry once
+    // before declaring it dead: a false negative makes callers delete a live
+    // daemon's endpoint file and break its singleton.
+    const timedOut = (response.error ?? "").includes("Timed out");
+    if (!timedOut) {
+        return false;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 250));
+    const retry = await sendDaemonRequest(endpoint, { command: "status" }, options);
+    return retry.ok;
 }

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;
@@ -52,9 +51,6 @@ 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" || value === "pi";
 }
@@ -155,12 +151,16 @@ export function defaultDaemonSessionStartMode(adapter) {
     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";
     }
@@ -483,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;
@@ -638,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");
                 }
             }
@@ -657,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()) {
@@ -721,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;
@@ -765,7 +804,8 @@ class WechatDaemon {
             reuseExistingVisible: options.reuseExistingVisible !== false,
         });
         if (!created &&
-            options.reuseExistingVisible === false &&
+            (options.reuseExistingVisible === false ||
+                options.sessionStartMode === "new") &&
             sessionStartMode === "new" &&
             (adapter === "claude" || adapter === "opencode" || adapter === "pi") &&
             visibleConnected) {
@@ -952,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 })) {
@@ -1015,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");
                 }));
@@ -1120,6 +1166,15 @@ class WechatDaemon {
         }
         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;
@@ -1151,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.`);
@@ -1231,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) {
@@ -1260,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;
@@ -1658,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.",
@@ -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",

package/dist/i18n/messages-zh.js

@@ -1,6 +1,6 @@
 export const messages = {
     // === 桥接欢迎 & 控制 ===
-    "bridge.welcome": "微信桥接就绪 ({adapter})。\n工作目录: {cwd}\n\n命令: /stop, /confirm, /deny, /status, /new\n{bindings}\n\n管理: /bind [表情] 命令, /unbind [表情], /bindings",
+    "bridge.welcome": "微信桥接就绪 ({adapter})。\n工作目录: {cwd}",
     "bridge.stopped": "桥接已停止。",
     "bridge.interrupt.sent": "已发送中断信号。",
     "bridge.interrupt.notBusy": "没有正在执行的任务可中断。",
@@ -66,7 +66,6 @@ export const messages = {
     "doctor.clock.ok": "与服务器时间偏差约 {skewSeconds}s",
     "doctor.clock.skewWarning": "与服务器时间偏差约 {skewSeconds}s（偏差过大会导致桥接启动后的消息被当作积压忽略，请校准系统时间）",
     "doctor.label.nodePty": "node-pty",
-    "doctor.label.shell": "shell",
     "doctor.label.dataDir": "数据目录",
     "doctor.label.credentials": "凭据",
     "doctor.label.mode": "模式",
@@ -79,7 +78,6 @@ export const messages = {
     "doctor.winBuildConpty": "(ConPTY 需要 build 18309+)",
     "doctor.nodePty.loaded": "已加载",
     "doctor.nodePty.fix": "修复: {fix}",
-    "doctor.adapterCli.shellNative": "使用本机 shell，无需检查其它适配器 CLI。",
     "doctor.adapterCli.notFound": "未找到{optional}",
     "doctor.dataDirMissing": "(首次运行会创建)",
     "doctor.credentialsFound": "已找到",
@@ -88,6 +86,7 @@ export const messages = {
     "doctor.mode.generic": "通用",
     "doctor.notSpecified": "(未指定)",
     "doctor.none": "无",
+    "doctor.endpoint.corrupted": "endpoint 文件存在但无法解析；下次成功写入时将被替换",
     "doctor.unknown": "未知",
     "doctor.yes": "是",
     "doctor.no": "否",

package/dist/utils/atomic-file.js

@@ -0,0 +1,15 @@
+import fs from "node:fs";
+import { ensureChannelDataDir } from "../wechat/channel-config.js";
+/**
+ * Write JSON atomically via temp file + rename, so a crash mid-write cannot
+ * leave a truncated or half-written file behind. Cross-process readers (the
+ * daemon, launchers, companions) either see the previous complete file or the
+ * new complete file — never a torn write.
+ */
+export function writeJsonFileAtomic(filePath, value) {
+    ensureChannelDataDir();
+    const data = JSON.stringify(value, null, 2);
+    const tempPath = `${filePath}.${process.pid}.tmp`;
+    fs.writeFileSync(tempPath, data, "utf-8");
+    fs.renameSync(tempPath, filePath);
+}