@unlinearity/cli-wechat-bridge 1.2.1 → 1.2.3

package/dist/bridge/wechat-bridge.js

@@ -22,14 +22,21 @@ import { canDrainDeferredCodexInboundQueue, formatDeferredCodexInboundQueueMessa
 import { TurnCoordinator } from "../core/turn-coordinator.js";
 import { resolveOutboundConversationTarget } from "../core/outbound-target.js";
 import { handleAdapterControl } from "./adapter-control.js";
+import { handleLanguageControl } from "./language-control.js";
+import { LANGUAGE_FILE } from "../wechat/channel-config.js";
 import { forwardBridgeEvent } from "../core/bridge-event-forwarder.js";
 import { isDirectModuleRun } from "../core/direct-run.js";
 import { WechatChannelPort } from "../channels/wechat/wechat-channel-port.js";
 import { ensureWecomAccount } from "../channels/wecom/setup.js";
+import { ensureTelegramAccount } from "../channels/telegram/setup.js";
+import { TelegramTransport } from "../channels/telegram/telegram-transport.js";
+import { TelegramChannelDriver } from "../channels/telegram/telegram-driver.js";
+import { TelegramChannelPort } from "../channels/telegram/telegram-channel-port.js";
 import { WecomChannelPort } from "../channels/wecom/wecom-channel-port.js";
 import { WecomTransport } from "../channels/wecom/wecom-transport.js";
 import { WecomChannelDriver } from "../channels/wecom/wecom-driver.js";
 import { WechatChannelDriver } from "../channels/wechat/wechat-driver.js";
+import { isBridgeChannelId } from "../core/channel-types.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, } from "../wechat/wechat-transport.js";
 import { getPendingChannelMessagesFile, getPendingWechatMessagesFile, PendingWechatMessageStore, } from "../channels/wechat/wechat-outbound-queue.js";
@@ -98,6 +105,8 @@ export function parseCliArgs(argv) {
     let lifecycle = "persistent";
     let sessionStartMode = "restore";
     let channelId = "wechat";
+    let codexAttachDaemon = false;
+    let codexAttachThreadId;
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
         const next = argv[i + 1];
@@ -145,7 +154,7 @@ export function parseCliArgs(argv) {
                 i += 1;
                 break;
             case "--channel":
-                if (!next || (next !== "wechat" && next !== "wecom")) {
+                if (!isBridgeChannelId(next) || next === "local") {
                     throw new Error(`Invalid channel: ${next ?? "(missing)"}`);
                 }
                 channelId = next;
@@ -154,6 +163,16 @@ export function parseCliArgs(argv) {
             case "--shutdown-on-parent-exit":
                 lifecycle = "companion_bound";
                 break;
+            case "--codex-attach-daemon":
+                codexAttachDaemon = true;
+                break;
+            case "--codex-thread-id":
+                if (!next) {
+                    throw new Error("--codex-thread-id requires a value");
+                }
+                codexAttachThreadId = next;
+                i += 1;
+                break;
             case "--help":
             case "-h":
                 printUsageAndExit();
@@ -165,6 +184,9 @@ export function parseCliArgs(argv) {
     if (!adapter) {
         throw new Error("Missing required --adapter <codex|claude|opencode|pi>");
     }
+    if (codexAttachDaemon && adapter !== "codex") {
+        throw new Error("--codex-attach-daemon requires --adapter codex");
+    }
     const defaultCommand = resolveDefaultAdapterCommand(adapter);
     return {
         adapter,
@@ -174,6 +196,8 @@ export function parseCliArgs(argv) {
         lifecycle,
         sessionStartMode,
         channelId,
+        codexAttachDaemon,
+        codexAttachThreadId,
     };
 }
 function toWechatSendContext(kind) {
@@ -205,7 +229,7 @@ function toLegacyInboundWechatMessage(message) {
 function printUsageAndExit() {
     process.stdout.write([
         "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>]",
+        "  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>] [--codex-attach-daemon [--codex-thread-id <id>]]",
         "",
         "This entry is internal. Users should run a wechat-* or wecom-* launcher.",
         "",
@@ -230,17 +254,24 @@ async function main() {
     const wecomAccount = options.channelId === "wecom"
         ? await ensureWecomAccount({ log })
         : null;
+    const telegramAccount = options.channelId === "telegram"
+        ? await ensureTelegramAccount({ log })
+        : null;
     const credentials = wecomAccount
         ? { userId: wecomAccount.operatorUserId }
-        : await ensureWechatCredentials({
-            requireUserId: true,
-            validateExisting: true,
-            log,
-        });
+        : telegramAccount
+            ? { userId: telegramAccount.operatorUserId }
+            : await ensureWechatCredentials({
+                requireUserId: true,
+                validateExisting: true,
+                log,
+            });
     if (!credentials.userId) {
         throw new Error(options.channelId === "wecom"
             ? "Saved WeCom credentials are missing operatorUserId."
-            : "Saved WeChat credentials are missing userId.");
+            : options.channelId === "telegram"
+                ? "Saved Telegram credentials are missing operatorUserId."
+                : "Saved WeChat credentials are missing userId.");
     }
     const transport = new WeChatTransport({ log, logError });
     const wecomTransport = wecomAccount
@@ -252,6 +283,15 @@ async function main() {
             },
         })
         : null;
+    const telegramTransport = telegramAccount
+        ? new TelegramTransport({
+            account: telegramAccount,
+            logger: {
+                log: (message) => log(message),
+                error: (message) => logError(message),
+            },
+        })
+        : null;
     const channelDriver = wecomTransport
         ? new WecomChannelDriver({
             transport: wecomTransport,
@@ -259,11 +299,18 @@ async function main() {
             operatorId: credentials.userId,
             logError,
         })
-        : new WechatChannelDriver({
-            transport,
-            logError,
-            buildInboundPrompt: (text, attachments) => buildWechatInboundPrompt(text, attachments.filter((attachment) => attachment.kind === "image" || attachment.kind === "file")),
-        });
+        : telegramTransport
+            ? new TelegramChannelDriver({
+                transport: telegramTransport,
+                accountId: telegramAccount?.botUsername,
+                operatorId: credentials.userId,
+                logError,
+            })
+            : new WechatChannelDriver({
+                transport,
+                logError,
+                buildInboundPrompt: (text, attachments) => buildWechatInboundPrompt(text, attachments.filter((attachment) => attachment.kind === "image" || attachment.kind === "file")),
+            });
     // 非阻塞地检查更新（不影响启动速度，也避免首次登录时打断二维码输出）
     // unref：不能让这个延迟检查把 event loop 挂活（如 --doctor 或快速退出场景），
     // 否则会与强制退出 teardown 竞态。
@@ -325,9 +372,15 @@ async function main() {
         profile: options.profile,
         lifecycle: options.lifecycle,
         sessionStartMode: options.sessionStartMode,
-        initialSharedSessionId: stateStore.getState().sharedSessionId ?? stateStore.getState().sharedThreadId,
+        // Daemon attach binds an explicit or discovered live thread; a stale
+        // persisted session id must not leak into the attach target.
+        initialSharedSessionId: options.codexAttachDaemon
+            ? options.codexAttachThreadId
+            : stateStore.getState().sharedSessionId ?? stateStore.getState().sharedThreadId,
         initialResumeConversationId: stateStore.getState().resumeConversationId,
         initialTranscriptPath: stateStore.getState().transcriptPath,
+        codexAttachDaemon: options.codexAttachDaemon,
+        codexAttachThreadId: options.codexAttachThreadId,
     });
     const pendingWechatMessages = new PendingWechatMessageStore(options.channelId === "wechat"
         ? getPendingWechatMessagesFile(options.cwd)
@@ -414,8 +467,8 @@ async function main() {
     const trackWechatForwardTask = (task) => {
         const tracked = task
             .catch((error) => {
-            logError(`WeChat forward task failed: ${describeWechatTransportError(error)}`);
-            stateStore.appendLog(`wechat_forward_failed: error=${truncatePreview(describeWechatTransportError(error), 400)}`);
+            logError(`${channelDriver.displayName} forward task failed: ${describeWechatTransportError(error)}`);
+            stateStore.appendLog(`${channelDriver.id}_forward_failed: error=${truncatePreview(describeWechatTransportError(error), 400)}`);
         })
             .finally(() => {
             pendingWechatForwardTasks.delete(tracked);
@@ -661,6 +714,7 @@ async function main() {
             },
             requestShutdown,
             wecomTransport,
+            telegramTransport,
             getWecomTarget: () => turns.resolveTarget(operatorConversation),
         });
         await adapter.start();
@@ -706,7 +760,7 @@ async function main() {
                                     task: nextActiveTask,
                                     conversation: channelMessage.conversation,
                                     onBusy: async () => {
-                                        await queueInboundReply(message.senderId, `${options.adapter} is still working. Wait for the current reply or use /stop.`);
+                                        await queueInboundReply(message.senderId, t("bridge.busy.remote", { adapter: options.adapter }));
                                     },
                                     forward: async () => {
                                         await dispatchInboundWechatText({
@@ -752,7 +806,7 @@ async function main() {
                     if (chatType === "direct") {
                         const result = await channelDriver.sendText({
                             target: channelDriver.directConversation(senderId),
-                            text: "Unauthorized.",
+                            text: t("channel.unauthorized"),
                             context: "notice",
                             log: (entry) => stateStore.appendLog(entry),
                         });
@@ -884,7 +938,7 @@ async function main() {
                             const result = await turns.dispatch({
                                 task: nextActiveTask,
                                 onBusy: async () => {
-                                    await queueWechatMessage(message.senderId, `${options.adapter} is still working. Wait for the current reply or use /stop.`);
+                                    await queueWechatMessage(message.senderId, t("bridge.busy.remote", { adapter: options.adapter }));
                                 },
                                 forward: async () => {
                                     await dispatchInboundWechatText({
@@ -954,29 +1008,44 @@ function syncSharedSessionState(stateStore, adapter) {
         }
     }
 }
-function wireAdapterEvents(params) {
-    const { adapter, channelDriver, resumeCoordinator, options, transport, stateStore, outputBatcher, queueWechatAttachmentAction, queueWechatMessage, trackWechatForwardTask, maybeDrainDeferredInboundMessages, getActiveTask, clearActiveTask, syncSharedSessionState, syncLocalClientEndpoint, requestShutdown, wecomTransport, getWecomTarget, } = params;
-    const channelPort = options.channelId === "wecom"
-        ? new WecomChannelPort({
-            transport: wecomTransport,
-            sendText: (target, text, kind) => queueWechatMessage(stateStore.getState().authorizedUserId, text, toWechatSendContext(kind), target),
-            onEmptyVisibleReply: (adapter, rawText) => {
-                stateStore.appendLog(`empty_visible_final_reply: adapter=${adapter ?? options.adapter} raw=${truncatePreview(rawText)}`);
-            },
-        })
-        : new WechatChannelPort({
+export function wireAdapterEvents(params) {
+    const { adapter, channelDriver, resumeCoordinator, options, transport, stateStore, outputBatcher, queueWechatAttachmentAction, queueWechatMessage, trackWechatForwardTask, maybeDrainDeferredInboundMessages, getActiveTask, clearActiveTask, syncSharedSessionState, syncLocalClientEndpoint, requestShutdown, wecomTransport, telegramTransport, getWecomTarget, } = params;
+    const remotePortCallbacks = {
+        sendText: (target, text, kind) => queueWechatMessage(stateStore.getState().authorizedUserId, text, toWechatSendContext(kind), target),
+        onEmptyVisibleReply: (adapter, rawText) => {
+            stateStore.appendLog(`empty_visible_final_reply: adapter=${adapter ?? options.adapter} raw=${truncatePreview(rawText)}`);
+        },
+    };
+    // Every remote channel must provide its own port; never fall back to WeChat.
+    const portFactories = {
+        wecom: () => {
+            if (!wecomTransport) {
+                throw new Error("The wecom channel port requires a WeCom transport.");
+            }
+            return new WecomChannelPort({ transport: wecomTransport, ...remotePortCallbacks });
+        },
+        telegram: () => {
+            if (!telegramTransport) {
+                throw new Error("The telegram channel port requires a Telegram transport.");
+            }
+            return new TelegramChannelPort({ transport: telegramTransport, ...remotePortCallbacks });
+        },
+        wechat: () => new WechatChannelPort({
             sendText: (recipientId, text, context) => queueWechatMessage(recipientId, text, context),
             sendImage: (recipientId, filePath) => queueWechatAttachmentAction(() => transport.sendImage(filePath, { recipientId })),
             sendFile: (recipientId, filePath) => queueWechatAttachmentAction(() => transport.sendFile(filePath, { recipientId })),
             sendVoice: (recipientId, filePath) => queueWechatAttachmentAction(() => transport.sendVoice(filePath, recipientId)),
             sendVideo: (recipientId, filePath) => queueWechatAttachmentAction(() => transport.sendVideo(filePath, { recipientId })),
-            onEmptyVisibleReply: (adapter, rawText) => {
-                stateStore.appendLog(`empty_visible_final_reply: adapter=${adapter ?? options.adapter} raw=${truncatePreview(rawText)}`);
-            },
+            onEmptyVisibleReply: remotePortCallbacks.onEmptyVisibleReply,
             onTextSent: (_adapter, text) => {
                 stateStore.appendLog(`final_reply_sent: chars=${Array.from(text).length}`);
             },
-        });
+        }),
+    };
+    if (options.channelId === "local") {
+        throw new Error("The local channel does not support standalone bridge output.");
+    }
+    const channelPort = portFactories[options.channelId]();
     let lastFinalReplyAtMs = 0;
     let eventForwardChain = Promise.resolve();
     adapter.setEventSink((event) => {
@@ -984,10 +1053,12 @@ function wireAdapterEvents(params) {
         syncLocalClientEndpoint();
         const adapterState = adapter.getState();
         const bridgeState = stateStore.getState();
-        if (bridgeState.pendingConfirmation && !adapterState.pendingApproval) {
+        if (bridgeState.pendingConfirmation && (!adapterState.pendingApproval
+            || (adapterState.pendingApprovals !== undefined && bridgeState.pendingConfirmation.requestId !== adapterState.pendingApproval.requestId))) {
             stateStore.clearPendingConfirmation();
         }
-        if (bridgeState.pendingUserInput && !adapterState.pendingUserInput) {
+        if (bridgeState.pendingUserInput && (!adapterState.pendingUserInput
+            || (bridgeState.pendingUserInput.requestId !== undefined && bridgeState.pendingUserInput.requestId !== adapterState.pendingUserInput.requestId))) {
             stateStore.clearPendingUserInput();
         }
         const authorizedUserId = stateStore.getState().authorizedUserId;
@@ -1050,14 +1121,21 @@ function wireAdapterEvents(params) {
             },
             approvalRequired: (next) => {
                 trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
+                    const liveState = adapter.getState();
+                    if (liveState.pendingApprovals !== undefined && liveState.pendingApproval?.requestId !== next.request.requestId)
+                        return;
                     const pending = toPendingApproval(next.request);
-                    stateStore.setPendingConfirmation(pending);
                     stateStore.appendLog(`Approval requested (${pending.source}): ${pending.commandPreview}`);
-                    await queueWechatMessage(authorizedUserId, formatApprovalMessage(pending, adapterState), "approval_required", eventTarget);
+                    await queueWechatMessage(authorizedUserId, formatApprovalMessage(pending, liveState), "approval_required", eventTarget);
+                    if (adapter.getState().pendingApproval?.requestId === pending.requestId) {
+                        stateStore.setPendingConfirmation(pending);
+                    }
                 }));
             },
             userInputRequired: (next) => {
                 trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
+                    if (next.request.requestId !== undefined && adapter.getState().pendingUserInput?.requestId !== next.request.requestId)
+                        return;
                     const pending = toPendingUserInput(next.request);
                     stateStore.setPendingUserInput(pending);
                     stateStore.appendLog(`User input requested: questions=${pending.questions.length}`);
@@ -1155,12 +1233,12 @@ function formatInboundMessagePreview(message) {
     }
     return "(empty)";
 }
-async function handleInboundMessage(params) {
+export async function handleInboundMessage(params) {
     const { message, channelMessage, channelDriver, } = params;
     const { options, stateStore, adapter, resumeCoordinator, queueWechatMessage, outputBatcher, clearActiveTask, dispatchInboundText, deferInboundMessage, } = params;
     const state = stateStore.getState();
     if (message.senderId !== state.authorizedUserId) {
-        await queueWechatMessage(message.senderId, `Unauthorized. This bridge only accepts messages from ${channelDriver.operatorDescription}.`);
+        await queueWechatMessage(message.senderId, t("bridge.unauthorized", { mode: t("bridge.mode.bridge"), operator: channelDriver.operatorDescription }));
         return null;
     }
     const systemCommand = parseWechatControlCommand(message.text, {
@@ -1169,19 +1247,24 @@ async function handleInboundMessage(params) {
         hasPendingUserInput: Boolean(state.pendingUserInput),
     });
     switch (systemCommand?.type) {
+        case "language":
+            await queueWechatMessage(message.senderId, await handleLanguageControl({
+                target: systemCommand.target, settingsFile: params.localeSettingsFile ?? LANGUAGE_FILE, adapters: [adapter],
+            }));
+            return null;
         case "model":
         case "plan":
             await queueWechatMessage(message.senderId, await handleAdapterControl(adapter, message.senderId, systemCommand));
             return null;
         case "broadcast":
-            await queueWechatMessage(message.senderId, "/all is only available in daemon mode. Start the daemon with wechat-daemon or wecom-daemon to broadcast to all workers.");
+            await queueWechatMessage(message.senderId, t("bridge.broadcast.daemonOnly"));
             return null;
         case "status":
             await queueWechatMessage(message.senderId, formatStatusReport(stateStore.getState(), adapter.getState()));
             return null;
         case "resume": {
             if (!isWechatResumeEnabled(options.adapter)) {
-                await queueWechatMessage(message.senderId, `${channelDriver.displayName} /resume is disabled in ${options.adapter} mode. Use /resume directly inside "${channelDriver.id}-${options.adapter}"; the remote channel will follow the active local session.`);
+                await queueWechatMessage(message.senderId, t("bridge.resume.disabled", { channel: channelDriver.displayName, adapter: options.adapter, command: `${channelDriver.id}-${options.adapter}` }));
                 return null;
             }
             try {
@@ -1201,7 +1284,7 @@ async function handleInboundMessage(params) {
         }
         case "new_session": {
             if (!adapter.createSession) {
-                await queueWechatMessage(message.senderId, `/new is not available in ${options.adapter} mode.`);
+                await queueWechatMessage(message.senderId, t("bridge.newSession.unavailable", { adapter: options.adapter }));
                 return null;
             }
             await outputBatcher.flushNow();
@@ -1217,8 +1300,8 @@ async function handleInboundMessage(params) {
         case "stop": {
             const interrupted = await adapter.interrupt();
             await queueWechatMessage(message.senderId, interrupted
-                ? "Interrupt signal sent to the active worker."
-                : "No running worker was available to interrupt.");
+                ? t("bridge.interrupt.workerSent")
+                : t("bridge.interrupt.workerIdle"));
             return null;
         }
         case "reset":
@@ -1230,47 +1313,48 @@ async function handleInboundMessage(params) {
             resumeCoordinator.clear();
             await adapter.reset();
             stateStore.appendLog("Worker reset by owner.");
-            await queueWechatMessage(message.senderId, "Worker session has been reset.");
+            await queueWechatMessage(message.senderId, t("bridge.reset.done"));
             return null;
         case "confirm": {
             const pending = state.pendingConfirmation;
             if (!pending) {
-                await queueWechatMessage(message.senderId, "No pending approval request.");
+                await queueWechatMessage(message.senderId, t("approval.noPending"));
                 return null;
             }
-            const confirmed = await adapter.resolveApproval("confirm");
+            const confirmed = await adapter.resolveApproval("confirm", pending.requestId);
             if (!confirmed) {
-                await queueWechatMessage(message.senderId, "The worker could not apply this approval request.");
+                await queueWechatMessage(message.senderId, t("bridge.approval.applyFailed"));
                 return null;
             }
-            stateStore.clearPendingConfirmation();
+            if (stateStore.getState().pendingConfirmation?.requestId === pending.requestId) {
+                stateStore.clearPendingConfirmation();
+            }
             stateStore.appendLog(`Approval confirmed: ${pending.commandPreview}`);
-            await queueWechatMessage(message.senderId, "Approval confirmed. Continuing...");
-            return {
-                startedAt: Date.now(),
-                inputPreview: pending.commandPreview,
-            };
+            await queueWechatMessage(message.senderId, t("approval.confirmed"));
+            return null;
         }
         case "deny": {
             const pending = state.pendingConfirmation;
             if (!pending) {
-                await queueWechatMessage(message.senderId, "No pending approval request.");
+                await queueWechatMessage(message.senderId, t("approval.noPending"));
                 return null;
             }
-            const denied = await adapter.resolveApproval("deny");
+            const denied = await adapter.resolveApproval("deny", pending.requestId);
             if (!denied) {
-                await queueWechatMessage(message.senderId, "The worker could not deny this approval request cleanly.");
+                await queueWechatMessage(message.senderId, t("bridge.approval.denyFailed"));
                 return null;
             }
-            stateStore.clearPendingConfirmation();
+            if (stateStore.getState().pendingConfirmation?.requestId === pending.requestId) {
+                stateStore.clearPendingConfirmation();
+            }
             stateStore.appendLog(`Approval denied: ${pending.commandPreview}`);
-            await queueWechatMessage(message.senderId, "Approval denied.");
+            await queueWechatMessage(message.senderId, t("approval.denied"));
             return null;
         }
         case "answer": {
             const pending = state.pendingUserInput;
             if (!pending) {
-                await queueWechatMessage(message.senderId, "No pending user input request.");
+                await queueWechatMessage(message.senderId, t("bridge.answer.none"));
                 return null;
             }
             const parsed = parsePendingUserInputAnswerCommand(systemCommand.raw, pending);
@@ -1278,18 +1362,16 @@ async function handleInboundMessage(params) {
                 await queueWechatMessage(message.senderId, parsed.error);
                 return null;
             }
-            const submitted = await adapter.submitUserInput(parsed.answers);
+            const submitted = await adapter.submitUserInput(parsed.answers, pending.requestId);
             if (!submitted) {
-                await queueWechatMessage(message.senderId, "The worker could not apply this answer.");
+                await queueWechatMessage(message.senderId, t("bridge.answer.failed"));
                 return null;
             }
-            stateStore.clearPendingUserInput();
+            if (stateStore.getState().pendingUserInput?.requestId === pending.requestId)
+                stateStore.clearPendingUserInput();
             stateStore.appendLog(`User input answered: ${parsed.preview}`);
-            await queueWechatMessage(message.senderId, "Answer submitted. Continuing...");
-            return {
-                startedAt: Date.now(),
-                inputPreview: parsed.preview,
-            };
+            await queueWechatMessage(message.senderId, t("bridge.answer.sent"));
+            return null;
         }
     }
     const adapterState = adapter.getState();
@@ -1316,16 +1398,16 @@ async function handleInboundMessage(params) {
             const pendingUserInput = stateStore.getState().pendingUserInput;
             await queueWechatMessage(message.senderId, pendingUserInput
                 ? formatPendingUserInputReminder(pendingUserInput)
-                : `${options.adapter} is waiting for structured input. Reply with /answer <key>=<value> ...`);
+                : t("bridge.input.waiting", { adapter: options.adapter }));
         },
         remindBusy: async () => {
             const currentState = adapter.getState();
             if ((options.adapter === "codex" || options.adapter === "opencode" || options.adapter === "pi") &&
                 currentState.activeTurnOrigin === "local") {
-                await queueWechatMessage(message.senderId, `${options.adapter === "opencode" ? "OpenCode" : options.adapter === "pi" ? "Pi" : "codex"} is currently busy with a local terminal turn. Wait for it to finish or use /stop.`);
+                await queueWechatMessage(message.senderId, t("bridge.busy.local", { adapter: options.adapter === "opencode" ? "OpenCode" : options.adapter === "pi" ? "Pi" : "codex" }));
                 return;
             }
-            await queueWechatMessage(message.senderId, `${options.adapter} is still working. Wait for the current reply or use /stop.`);
+            await queueWechatMessage(message.senderId, t("bridge.busy.remote", { adapter: options.adapter }));
         },
         defer: async () => {
             await deferInboundMessage(message);

package/dist/channels/channel-driver-factory.js

@@ -0,0 +1,56 @@
+import { WecomChannelDriver } from "./wecom/wecom-driver.js";
+import { WechatChannelDriver } from "./wechat/wechat-driver.js";
+import { TelegramChannelDriver } from "./telegram/telegram-driver.js";
+import { LocalChannelDriver } from "./local/local-driver.js";
+/**
+ * Single construction point for channel drivers. Adding a channel means
+ * adding a driver implementation and one branch here; orchestration layers
+ * stay channel-neutral.
+ */
+export function createChannelDriver(input) {
+    if (input.channelId === "wecom") {
+        if (!input.wecomTransport) {
+            throw new Error("The wecom channel requires a WeCom transport.");
+        }
+        return new WecomChannelDriver({
+            transport: input.wecomTransport,
+            accountId: input.accountId,
+            operatorId: input.authorizedUserId,
+            logError: input.logError,
+        });
+    }
+    if (input.channelId === "telegram") {
+        if (!input.telegramTransport) {
+            throw new Error("The telegram channel requires a Telegram transport.");
+        }
+        return new TelegramChannelDriver({
+            transport: input.telegramTransport,
+            accountId: input.accountId,
+            operatorId: input.authorizedUserId,
+            logError: input.logError,
+        });
+    }
+    if (input.channelId === "local") {
+        const files = input.localFiles ?? {
+            inboxFile: "",
+            transcriptFile: "",
+        };
+        if (!files.inboxFile || !files.transcriptFile) {
+            throw new Error("The local channel requires inbox and transcript file paths.");
+        }
+        return new LocalChannelDriver({
+            operatorId: input.authorizedUserId,
+            inboxFile: files.inboxFile,
+            transcriptFile: files.transcriptFile,
+            log: input.log,
+        });
+    }
+    if (!input.wechatTransport) {
+        throw new Error("The wechat channel requires a WeChat transport.");
+    }
+    return new WechatChannelDriver({
+        transport: input.wechatTransport,
+        logError: input.logError,
+        buildInboundPrompt: input.buildWechatInboundPrompt,
+    });
+}

package/dist/channels/local/local-channel-port.js

@@ -0,0 +1,40 @@
+/**
+ * Channel boundary for local loopback output. Unlike WeChat there is no
+ * plain-text conversion: the harness consumes the raw final reply.
+ */
+export class LocalChannelPort {
+    channelId = "local";
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async send(output) {
+        if (output.target.channelId !== "local") {
+            throw new Error(`Local channel cannot send to ${output.target.channelId}.`);
+        }
+        const recipientId = output.target.recipientId;
+        const prefixText = (text) => this.deps.prefixText?.(output.adapter, text) ?? text;
+        const context = typeof output.metadata?.sendContext === "string"
+            ? output.metadata.sendContext
+            : output.kind;
+        if (output.kind === "final_reply") {
+            const rawText = output.text ?? "";
+            if (!rawText.trim()) {
+                this.deps.onEmptyVisibleReply?.(output.adapter, rawText);
+                return true;
+            }
+            const sent = await this.deps.sendText(recipientId, prefixText(rawText), "final_reply");
+            if (sent) {
+                this.deps.onTextSent?.(output.adapter, rawText);
+            }
+            return true;
+        }
+        if (output.attachment) {
+            await this.deps.sendAttachment?.(recipientId, output.attachment);
+        }
+        if (output.text?.trim()) {
+            return Boolean(await this.deps.sendText(recipientId, prefixText(output.text), context));
+        }
+        return true;
+    }
+}