@unlinearity/cli-wechat-bridge 1.0.2 → 1.0.4

package/dist/bridge/bridge-adapters.shared.js

@@ -8,6 +8,8 @@ import { attachLocalCompanionMessageListener, buildLocalCompanionToken, clearLoc
 import { ensureWorkspaceChannelDir } from "../wechat/channel-config.js";
 import { buildClaudeFailureMessage, buildClaudeHookSettings, buildClaudePermissionDecisionHookOutput, buildClaudePermissionApprovalRequest, extractClaudeResumeConversationId, findInjectedClaudePromptIndex, normalizeClaudeAssistantMessage, parseClaudeHookPayload, } from "./claude-hooks.js";
 import { detectCliApproval, isHighRiskShellCommand, normalizeOutput, nowIso, truncatePreview, } from "./bridge-utils.js";
+import { coerceWebSocketMessageData, describeUnknownError, getCodexRpcRequestId, getLocalCompanionCommandName, getNotificationThreadId, getNotificationTurnId, getSharedSessionIdFromAdapterState, isRecentIsoTimestamp, isRecord, normalizeCodexRpcError, quotePosixCommandArg, quoteWindowsCommandArg, } from "./bridge-adapter-common.js";
+export { coerceWebSocketMessageData, describeUnknownError, getCodexRpcRequestId, getLocalCompanionCommandName, getNotificationThreadId, getNotificationTurnId, getSharedSessionIdFromAdapterState, isRecentIsoTimestamp, isRecord, normalizeCodexRpcError, quotePosixCommandArg, quoteWindowsCommandArg, } from "./bridge-adapter-common.js";
 export const DEFAULT_COLS = 120;
 export const DEFAULT_ROWS = 30;
 export const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
@@ -39,101 +41,6 @@ export const OPENCODE_SERVER_READY_TIMEOUT_MS = 10_000;
 export const OPENCODE_SSE_RECONNECT_DELAY_MS = 2_000;
 export const OPENCODE_SESSION_IDLE_SETTLE_MS = 1_500;
 export const OPENCODE_WECHAT_WORKING_NOTICE_DELAY_MS = 12_000;
-export function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-export function getCodexRpcRequestId(value) {
-    return typeof value === "string" || typeof value === "number" ? value : null;
-}
-export function getNotificationThreadId(params) {
-    if (!isRecord(params)) {
-        return null;
-    }
-    if (typeof params.threadId === "string") {
-        return params.threadId;
-    }
-    if (isRecord(params.thread) && typeof params.thread.id === "string") {
-        return params.thread.id;
-    }
-    return null;
-}
-export function getNotificationTurnId(params) {
-    if (!isRecord(params)) {
-        return null;
-    }
-    if (typeof params.turnId === "string") {
-        return params.turnId;
-    }
-    if (isRecord(params.turn) && typeof params.turn.id === "string") {
-        return params.turn.id;
-    }
-    return null;
-}
-export function describeUnknownError(error) {
-    if (error instanceof Error && error.message) {
-        return error.message;
-    }
-    return String(error);
-}
-export function normalizeCodexRpcError(error) {
-    if (isRecord(error)) {
-        const message = typeof error.message === "string"
-            ? error.message
-            : typeof error.code === "number"
-                ? `RPC error ${error.code}`
-                : "";
-        const data = typeof error.data === "string"
-            ? error.data
-            : typeof error.details === "string"
-                ? error.details
-                : "";
-        const combined = [message, data].filter(Boolean).join(": ");
-        if (combined) {
-            return combined;
-        }
-    }
-    return describeUnknownError(error);
-}
-export function getLocalCompanionCommandName(kind) {
-    switch (kind) {
-        case "codex":
-            return "wechat-codex";
-        case "claude":
-            return "wechat-claude";
-        case "opencode":
-            return "wechat-opencode";
-        default:
-            return "local companion";
-    }
-}
-export function getSharedSessionIdFromAdapterState(state) {
-    return state.sharedSessionId ?? state.sharedThreadId;
-}
-export function quoteWindowsCommandArg(value) {
-    return `"${value.replace(/"/g, '""')}"`;
-}
-export function quotePosixCommandArg(value) {
-    return `'${value.replace(/'/g, `'\\''`)}'`;
-}
-export function isRecentIsoTimestamp(timestamp, maxAgeMs) {
-    const parsedMs = Date.parse(timestamp);
-    if (!Number.isFinite(parsedMs)) {
-        return false;
-    }
-    return parsedMs >= Date.now() - maxAgeMs;
-}
-export function coerceWebSocketMessageData(data) {
-    if (typeof data === "string") {
-        return data;
-    }
-    if (data instanceof ArrayBuffer) {
-        return Buffer.from(data).toString("utf8");
-    }
-    if (ArrayBuffer.isView(data)) {
-        return Buffer.from(data.buffer, data.byteOffset, data.byteLength).toString("utf8");
-    }
-    return null;
-}
 export function buildCodexCliArgs(remoteUrl, options = {}) {
     assertNoReservedExtraCliArgs(options.extraCliArgs ?? [], ["--remote", "--remote-auth-token-env"], "Codex remote connection");
     const args = [];
@@ -196,7 +103,7 @@ export function shouldIncludeClaudeNoAltScreen(command) {
     if (cached !== undefined) {
         return cached;
     }
-    let supported = false;
+    let supported;
     try {
         const probe = spawnSync(spawnTarget.file, [...spawnTarget.args, "--help"], {
             cwd: process.cwd(),
@@ -660,7 +567,7 @@ export function escapePowerShellString(text) {
     return text.replace(/`/g, "``").replace(/"/g, '`"');
 }
 export function escapePosixShellString(text) {
-    return `'${text.replace(/'/g, `'\"'\"'`)}'`;
+    return `'${text.replace(/'/g, `'"'"'`)}'`;
 }
 export function buildShellProfileCommand(profilePath, family) {
     const resolved = path.resolve(profilePath);

package/dist/bridge/bridge-final-reply.js

@@ -1,10 +1,25 @@
 import { formatFinalReplyMessage, parseWechatFinalReply, sanitizeWechatFinalReplyText, } from "./bridge-utils.js";
+export const OPENCODE_EMPTY_VISIBLE_REPLY_MESSAGE = "OpenCode 没有产生可发送到微信的可见回复。请查看本地终端输出，或重试这条消息。";
 export async function forwardWechatFinalReply(params) {
-    const { adapter, rawText, sender } = params;
+    const { adapter, rawText, sender, onEmptyVisibleReply } = params;
     const parsed = parseWechatFinalReply(rawText);
-    const visibleText = formatFinalReplyMessage(adapter, sanitizeWechatFinalReplyText(adapter, parsed.visibleText)).trim();
+    const sanitizedText = sanitizeWechatFinalReplyText(adapter, parsed.visibleText);
+    const visibleText = formatFinalReplyMessage(adapter, sanitizedText).trim();
     if (visibleText) {
-        await sender.sendText(visibleText);
+        const sent = await sender.sendText(visibleText);
+        if (sent === false) {
+            return;
+        }
+    }
+    else if (adapter === "opencode" && parsed.visibleText.trim()) {
+        onEmptyVisibleReply?.({
+            adapter,
+            rawVisibleText: parsed.visibleText,
+        });
+        const sent = await sender.sendText(OPENCODE_EMPTY_VISIBLE_REPLY_MESSAGE);
+        if (sent === false) {
+            return;
+        }
     }
     for (const attachment of parsed.attachments) {
         try {

package/dist/bridge/bridge-state.js

@@ -3,6 +3,14 @@ import { BRIDGE_LOCK_FILE, BRIDGE_LOG_FILE, ensureWorkspaceChannelDir, ensureCha
 import { buildInstanceId } from "./bridge-utils.js";
 const ORPHAN_LOCK_RECLAIM_TIMEOUT_MS = 2_000;
 const ORPHAN_LOCK_RECLAIM_POLL_MS = 100;
+export function resolveRestorableSharedSessionId(persisted, options) {
+    if (!persisted ||
+        persisted.cwd !== options.cwd ||
+        persisted.adapter !== options.adapter) {
+        return undefined;
+    }
+    return persisted.sharedSessionId ?? persisted.sharedThreadId;
+}
 function cloneState(state) {
     return JSON.parse(JSON.stringify(state));
 }
@@ -162,9 +170,7 @@ export class BridgeStateStore {
         };
         this.acquireLock();
         const persisted = this.readStateFile();
-        const persistedSharedSessionId = persisted?.cwd === options.cwd
-            ? persisted.sharedSessionId ?? persisted.sharedThreadId
-            : undefined;
+        const persistedSharedSessionId = resolveRestorableSharedSessionId(persisted, options);
         const persistedResumeConversationId = options.adapter === "claude" &&
             persisted?.cwd === options.cwd &&
             typeof persisted.resumeConversationId === "string"

package/dist/bridge/bridge-utils.js

@@ -101,6 +101,7 @@ export function stripAnsi(text) {
 }
 export function normalizeOutput(text) {
     return stripAnsi(text)
+        // eslint-disable-next-line no-control-regex
         .replace(/\u0000/g, "")
         .replace(/\r\n/g, "\n")
         .replace(/\r/g, "\n");
@@ -132,6 +133,9 @@ export function parseSystemCommand(text) {
         return null;
     }
     const [rawCommand, ...rest] = trimmed.split(/\s+/);
+    if (!rawCommand) {
+        return null;
+    }
     const command = rawCommand.toLowerCase();
     const argument = rest.join(" ").trim();
     switch (command) {
@@ -139,6 +143,9 @@ export function parseSystemCommand(text) {
             return { type: "status" };
         case "/resume":
             return argument ? { type: "resume", target: argument } : { type: "resume" };
+        case "/new":
+        case "/new-session":
+            return { type: "new_session" };
         case "/stop":
             return { type: "stop" };
         case "/reset":
@@ -224,7 +231,11 @@ export function parseWechatFinalReply(text) {
         return extractInlineWechatAttachments(normalized);
     }
     const attachments = [];
-    const lines = match[1]
+    const attachmentBlock = match[1];
+    if (attachmentBlock === undefined) {
+        return extractInlineWechatAttachments(normalized);
+    }
+    const lines = attachmentBlock
         .split("\n")
         .map((line) => line.trim())
         .filter(Boolean);
@@ -237,7 +248,11 @@ export function parseWechatFinalReply(text) {
             return extractInlineWechatAttachments(normalized);
         }
         const kind = parsed[1];
-        const attachmentPath = resolveWechatAttachmentPath(parsed[2]);
+        const rawPath = parsed[2];
+        if (!rawPath) {
+            return extractInlineWechatAttachments(normalized);
+        }
+        const attachmentPath = resolveWechatAttachmentPath(rawPath);
         if (!attachmentPath) {
             return extractInlineWechatAttachments(normalized);
         }
@@ -404,7 +419,11 @@ export function getInteractiveShellCommandRejectionMessage(command) {
     if (!tokens.length) {
         return null;
     }
-    const executable = normalizeShellExecutableToken(tokens[0]);
+    const firstToken = tokens[0];
+    if (!firstToken) {
+        return null;
+    }
+    const executable = normalizeShellExecutableToken(firstToken);
     const args = tokens.slice(1);
     const lowerArgs = args.map((arg) => arg.toLowerCase());
     if (!executable) {
@@ -416,7 +435,7 @@ export function getInteractiveShellCommandRejectionMessage(command) {
     switch (executable) {
         case "python":
         case "python3":
-        case "py":
+        case "py": {
             if (!args.length) {
                 return buildInteractiveShellCommandMessage(executable, 'Try "python script.py" or "python -c \\"...\\"" instead.');
             }
@@ -435,6 +454,7 @@ export function getInteractiveShellCommandRejectionMessage(command) {
             return hasScriptLikeArg(args)
                 ? null
                 : buildInteractiveShellCommandMessage(executable, 'Try "python script.py" or "python -c \\"...\\"" instead.');
+        }
         case "node":
             if (!args.length || lowerArgs.includes("-i") || lowerArgs.includes("--interactive")) {
                 return buildInteractiveShellCommandMessage(executable, 'Try "node script.js" or "node -e \\"...\\"" instead.');
@@ -694,6 +714,7 @@ const OPENCODE_REASONING_LINE_RES = [
     /\bI need to (?:respond|reply|answer|tell the user)\b/i,
     /\bWe need to (?:respond|reply|answer)\b/i,
     /\bI should\b/i,
+    /\bI(?:'ll| will) (?:respond|reply|answer|tell the user|provide)\b/i,
     /\bI'll provide\b/i,
     /^Let me (?:directly )?(?:answer|respond)\b/i,
     /根据系统提示/i,
@@ -704,8 +725,30 @@ const OPENCODE_REASONING_LINE_RES = [
     /^我要直接(?:回答|回复)/,
     /^用户(?:说|问)了/,
 ];
+const OPENCODE_INLINE_REASONING_MARKER_RE = /\b(?:The user\b|I need to\b|I should\b|I(?:'ll| will)\b|We need to\b|Let me\b)/i;
+const OPENCODE_INLINE_REASONING_SENTENCE_RE = /^(?:The user\b|I need to\b|I should\b|I(?:'ll| will)\b|We need to\b|Let me\b)[^.!?\n]*(?:[.!?]+)\s*/i;
+function stripInlineOpenCodeReasoningPrefix(text) {
+    let current = text.trim();
+    const markerIndex = current.search(OPENCODE_INLINE_REASONING_MARKER_RE);
+    if (markerIndex > 0 && markerIndex <= 80) {
+        current = current.slice(markerIndex).trimStart();
+    }
+    for (let index = 0; index < 6; index += 1) {
+        const match = current.match(OPENCODE_INLINE_REASONING_SENTENCE_RE);
+        if (!match) {
+            break;
+        }
+        current = current.slice(match[0].length).trimStart();
+    }
+    return current;
+}
+function isOpenCodeReasoningResidue(text) {
+    return !text.replace(/[\s"'“”‘’`.,!?;:()[\]{}<>…。！？；：（）【】《》、，-]/g, "");
+}
 export function sanitizeWechatFinalReplyText(adapter, text) {
-    const normalized = cleanupVisibleWechatReplyText(text);
+    const normalized = adapter === "opencode"
+        ? cleanupVisibleWechatReplyText(stripInlineOpenCodeReasoningPrefix(text))
+        : cleanupVisibleWechatReplyText(text);
     if (!normalized || adapter !== "opencode") {
         return normalized;
     }
@@ -752,7 +795,8 @@ export function sanitizeWechatFinalReplyText(adapter, text) {
         return cleaned;
     }
     const tail = cleanupVisibleWechatReplyText(keptLines.slice(tailStartIndex).join("\n"));
-    return tail || cleaned;
+    const resolved = tail || cleaned;
+    return isOpenCodeReasoningResidue(resolved) ? "" : resolved;
 }
 function extractInlineWechatAttachments(text) {
     const sanitized = text
@@ -923,7 +967,7 @@ function parseSingleUserInputAnswer(question, rawValue) {
         };
     }
     const separatorIndex = trimmed.indexOf("|");
-    let selection = separatorIndex >= 0 ? trimmed.slice(0, separatorIndex).trim() : trimmed;
+    const selection = separatorIndex >= 0 ? trimmed.slice(0, separatorIndex).trim() : trimmed;
     let note = separatorIndex >= 0 ? trimmed.slice(separatorIndex + 1).trim() : "";
     const answers = [];
     if (selection) {
@@ -933,7 +977,6 @@ function parseSingleUserInputAnswer(question, rawValue) {
         }
         else if (question.isOther) {
             note = note ? `${selection}; ${note}` : selection;
-            selection = "";
         }
         else {
             return {
@@ -963,6 +1006,11 @@ export function parsePendingUserInputAnswerCommand(raw, pending) {
     const answers = {};
     if (pending.questions.length === 1) {
         const question = pending.questions[0];
+        if (!question) {
+            return {
+                error: "No pending user input question was found.",
+            };
+        }
         const parsed = parseSingleUserInputAnswer(question, input);
         if ("error" in parsed) {
             return parsed;
@@ -1045,6 +1093,9 @@ export function formatUserInputRequestMessage(pending, adapterState) {
     lines.push("");
     if (pending.questions.length === 1) {
         const question = pending.questions[0];
+        if (!question) {
+            return lines.join("\n");
+        }
         if (question.options?.length) {
             lines.push("Reply with /answer <option number or exact label>.");
             if (question.isOther) {
@@ -1067,6 +1118,9 @@ export function formatUserInputRequestMessage(pending, adapterState) {
 export function formatPendingUserInputReminder(pending) {
     if (pending.questions.length === 1) {
         const question = pending.questions[0];
+        if (!question) {
+            return "Codex is waiting for user input. Reply with /answer and your response, or use /stop to interrupt.";
+        }
         return `Codex is waiting for user input for ${question.header}. Reply with /answer and your response, or use /stop to interrupt.`;
     }
     return `Codex is waiting for answers to ${pending.questions.length} questions. Reply with /answer questionId=value; questionId2=value, or use /stop to interrupt.`;

package/dist/bridge/claude-hooks.js

@@ -108,7 +108,7 @@ function summarizeClaudePlan(plan) {
     const description = lines.find((line) => !/^#+\s+/.test(line) &&
         !/^[-*]\s+/.test(line) &&
         !/^\d+\.\s+/.test(line));
-    return truncatePreview([heading, description].filter(Boolean).join(" - ") || lines[0], 180);
+    return truncatePreview([heading, description].filter(Boolean).join(" - ") || lines[0] || "(empty plan)", 180);
 }
 function summarizeClaudeToolInput(toolName, toolInput) {
     if (!toolInput) {
@@ -214,7 +214,7 @@ export function extractClaudeTranscriptFinalReply(rawTranscript) {
         if (!line) {
             continue;
         }
-        let parsed = null;
+        let parsed;
         try {
             parsed = JSON.parse(line);
         }

package/dist/bridge/wechat-bridge.js

@@ -14,6 +14,8 @@ import { checkForUpdate, formatUpdateMessage, } from "../utils/version-checker.j
 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;
 function log(message) {
     process.stderr.write(`[wechat-bridge] ${message}\n`);
 }
@@ -73,6 +75,21 @@ export function formatUserFacingInboundError(params) {
 export function formatWechatSendFailureLogEntry(params) {
     return `wechat_send_failed: context=${params.context} recipient=${params.recipientId} 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)}`;
+}
+function isRetryableWechatSendError(error) {
+    const classification = classifyWechatTransportError(error);
+    if (classification.retryable) {
+        return true;
+    }
+    const details = describeWechatTransportError(error);
+    return /^Error: 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"));
@@ -271,6 +288,7 @@ async function main() {
     stateStore.appendLog(`Cleared stale companion endpoint for ${options.cwd} before adapter start.`);
     let textSendChain = Promise.resolve();
     let attachmentSendChain = Promise.resolve();
+    const pendingWechatForwardTasks = new Set();
     let activeTask = null;
     const deferredInboundMessages = [];
     let drainingDeferredInboundMessages = false;
@@ -288,14 +306,53 @@ async function main() {
         return run;
     };
     const queueWechatMessage = (senderId, text, context = "message") => {
-        return queueWechatTextAction(() => transport.sendText(senderId, text)).catch((err) => {
-            logError(`Failed to send WeChat ${context}: ${describeWechatTransportError(err)}`);
-            stateStore.appendLog(formatWechatSendFailureLogEntry({
-                context,
-                recipientId: senderId,
-                error: err,
-            }));
+        return queueWechatTextAction(async () => {
+            for (let attempt = 1; attempt <= WECHAT_SEND_MAX_ATTEMPTS; attempt += 1) {
+                try {
+                    await transport.sendText(senderId, text);
+                    return true;
+                }
+                catch (err) {
+                    if (attempt < WECHAT_SEND_MAX_ATTEMPTS && isRetryableWechatSendError(err)) {
+                        const delayMs = computeWechatSendRetryDelayMs(attempt);
+                        logError(`Failed to send WeChat ${context} (attempt ${attempt}). Retrying in ${formatDuration(delayMs)}. ${describeWechatTransportError(err)}`);
+                        stateStore.appendLog(formatWechatSendRetryLogEntry({
+                            context,
+                            recipientId: senderId,
+                            attempt,
+                            delayMs,
+                            error: err,
+                        }));
+                        await delay(delayMs);
+                        continue;
+                    }
+                    logError(`Failed to send WeChat ${context}: ${describeWechatTransportError(err)}`);
+                    stateStore.appendLog(formatWechatSendFailureLogEntry({
+                        context,
+                        recipientId: senderId,
+                        error: err,
+                    }));
+                    return false;
+                }
+            }
+            return false;
+        });
+    };
+    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)}`);
+        })
+            .finally(() => {
+            pendingWechatForwardTasks.delete(tracked);
         });
+        pendingWechatForwardTasks.add(tracked);
+    };
+    const waitForPendingWechatForwardTasks = async () => {
+        while (pendingWechatForwardTasks.size > 0) {
+            await Promise.allSettled([...pendingWechatForwardTasks]);
+        }
     };
     const outputBatcher = new OutputBatcher(async (text) => {
         await queueWechatMessage(stateStore.getState().authorizedUserId, text);
@@ -377,6 +434,7 @@ async function main() {
         }
         try {
             await outputBatcher.flushNow();
+            await waitForPendingWechatForwardTasks();
         }
         catch {
             // Best effort flush.
@@ -384,6 +442,7 @@ async function main() {
         try {
             await textSendChain;
             await attachmentSendChain;
+            await waitForPendingWechatForwardTasks();
         }
         catch {
             // Best effort flush.
@@ -458,6 +517,7 @@ async function main() {
             outputBatcher,
             queueWechatAttachmentAction,
             queueWechatMessage,
+            trackWechatForwardTask,
             maybeDrainDeferredInboundMessages,
             getActiveTask: () => activeTask,
             clearActiveTask: () => {
@@ -622,7 +682,7 @@ function syncSharedSessionState(stateStore, adapter) {
     }
 }
 function wireAdapterEvents(params) {
-    const { adapter, options, transport, stateStore, outputBatcher, queueWechatAttachmentAction, queueWechatMessage, maybeDrainDeferredInboundMessages, getActiveTask, clearActiveTask, updateLastOutputAt, syncSharedSessionState, syncLocalClientEndpoint, requestShutdown, } = params;
+    const { adapter, options, transport, stateStore, outputBatcher, queueWechatAttachmentAction, queueWechatMessage, trackWechatForwardTask, maybeDrainDeferredInboundMessages, getActiveTask, clearActiveTask, updateLastOutputAt, syncSharedSessionState, syncLocalClientEndpoint, requestShutdown, } = params;
     adapter.setEventSink((event) => {
         syncSharedSessionState();
         syncLocalClientEndpoint();
@@ -641,19 +701,29 @@ function wireAdapterEvents(params) {
                 }
                 break;
             case "final_reply":
-                void outputBatcher.flushNow().then(async () => {
+                stateStore.appendLog(`final_reply: ${truncatePreview(event.text)}`);
+                trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                     await forwardWechatFinalReply({
                         adapter: options.adapter,
                         rawText: event.text,
+                        onEmptyVisibleReply: ({ rawVisibleText }) => {
+                            stateStore.appendLog(`empty_visible_final_reply: adapter=${options.adapter} raw=${truncatePreview(rawVisibleText)}`);
+                        },
                         sender: {
-                            sendText: (text) => queueWechatMessage(authorizedUserId, text),
+                            sendText: async (text) => {
+                                const sent = await queueWechatMessage(authorizedUserId, text, "final_reply");
+                                if (sent) {
+                                    stateStore.appendLog(`final_reply_sent: chars=${Array.from(text).length}`);
+                                }
+                                return sent;
+                            },
                             sendImage: (imagePath) => queueWechatAttachmentAction(() => transport.sendImage(imagePath, { recipientId: authorizedUserId })),
                             sendFile: (filePath) => queueWechatAttachmentAction(() => transport.sendFile(filePath, { recipientId: authorizedUserId })),
                             sendVoice: (voicePath) => queueWechatAttachmentAction(() => transport.sendVoice(voicePath, authorizedUserId)),
                             sendVideo: (videoPath) => queueWechatAttachmentAction(() => transport.sendVideo(videoPath, { recipientId: authorizedUserId })),
                         },
                     });
-                });
+                }));
                 break;
             case "status":
                 if (event.message) {
@@ -666,56 +736,56 @@ function wireAdapterEvents(params) {
                 updateLastOutputAt();
                 stateStore.appendLog(`${event.level}_notice: ${truncatePreview(event.text)}`);
                 if (shouldForwardBridgeEventToWechat(options.adapter, event.type, { text: event.text })) {
-                    void outputBatcher.flushNow().then(async () => {
+                    trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                         await queueWechatMessage(authorizedUserId, event.text, "notice");
-                    });
+                    }));
                 }
                 break;
             case "approval_required":
-                void outputBatcher.flushNow().then(async () => {
+                trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                     const pending = toPendingApproval(event.request);
                     stateStore.setPendingConfirmation(pending);
                     stateStore.appendLog(`Approval requested (${pending.source}): ${pending.commandPreview}`);
                     await queueWechatMessage(authorizedUserId, formatApprovalMessage(pending, adapterState), "approval_required");
-                });
+                }));
                 break;
             case "mirrored_user_input":
                 stateStore.appendLog(`mirrored_local_input: ${truncatePreview(event.text)}`);
                 if (shouldForwardBridgeEventToWechat(options.adapter, event.type, { text: event.text })) {
-                    void outputBatcher.flushNow().then(async () => {
+                    trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                         await queueWechatMessage(authorizedUserId, formatMirroredUserInputMessage(options.adapter, event.text), "mirrored_user_input");
-                    });
+                    }));
                 }
                 break;
             case "session_switched":
                 stateStore.appendLog(`session_switched: ${event.sessionId} source=${event.source} reason=${event.reason}`);
                 if (shouldForwardBridgeEventToWechat(options.adapter, event.type)) {
-                    void outputBatcher.flushNow().then(async () => {
+                    trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                         await queueWechatMessage(authorizedUserId, formatSessionSwitchMessage({
                             adapter: options.adapter,
                             sessionId: event.sessionId,
                             source: event.source,
                             reason: event.reason,
                         }), "session_switched");
-                    });
+                    }));
                 }
                 break;
             case "thread_switched":
                 stateStore.appendLog(`thread_switched: ${event.threadId} source=${event.source} reason=${event.reason}`);
                 if (shouldForwardBridgeEventToWechat(options.adapter, event.type)) {
-                    void outputBatcher.flushNow().then(async () => {
+                    trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                         await queueWechatMessage(authorizedUserId, formatSessionSwitchMessage({
                             adapter: options.adapter,
                             sessionId: event.threadId,
                             source: event.source,
                             reason: event.reason,
                         }), "thread_switched");
-                    });
+                    }));
                 }
                 void maybeDrainDeferredInboundMessages();
                 break;
             case "task_complete":
-                void outputBatcher.flushNow().then(async () => {
+                trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                     stateStore.clearPendingConfirmation();
                     if (options.adapter === "shell") {
                         const summary = buildCompletionSummary({
@@ -728,25 +798,25 @@ function wireAdapterEvents(params) {
                     }
                     clearActiveTask();
                     await maybeDrainDeferredInboundMessages();
-                });
+                }));
                 break;
             case "task_failed":
-                void outputBatcher.flushNow().then(async () => {
+                trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                     stateStore.clearPendingConfirmation();
                     clearActiveTask();
                     await queueWechatMessage(authorizedUserId, formatTaskFailedMessage(options.adapter, event.message), "task_failed");
                     await maybeDrainDeferredInboundMessages();
-                });
+                }));
                 break;
             case "fatal_error":
                 logError(event.message);
                 stateStore.appendLog(`fatal_error: ${event.message}`);
                 stateStore.clearPendingConfirmation();
                 clearActiveTask();
-                void outputBatcher.flushNow().then(async () => {
+                trackWechatForwardTask(outputBatcher.flushNow().then(async () => {
                     await queueWechatMessage(authorizedUserId, formatUserFacingBridgeFatalError(event.message), "fatal_error");
                     await maybeDrainDeferredInboundMessages();
-                });
+                }));
                 break;
             case "shutdown_requested":
                 stateStore.appendLog(`shutdown_requested: ${event.reason}`);
@@ -773,6 +843,7 @@ async function handleInboundMessage(params) {
     const systemCommand = parseWechatControlCommand(message.text, {
         adapter: options.adapter,
         hasPendingConfirmation: Boolean(state.pendingConfirmation),
+        hasPendingUserInput: Boolean(state.pendingUserInput),
     });
     if (message.senderId !== state.authorizedUserId) {
         await queueWechatMessage(message.senderId, "Unauthorized. This bridge only accepts messages from the configured WeChat owner.");
@@ -798,6 +869,19 @@ async function handleInboundMessage(params) {
             await queueWechatMessage(message.senderId, `/resume is not available in ${options.adapter} mode.`);
             return null;
         }
+        case "new_session": {
+            if (!adapter.createSession) {
+                await queueWechatMessage(message.senderId, `/new is not available in ${options.adapter} mode.`);
+                return null;
+            }
+            await outputBatcher.flushNow();
+            outputBatcher.clear();
+            stateStore.clearPendingConfirmation();
+            stateStore.clearSharedSessionId();
+            await adapter.createSession();
+            stateStore.appendLog(`New ${options.adapter} session requested by owner.`);
+            return null;
+        }
         case "stop": {
             const interrupted = await adapter.interrupt();
             await queueWechatMessage(message.senderId, interrupted