cli-wechat-bridge 1.1.3 → 1.1.5

package/dist/bridge/wechat-bridge.js

@@ -5,9 +5,11 @@ import { delay } from "./bridge-adapters.shared.js";
 import { t } from "../i18n/index.js";
 import { BridgeController } from "./bridge-controller.js";
 import { forwardWechatFinalReply } from "./bridge-final-reply.js";
+import { ResumeSessionCoordinator, isWechatResumeEnabled, shouldForwardSessionSwitchEvent, } from "./bridge-session-resume.js";
+import { WECHAT_SEND_MAX_ATTEMPTS, computeWechatSendRetryDelayMs, formatUserFacingBridgeFatalError, formatUserFacingInboundError, formatWechatContextTokenStaleLogEntry, formatWechatSendFailureLogEntry, formatWechatSendRetryLogEntry, isRetryableWechatSendError, shouldForwardBridgeEventToWechat, } from "./wechat-forwarding.js";
 import { ensureWechatCredentials } from "../wechat/setup.js";
 import { BridgeStateStore } from "./bridge-state.js";
-import { reapOrphanedOpencodeProcesses, reapPeerBridgeProcesses } from "./bridge-process-reaper.js";
+import { getProcessRecordByPid, reapOrphanedOpencodeProcesses, reapPeerBridgeProcesses, } from "./bridge-process-reaper.js";
 import { createRuntimeHost } from "../runtime/create-runtime-host.js";
 import { buildWechatInboundPrompt, buildOneTimeCode, formatApprovalMessage, formatPendingApprovalReminder, formatPendingUserInputReminder, formatDuration, formatMirroredUserInputMessage, formatSessionSwitchMessage, formatStatusReport, formatTaskFailedMessage, formatThinkingForWechat, formatUserInputRequestMessage, MESSAGE_START_GRACE_MS, nowIso, OutputBatcher, parsePendingUserInputAnswerCommand, parseWechatControlCommand, truncatePreview, } from "./bridge-utils.js";
 import { classifyWechatTransportError, DEFAULT_LONG_POLL_TIMEOUT_MS, WeChatTransport, describeWechatTransportError, isWechatContextTokenStaleError, } from "../wechat/wechat-transport.js";
@@ -17,8 +19,11 @@ import { formatBindCommandUsage, formatBindingsListMessage, isBindCommandPrefix,
 const POLL_RETRY_BASE_MS = 1_000;
 const POLL_RETRY_MAX_MS = 30_000;
 const PARENT_PROCESS_POLL_MS = 5_000;
-const WECHAT_SEND_MAX_ATTEMPTS = 3;
-const WECHAT_SEND_RETRY_BASE_MS = 750;
+// Hard ceiling for the whole shutdown cleanup sequence before a forced exit.
+const SHUTDOWN_FORCE_EXIT_TIMEOUT_MS = 10_000;
+// Re-verify the parent's command line every N polls (5s each → ~60s) to keep
+// the full-process probe off the hot path.
+const PARENT_IDENTITY_CHECK_INTERVAL = 12;
 function log(message) {
     process.stderr.write(`[wechat-bridge] ${message}\n`);
 }
@@ -42,63 +47,6 @@ function isPidAlive(pid) {
         return false;
     }
 }
-export function formatUserFacingBridgeFatalError(message) {
-    return `Bridge error: ${message.replace(/\s+Recent app-server log:.*$/s, "").trim()}`;
-}
-export function shouldForwardBridgeEventToWechat(adapter, eventType, options = {}) {
-    if (adapter !== "opencode" && adapter !== "pi") {
-        return true;
-    }
-    switch (eventType) {
-        case "stdout":
-        case "stderr":
-        case "thread_switched":
-            return false;
-        case "notice":
-            return adapter === "pi" || /^OpenCode local draft:\s*/i.test(options.text ?? "");
-        case "mirrored_user_input":
-            return true;
-        default:
-            return true;
-    }
-}
-export function formatUserFacingInboundError(params) {
-    const { adapter, cwd, errorText, isUserFacingShellRejection } = params;
-    if (isUserFacingShellRejection) {
-        return errorText;
-    }
-    if (adapter === "opencode" &&
-        /opencode companion is not connected/i.test(errorText)) {
-        return cwd
-            ? `OpenCode companion is not connected for bridge workspace:\n${cwd}\nRun "wechat-opencode" in that directory to reconnect the current local terminal, or run "wechat-bridge-opencode" and then "wechat-opencode" in your target project to replace this bridge.`
-            : 'OpenCode companion is not connected. Start "wechat-opencode" in this directory to reconnect it, then retry.';
-    }
-    return `Bridge error: ${errorText}`;
-}
-export function formatWechatSendFailureLogEntry(params) {
-    return `wechat_send_failed: context=${params.context} recipient=${params.recipientId} error=${truncatePreview(describeWechatTransportError(params.error), 400)}`;
-}
-export function formatWechatContextTokenStaleLogEntry(params) {
-    return `wechat_context_token_stale: context=${params.context} recipient=${params.recipientId} action=wechat_message_required error=${truncatePreview(describeWechatTransportError(params.error), 400)}`;
-}
-function formatWechatSendRetryLogEntry(params) {
-    return `wechat_send_retry: context=${params.context} recipient=${params.recipientId} attempt=${params.attempt} delay_ms=${params.delayMs} error=${truncatePreview(describeWechatTransportError(params.error), 400)}`;
-}
-export function isRetryableWechatSendError(error) {
-    if (isWechatContextTokenStaleError(error)) {
-        return false;
-    }
-    const classification = classifyWechatTransportError(error);
-    if (classification.retryable) {
-        return true;
-    }
-    const details = describeWechatTransportError(error);
-    return /^(?:Error|WechatApiResponseError): sendmessage failed:/i.test(details) &&
-        !/errcode=-14\b.*session timeout/i.test(details);
-}
-function computeWechatSendRetryDelayMs(attempt) {
-    return WECHAT_SEND_RETRY_BASE_MS * attempt;
-}
 export function shouldWatchParentProcess(options) {
     return (options.startupParentPid > 1 &&
         (options.attachedToTerminal || options.lifecycle === "companion_bound"));
@@ -159,7 +107,7 @@ export function parseCliArgs(argv) {
         const next = argv[i + 1];
         switch (arg) {
             case "--adapter":
-                if (!next || !["codex", "claude", "opencode", "pi", "shell"].includes(next)) {
+                if (!next || !["codex", "claude", "opencode", "pi"].includes(next)) {
                     throw new Error(`Invalid adapter: ${next ?? "(missing)"}`);
                 }
                 adapter = next;
@@ -212,7 +160,7 @@ export function parseCliArgs(argv) {
         }
     }
     if (!adapter) {
-        throw new Error("Missing required --adapter <codex|claude|opencode|pi|shell>");
+        throw new Error("Missing required --adapter <codex|claude|opencode|pi>");
     }
     const defaultCommand = resolveDefaultAdapterCommand(adapter);
     return {
@@ -226,18 +174,10 @@ export function parseCliArgs(argv) {
 }
 function printUsageAndExit() {
     process.stdout.write([
-        "Usage: wechat-bridge --adapter <codex|claude|opencode|pi|shell> [--cmd <executable>] [--cwd <path>] [--profile <name-or-path>] [--lifecycle <persistent|companion_bound>] [--session-start-mode <restore|new>]",
+        "Internal bridge runtime usage:",
+        "  npm run bridge -- --adapter <codex|claude|opencode|pi> [--cmd <executable>] [--cwd <path>] [--profile <name-or-path>] [--lifecycle <persistent|companion_bound>] [--session-start-mode <restore|new>]",
         "",
-        "Examples:",
-        "  wechat-bridge-codex",
-        "  wechat-bridge-claude --cwd ~/work/my-project",
-        "  wechat-bridge-opencode --cwd ~/work/my-project",
-        "  wechat-bridge-pi --cwd ~/work/my-project",
-        "  wechat-bridge-shell --cmd pwsh   # headless shell executor for non-interactive commands/scripts",
-        "  wechat-bridge-shell --cmd bash   # headless shell executor for non-interactive commands/scripts",
-        "  wechat-bridge-codex --lifecycle companion_bound",
-        "  bun run bridge:codex            # repo-local development entrypoint",
-        "  bun run bridge:opencode          # repo-local development entrypoint",
+        "This entry is internal. Users should run wechat-codex, wechat-claude, wechat-opencode, wechat-pi, or wechat-daemon.",
         "",
     ].join("\n"));
     process.exit(0);
@@ -330,6 +270,10 @@ async function main() {
         initialResumeConversationId: stateStore.getState().resumeConversationId,
         initialTranscriptPath: stateStore.getState().transcriptPath,
     });
+    const resumeCoordinator = new ResumeSessionCoordinator({
+        adapter: options.adapter,
+        runtime: adapter,
+    });
     const controller = new BridgeController(adapter, options.cwd);
     controller.clearLocalClientEndpoint();
     stateStore.appendLog(`Cleared stale companion endpoint for ${options.cwd} before adapter start.`);
@@ -339,8 +283,6 @@ async function main() {
     let activeTask = null;
     const deferredInboundMessages = [];
     let drainingDeferredInboundMessages = false;
-    let lastOutputAt = 0;
-    let lastHeartbeatAt = 0;
     let consecutivePollFailures = 0;
     let backlogNoticeSent = false;
     const queueWechatTextAction = (action) => {
@@ -447,7 +389,6 @@ async function main() {
                 adapter,
             });
             activeTask = nextTask;
-            lastHeartbeatAt = 0;
         }
         catch (err) {
             const errorText = err instanceof Error ? err.message : String(err);
@@ -462,7 +403,6 @@ async function main() {
                 adapter: options.adapter,
                 cwd: options.cwd,
                 errorText,
-                isUserFacingShellRejection: false,
             }), "inbound_error");
         }
         finally {
@@ -474,6 +414,10 @@ async function main() {
     let shutdownPromise = null;
     let requestedExitCode = 0;
     let stdinDetached = false;
+    // Snapshot of the parent process command line at bridge startup (null when
+    // unresolvable). Compared against periodic re-probes to detect OS pid reuse.
+    const parentStartupCommandLine = getProcessRecordByPid(startupParentPid)?.commandLine ?? null;
+    let parentWatchPollCount = 0;
     const parentWatchTimer = shouldWatchParentProcess({
         startupParentPid,
         attachedToTerminal,
@@ -481,6 +425,19 @@ async function main() {
     })
         ? setInterval(() => {
             if (shutdownPromise || isPidAlive(startupParentPid)) {
+                // Periodically re-verify the parent's command line so an OS pid
+                // reuse (dead parent's pid handed to an unrelated long-running
+                // process) cannot keep this companion-bound bridge alive forever.
+                parentWatchPollCount += 1;
+                if (parentWatchPollCount % PARENT_IDENTITY_CHECK_INTERVAL === 0) {
+                    const record = getProcessRecordByPid(startupParentPid);
+                    if (parentStartupCommandLine !== null &&
+                        record !== null &&
+                        record.commandLine !== parentStartupCommandLine) {
+                        log(`Parent pid ${startupParentPid} was reused by another process. Stopping bridge.`);
+                        void shutdown(0);
+                    }
+                }
                 return;
             }
             log(`Parent process ${startupParentPid} exited. Stopping bridge.`);
@@ -530,7 +487,17 @@ async function main() {
             return;
         }
         log(message);
-        void shutdown(exitCode).finally(() => process.exit(requestedExitCode));
+        // Bound the whole cleanup: a dispose that hangs (child process refusing
+        // to exit) would otherwise keep the process alive indefinitely after the
+        // one-shot signal handlers are consumed.
+        const forceExitTimer = setTimeout(() => {
+            logError(`Shutdown cleanup exceeded ${formatDuration(SHUTDOWN_FORCE_EXIT_TIMEOUT_MS)}; forcing exit.`);
+            process.exit(requestedExitCode);
+        }, SHUTDOWN_FORCE_EXIT_TIMEOUT_MS);
+        void shutdown(exitCode).finally(() => {
+            clearTimeout(forceExitTimer);
+            process.exit(requestedExitCode);
+        });
     };
     process.once("SIGINT", () => {
         requestShutdown("Received SIGINT. Stopping bridge.");
@@ -571,6 +538,7 @@ async function main() {
     try {
         wireAdapterEvents({
             adapter,
+            resumeCoordinator,
             options,
             transport,
             stateStore,
@@ -579,13 +547,8 @@ async function main() {
             queueWechatMessage,
             trackWechatForwardTask,
             maybeDrainDeferredInboundMessages,
-            getActiveTask: () => activeTask,
             clearActiveTask: () => {
                 activeTask = null;
-                lastHeartbeatAt = 0;
-            },
-            updateLastOutputAt: () => {
-                lastOutputAt = Date.now();
             },
             syncSharedSessionState: () => {
                 syncSharedSessionState(stateStore, adapter);
@@ -609,25 +572,33 @@ async function main() {
         }
         log(`Authorized WeChat user: ${credentials.userId}`);
         if (options.adapter === "codex") {
-            log('Start the visible Codex panel in a second terminal with: wechat-codex');
+            log("For source-mode debugging, open the visible Codex client with: npm run codex:panel");
         }
         else if (options.adapter === "opencode") {
-            log('Start the visible OpenCode companion in a second terminal with: wechat-opencode');
+            log("For source-mode debugging, open the visible OpenCode client with: npm run opencode:panel");
         }
         else if (options.adapter === "claude") {
-            log('Start the visible Claude companion in a second terminal with: wechat-claude');
+            log("For source-mode debugging, open the visible Claude client with: npm run claude:companion");
         }
-        else if (options.adapter === "shell") {
-            log("Shell mode runs as a headless remote executor for non-interactive commands and scripts.");
+        else if (options.adapter === "pi") {
+            log("For source-mode debugging, open the visible Pi client with: npm run pi:companion");
         }
         loadEmojiBindings();
+        // Keep the standalone bridge's WeChat welcome brief: command and emoji
+        // reference material belongs to /status and /bindings, which users can
+        // request on demand. The daemon sends its own, fuller welcome.
         const welcomeText = t("bridge.welcome", {
             adapter: options.adapter,
             cwd: options.cwd,
-            bindings: formatBindingsListMessage(listBindings()),
         });
         await queueWechatMessage(credentials.userId, welcomeText);
         while (true) {
+            if (shutdownPromise) {
+                // Shutdown (e.g. SIGINT) was requested while we were awaiting the
+                // previous poll: stop consuming inbound messages instead of racing
+                // the concurrent cleanup/dispose with new sends.
+                break;
+            }
             if (!ensureRuntimeOwnership()) {
                 break;
             }
@@ -654,7 +625,7 @@ async function main() {
                 await delay(delayMs);
                 continue;
             }
-            if (!ensureRuntimeOwnership()) {
+            if (shutdownPromise || !ensureRuntimeOwnership()) {
                 break;
             }
             if (consecutivePollFailures > 0) {
@@ -686,8 +657,12 @@ async function main() {
                         options,
                         stateStore,
                         adapter,
+                        resumeCoordinator,
                         queueWechatMessage,
                         outputBatcher,
+                        clearActiveTask: () => {
+                            activeTask = null;
+                        },
                         deferInboundMessage: async (nextMessage) => {
                             deferredInboundMessages.push({
                                 message: nextMessage,
@@ -699,32 +674,20 @@ async function main() {
                 }
                 catch (err) {
                     const errorText = err instanceof Error ? err.message : String(err);
-                    const isUserFacingShellRejection = err instanceof Error && err.name === "ShellCommandRejectedError";
                     logError(errorText);
-                    stateStore.appendLog(`${isUserFacingShellRejection ? "inbound_rejected" : "inbound_error"}: ${errorText}`);
+                    stateStore.appendLog(`inbound_error: ${errorText}`);
                     await queueWechatMessage(message.senderId, formatUserFacingInboundError({
                         adapter: options.adapter,
                         cwd: options.cwd,
                         errorText,
-                        isUserFacingShellRejection,
                     }), "inbound_error");
                 }
                 if (nextTask) {
                     activeTask = nextTask;
-                    lastHeartbeatAt = 0;
                 }
                 syncSharedSessionState(stateStore, adapter);
                 await maybeDrainDeferredInboundMessages();
             }
-            const adapterState = adapter.getState();
-            const lastSignalAt = Math.max(lastHeartbeatAt, lastOutputAt || activeTask?.startedAt || 0);
-            if (activeTask &&
-                options.adapter === "shell" &&
-                adapterState.status === "busy" &&
-                Date.now() - lastSignalAt >= 30_000) {
-                lastHeartbeatAt = Date.now();
-                await queueWechatMessage(stateStore.getState().authorizedUserId, `${options.adapter} is still running. Waiting for more output...`);
-            }
         }
     }
     finally {
@@ -756,7 +719,7 @@ function syncSharedSessionState(stateStore, adapter) {
     }
 }
 function wireAdapterEvents(params) {
-    const { adapter, options, transport, stateStore, outputBatcher, queueWechatAttachmentAction, queueWechatMessage, trackWechatForwardTask, maybeDrainDeferredInboundMessages, getActiveTask, clearActiveTask, updateLastOutputAt, syncSharedSessionState, syncLocalClientEndpoint, requestShutdown, } = params;
+    const { adapter, resumeCoordinator, options, transport, stateStore, outputBatcher, queueWechatAttachmentAction, queueWechatMessage, trackWechatForwardTask, maybeDrainDeferredInboundMessages, clearActiveTask, syncSharedSessionState, syncLocalClientEndpoint, requestShutdown, } = params;
     adapter.setEventSink((event) => {
         syncSharedSessionState();
         syncLocalClientEndpoint();
@@ -772,7 +735,6 @@ function wireAdapterEvents(params) {
         switch (event.type) {
             case "stdout":
             case "stderr":
-                updateLastOutputAt();
                 if (shouldForwardBridgeEventToWechat(options.adapter, event.type)) {
                     outputBatcher.push(event.text);
                 }
@@ -810,7 +772,6 @@ function wireAdapterEvents(params) {
                 void maybeDrainDeferredInboundMessages();
                 break;
             case "notice":
-                updateLastOutputAt();
                 stateStore.appendLog(`${event.level}_notice: ${truncatePreview(event.text)}`);
                 if (shouldForwardBridgeEventToWechat(options.adapter, event.type, { text: event.text })) {
                     trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
@@ -819,7 +780,6 @@ function wireAdapterEvents(params) {
                 }
                 break;
             case "thinking":
-                updateLastOutputAt();
                 if (event.text) {
                     const thinkingPreview = formatThinkingForWechat(event.text, 500);
                     if (thinkingPreview) {
@@ -855,8 +815,12 @@ function wireAdapterEvents(params) {
                 }
                 break;
             case "session_switched":
+                if (event.source === "local") {
+                    resumeCoordinator.clear();
+                }
                 stateStore.appendLog(`session_switched: ${event.sessionId} source=${event.source} reason=${event.reason}`);
-                if (shouldForwardBridgeEventToWechat(options.adapter, event.type)) {
+                if (shouldForwardSessionSwitchEvent(event.reason) &&
+                    shouldForwardBridgeEventToWechat(options.adapter, event.type)) {
                     trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                         await queueWechatMessage(authorizedUserId, formatSessionSwitchMessage({
                             adapter: options.adapter,
@@ -868,8 +832,12 @@ function wireAdapterEvents(params) {
                 }
                 break;
             case "thread_switched":
+                if (event.source === "local") {
+                    resumeCoordinator.clear();
+                }
                 stateStore.appendLog(`thread_switched: ${event.threadId} source=${event.source} reason=${event.reason}`);
-                if (shouldForwardBridgeEventToWechat(options.adapter, event.type)) {
+                if (shouldForwardSessionSwitchEvent(event.reason) &&
+                    shouldForwardBridgeEventToWechat(options.adapter, event.type)) {
                     trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                         await queueWechatMessage(authorizedUserId, formatSessionSwitchMessage({
                             adapter: options.adapter,
@@ -885,15 +853,6 @@ function wireAdapterEvents(params) {
                 trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                     stateStore.clearPendingConfirmation();
                     stateStore.clearPendingUserInput();
-                    if (options.adapter === "shell") {
-                        const summary = buildCompletionSummary({
-                            adapter: options.adapter,
-                            activeTask: getActiveTask(),
-                            exitCode: event.exitCode,
-                            recentOutput: outputBatcher.getRecentSummary(),
-                        });
-                        await queueWechatMessage(authorizedUserId, summary);
-                    }
                     clearActiveTask();
                     await maybeDrainDeferredInboundMessages();
                 }));
@@ -925,18 +884,6 @@ function wireAdapterEvents(params) {
         }
     });
 }
-function buildCompletionSummary(params) {
-    const lines = [`${params.adapter} task complete.`];
-    if (params.activeTask) {
-        lines.push(`duration: ${formatDuration(Date.now() - params.activeTask.startedAt)}`);
-        lines.push(`input: ${params.activeTask.inputPreview}`);
-    }
-    if (typeof params.exitCode === "number") {
-        lines.push(`exit_code: ${params.exitCode}`);
-    }
-    lines.push(`recent_output:\n${params.recentOutput}`);
-    return lines.join("\n");
-}
 function formatInboundMessagePreview(message) {
     if (message.text.trim()) {
         return message.text;
@@ -950,7 +897,7 @@ function formatInboundMessagePreview(message) {
 }
 async function handleInboundMessage(params) {
     let { message, } = params;
-    const { options, stateStore, adapter, queueWechatMessage, outputBatcher, deferInboundMessage, } = params;
+    const { options, stateStore, adapter, resumeCoordinator, queueWechatMessage, outputBatcher, clearActiveTask, deferInboundMessage, } = params;
     const state = stateStore.getState();
     if (message.senderId !== state.authorizedUserId) {
         await queueWechatMessage(message.senderId, "Unauthorized. This bridge only accepts messages from the configured WeChat owner.");
@@ -997,19 +944,23 @@ async function handleInboundMessage(params) {
             await queueWechatMessage(message.senderId, formatStatusReport(stateStore.getState(), adapter.getState()));
             return null;
         case "resume": {
-            if (options.adapter === "codex") {
-                await queueWechatMessage(message.senderId, 'WeChat /resume is disabled in codex mode. Use /resume directly inside "wechat-codex"; WeChat will follow the active local thread.');
+            if (!isWechatResumeEnabled(options.adapter)) {
+                await queueWechatMessage(message.senderId, `WeChat /resume is disabled in ${options.adapter} mode. Use /resume directly inside "wechat-${options.adapter}"; WeChat will follow the active local session.`);
                 return null;
             }
-            if (options.adapter === "claude") {
-                await queueWechatMessage(message.senderId, 'WeChat /resume is disabled in claude mode. Use /resume directly inside "wechat-claude"; WeChat will follow the active local session.');
-                return null;
+            try {
+                if (systemCommand.target) {
+                    await outputBatcher.flushNow();
+                }
+                const result = await resumeCoordinator.execute(systemCommand.target);
+                if (result.kind === "resumed") {
+                    clearActiveTask();
+                }
+                await queueWechatMessage(message.senderId, result.message);
             }
-            if (options.adapter === "opencode") {
-                await queueWechatMessage(message.senderId, 'WeChat /resume is disabled in opencode mode. Use /resume directly inside "wechat-opencode"; WeChat will follow the active local session.');
-                return null;
+            catch (error) {
+                await queueWechatMessage(message.senderId, error instanceof Error ? error.message : String(error));
             }
-            await queueWechatMessage(message.senderId, `/resume is not available in ${options.adapter} mode.`);
             return null;
         }
         case "new_session": {
@@ -1022,6 +973,7 @@ async function handleInboundMessage(params) {
             stateStore.clearPendingConfirmation();
             stateStore.clearPendingUserInput();
             stateStore.clearSharedSessionId();
+            resumeCoordinator.clear();
             await adapter.createSession();
             stateStore.appendLog(`New ${options.adapter} session requested by owner.`);
             return null;
@@ -1039,6 +991,7 @@ async function handleInboundMessage(params) {
             stateStore.clearPendingConfirmation();
             stateStore.clearPendingUserInput();
             stateStore.clearSharedSessionId();
+            resumeCoordinator.clear();
             await adapter.reset();
             stateStore.appendLog("Worker reset by owner.");
             await queueWechatMessage(message.senderId, "Worker session has been reset.");

package/dist/bridge/wechat-forwarding.js

@@ -0,0 +1,58 @@
+import { truncatePreview } from "./bridge-utils.js";
+import { classifyWechatTransportError, describeWechatTransportError, isWechatContextTokenStaleError, } from "../wechat/wechat-transport.js";
+export const WECHAT_SEND_MAX_ATTEMPTS = 3;
+const WECHAT_SEND_RETRY_BASE_MS = 750;
+export function formatUserFacingBridgeFatalError(message) {
+    return `Bridge error: ${message.replace(/\s+Recent app-server log:.*$/s, "").trim()}`;
+}
+export function shouldForwardBridgeEventToWechat(adapter, eventType, options = {}) {
+    if (adapter !== "opencode" && adapter !== "pi") {
+        return true;
+    }
+    switch (eventType) {
+        case "stdout":
+        case "stderr":
+        case "thread_switched":
+            return false;
+        case "notice":
+            return adapter === "pi" || /^OpenCode local draft:\s*/i.test(options.text ?? "");
+        case "mirrored_user_input":
+            return true;
+        default:
+            return true;
+    }
+}
+export function formatUserFacingInboundError(params) {
+    const { adapter, cwd, errorText } = params;
+    if (adapter === "opencode" &&
+        /opencode companion is not connected/i.test(errorText)) {
+        return cwd
+            ? `OpenCode is not connected for workspace:\n${cwd}\nRun "wechat-opencode" in that directory to recreate or reconnect the visible terminal.`
+            : 'OpenCode is not connected. Run "wechat-opencode" in this directory, then retry.';
+    }
+    return `Bridge error: ${errorText}`;
+}
+export function formatWechatSendFailureLogEntry(params) {
+    return `wechat_send_failed: context=${params.context} recipient=${params.recipientId} error=${truncatePreview(describeWechatTransportError(params.error), 400)}`;
+}
+export function formatWechatContextTokenStaleLogEntry(params) {
+    return `wechat_context_token_stale: context=${params.context} recipient=${params.recipientId} action=wechat_message_required error=${truncatePreview(describeWechatTransportError(params.error), 400)}`;
+}
+export function formatWechatSendRetryLogEntry(params) {
+    return `wechat_send_retry: context=${params.context} recipient=${params.recipientId} attempt=${params.attempt} delay_ms=${params.delayMs} error=${truncatePreview(describeWechatTransportError(params.error), 400)}`;
+}
+export function isRetryableWechatSendError(error) {
+    if (isWechatContextTokenStaleError(error)) {
+        return false;
+    }
+    const classification = classifyWechatTransportError(error);
+    if (classification.retryable) {
+        return true;
+    }
+    const details = describeWechatTransportError(error);
+    return /^(?:Error|WechatApiResponseError): sendmessage failed:/i.test(details) &&
+        !/errcode=-14\b.*session timeout/i.test(details);
+}
+export function computeWechatSendRetryDelayMs(attempt) {
+    return WECHAT_SEND_RETRY_BASE_MS * attempt;
+}