@wu529778790/open-im 1.10.9-beta.2 → 1.10.9-beta.21

package/dist/shared/ai-task.js

@@ -10,25 +10,65 @@ const log = createLogger('AITask');
 function isUsageLimitError(error) {
     return /usage limit/i.test(error) || /try again at\s+\d{1,2}:\d{2}\s*(AM|PM)/i.test(error);
 }
-function classifyErrorType(error) {
+/**
+ * 将 AI/CLI 错误文本归类为一个稳定的 errorType 字符串，用于遥测聚合。
+ * 分类基于线上真实错误签名（见 logs/r2-events），新增分支时同步更新测试。
+ */
+export function classifyErrorType(error) {
     const s = error.toLowerCase();
     if (s.includes('aborted'))
         return 'aborted';
+    // 空输出：流正常结束但无内容（claude-sdk-adapter 的兜底消息）
+    if (s.includes('无输出') || s.includes('响应异常结束') || s.includes('empty output')) {
+        return 'empty_output';
+    }
     if (isUsageLimitError(error) || s.includes('rate limit') || s.includes('quota'))
         return 'limit';
-    if (s.includes('invalid api key') || s.includes('unauthorized') || s.includes('401'))
+    // 鉴权：凭据无效或需要登录（含中文「登录」/「login」）
+    if (s.includes('invalid api key') ||
+        s.includes('unauthorized') ||
+        s.includes('401') ||
+        s.includes('need to log in') ||
+        s.includes('need to login') ||
+        s.includes('需要登录') ||
+        s.includes('需要先登录') ||
+        s.includes('log in required') ||
+        s.includes('login required')) {
         return 'auth';
+    }
     if (s.includes('model') && (s.includes('not support') || s.includes('not found') || s.includes('invalid'))) {
         return 'model';
     }
-    if (s.includes('process exited') || s.includes('exit code'))
+    // 安装/配置缺失：二进制或可执行文件缺失、环境变量缺失、token 未配置
+    if (s.includes('native cli binary') ||
+        s.includes('executable not found') ||
+        (s.includes('binary') && s.includes('not found')) ||
+        s.includes('missing environment variable') ||
+        s.includes('token data is not available')) {
+        return 'setup';
+    }
+    // 会话失效：找不到会话/对话，或会话过期/损坏
+    if (s.includes('no conversation found') ||
+        s.includes('session not found') ||
+        (s.includes('session') && (s.includes('expired') || s.includes('corrupt')))) {
+        return 'session';
+    }
+    // 进程退出或被信号终止
+    if (s.includes('process exited') ||
+        s.includes('exit code') ||
+        s.includes('exited with code') ||
+        s.includes('terminated by signal') ||
+        s.includes('sigkill')) {
         return 'process';
+    }
+    // 网络：超时/连接重置/DNS/网络请求失败（含中文「网络」）
     if (s.includes('timeout') ||
         s.includes('etimedout') ||
         s.includes('econnreset') ||
         s.includes('enotfound') ||
         s.includes('eai_again') ||
-        s.includes('network')) {
+        s.includes('network') ||
+        s.includes('网络')) {
         return 'network';
     }
     return 'unknown';
@@ -115,7 +155,7 @@ export function runAITask(deps, ctx, prompt, toolAdapter, platformAdapter) {
             log.info(`[AITask] Starting: userId=${ctx.userId}, initialSessionId=${currentSessionId ?? 'new'}, prompt="${prompt.slice(0, 50)}..."`);
             emitStructuredEvent('AITask', 'ai.task.start', {
                 platform: ctx.platform,
-                taskKey: ctx.taskKey,
+                taskKey: hashUserId(ctx.taskKey),
                 userKey: hashUserId(ctx.userId),
                 toolId: aiCommand,
             });
@@ -179,7 +219,7 @@ export function runAITask(deps, ctx, prompt, toolAdapter, platformAdapter) {
                         return;
                     emitStructuredEvent('AITask', 'ai.task.complete', {
                         platform: ctx.platform,
-                        taskKey: ctx.taskKey,
+                        taskKey: hashUserId(ctx.taskKey),
                         userKey: hashUserId(ctx.userId),
                         toolId: aiCommand,
                         durationMs: result.durationMs,
@@ -242,7 +282,7 @@ export function runAITask(deps, ctx, prompt, toolAdapter, platformAdapter) {
                     log.error(`Task error for user ${ctx.userId}: ${error}`);
                     emitStructuredEvent('AITask', 'ai.task.error', {
                         platform: ctx.platform,
-                        taskKey: ctx.taskKey,
+                        taskKey: hashUserId(ctx.taskKey),
                         userKey: hashUserId(ctx.userId),
                         toolId: aiCommand,
                         durationMs: Date.now() - taskState.startedAt,
@@ -290,13 +330,18 @@ export function runAITask(deps, ctx, prompt, toolAdapter, platformAdapter) {
                     if (!settled) {
                         emitStructuredEvent('AITask', 'ai.task.error', {
                             platform: ctx.platform,
-                            taskKey: ctx.taskKey,
+                            taskKey: hashUserId(ctx.taskKey),
                             userKey: hashUserId(ctx.userId),
                             toolId: aiCommand,
                             durationMs: Date.now() - taskState.startedAt,
                             errorSnippet: 'aborted',
                             errorType: 'aborted',
                         });
+                        // 用户取消（/new、/resume、队列超时、stale 清理）：把「思考中…」占位卡片编辑为终态，
+                        // 避免卡片卡在转圈。停按钮路径会先 settle() 再 abort，settled=true 时此处跳过，不会双发。
+                        void platformAdapter.sendError('⏹️ 已取消').catch(() => {
+                            /* 占位卡片可能已被删除或流过期，编辑失败可忽略 */
+                        });
                     }
                     activeHandle?.abort();
                     cleanup();
@@ -307,6 +352,9 @@ export function runAITask(deps, ctx, prompt, toolAdapter, platformAdapter) {
             settle,
             startedAt: Date.now(),
             toolId: aiCommand,
+            taskKey: hashUserId(ctx.taskKey),
+            platform: ctx.platform,
+            userKey: hashUserId(ctx.userId),
         };
         try {
             startRun();
@@ -318,7 +366,7 @@ export function runAITask(deps, ctx, prompt, toolAdapter, platformAdapter) {
                 log.error(`[AITask] Synchronous error in startRun: ${err}`);
                 emitStructuredEvent('AITask', 'ai.task.error', {
                     platform: ctx.platform,
-                    taskKey: ctx.taskKey,
+                    taskKey: hashUserId(ctx.taskKey),
                     userKey: hashUserId(ctx.userId),
                     toolId: aiCommand,
                     durationMs: 0,

package/dist/shared/process-kill.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 跨平台子进程树终止：用于 Codex / CodeBuddy CLI 子进程。
+ *
+ * 在 Unix 上子进程需以 `detached: true` 启动，使其成为独立进程组的组长；
+ * 这样 `process.kill(-pid)` 才能同时命中 CLI 及其派生的孙进程（MCP server、
+ * shell 工具调用等）。Windows 不支持负 PID 信号，改用 `taskkill /T /F`
+ * 按 PID 递归终止整棵进程树。
+ *
+ * 进程退出（shutdown / 崩溃）时，`destroyAllLiveChildren()` 会强制清理所有
+ * 仍在运行的被追踪子进程，避免僵尸 / 孤儿进程。
+ */
+import { type ChildProcess } from 'node:child_process';
+/** 追踪一个已 spawn 的子进程，使其在关停时能被强制终止。 */
+export declare function trackChild(child: ChildProcess): ChildProcess;
+/**
+ * 终止子进程及其所有后代。默认优雅：先 SIGTERM，`graceMs` 后升级为 SIGKILL。
+ * 传 `force: true` 则立即 SIGKILL（用于关停）。
+ */
+export declare function killProcessTree(child: ChildProcess, opts?: {
+    force?: boolean;
+    graceMs?: number;
+}): void;
+/** 强制终止所有仍在运行的被追踪子进程。关停 / 进程退出时调用。 */
+export declare function destroyAllLiveChildren(): void;

package/dist/shared/process-kill.js

@@ -0,0 +1,79 @@
+/**
+ * 跨平台子进程树终止：用于 Codex / CodeBuddy CLI 子进程。
+ *
+ * 在 Unix 上子进程需以 `detached: true` 启动，使其成为独立进程组的组长；
+ * 这样 `process.kill(-pid)` 才能同时命中 CLI 及其派生的孙进程（MCP server、
+ * shell 工具调用等）。Windows 不支持负 PID 信号，改用 `taskkill /T /F`
+ * 按 PID 递归终止整棵进程树。
+ *
+ * 进程退出（shutdown / 崩溃）时，`destroyAllLiveChildren()` 会强制清理所有
+ * 仍在运行的被追踪子进程，避免僵尸 / 孤儿进程。
+ */
+import { spawn } from 'node:child_process';
+import { createLogger } from '../logger.js';
+const log = createLogger('ProcessKill');
+/** 当前被追踪的存活子进程，供关停时强制清理。 */
+const liveChildren = new Set();
+/** 追踪一个已 spawn 的子进程，使其在关停时能被强制终止。 */
+export function trackChild(child) {
+    liveChildren.add(child);
+    child.once('close', () => liveChildren.delete(child));
+    return child;
+}
+/** 向整棵进程树发送信号：Unix 用负 PID（整组），Windows 用 taskkill /T /F。 */
+function signalTree(child, signal) {
+    const pid = child.pid;
+    if (pid == null)
+        return;
+    try {
+        if (process.platform === 'win32') {
+            // Windows 没有「优雅 SIGTERM」语义，统一 /T（递归） /F（强制）
+            const tk = spawn('taskkill', ['/pid', String(pid), '/T', '/F'], {
+                windowsHide: true,
+                stdio: 'ignore',
+            });
+            tk.unref();
+        }
+        else {
+            process.kill(-pid, signal);
+        }
+    }
+    catch (err) {
+        // ESRCH（已退出）或未 detached（无独立进程组）——退化为直接信号
+        try {
+            child.kill(signal);
+        }
+        catch {
+            /* 进程已退出，忽略 */
+        }
+        log.debug(`signalTree(${signal}) for pid=${pid} 退化为直杀: ${err.message}`);
+    }
+}
+/**
+ * 终止子进程及其所有后代。默认优雅：先 SIGTERM，`graceMs` 后升级为 SIGKILL。
+ * 传 `force: true` 则立即 SIGKILL（用于关停）。
+ */
+export function killProcessTree(child, opts = {}) {
+    const { force = false, graceMs = 5000 } = opts;
+    if (child.pid == null)
+        return;
+    if (force) {
+        signalTree(child, 'SIGKILL');
+        return;
+    }
+    signalTree(child, 'SIGTERM');
+    const escalate = setTimeout(() => signalTree(child, 'SIGKILL'), graceMs);
+    escalate.unref();
+}
+/** 强制终止所有仍在运行的被追踪子进程。关停 / 进程退出时调用。 */
+export function destroyAllLiveChildren() {
+    for (const child of [...liveChildren]) {
+        try {
+            signalTree(child, 'SIGKILL');
+        }
+        catch {
+            /* best effort */
+        }
+    }
+    liveChildren.clear();
+}

package/dist/shared/reconnect.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 重连韧性共享工具：抖动（jitter）+ 致命错误慢探测。
+ *
+ * 各平台长连接断开后各自重连，原本退避固定无抖动 → 车队重启会锁步重连风暴；
+ * 且致命（鉴权）错误也紧密/无限重试， hammer 网关。
+ *
+ * 策略（已与产品确认）：
+ * - 所有退避加 ±30% 抖动，避免锁步。
+ * - 鉴权类致命错误转为**慢探测**（每 5 分钟一次 + 显眼告警）：
+ *   既不紧密 hammer，也不永久断连（尊重 WeWork「避免永久断连」意图）。
+ */
+/** 慢探测间隔：致命错误后每 5 分钟探测一次。 */
+export declare const SLOW_PROBE_MS: number;
+/**
+ * 在 baseMs 上叠加 ±frac 的抖动，避免车队重启锁步重连。
+ * jitteredDelay(1000, 0.3) ∈ [700, 1300]。
+ */
+export declare function jitteredDelay(baseMs: number, frac?: number): number;
+/**
+ * 判断是否为「致命/不可重试」错误（凭据无效、鉴权失败）。
+ * 这类错误紧密重试无意义，应转慢探测。
+ */
+export declare function isFatalReconnectError(err: unknown): boolean;
+/**
+ * 计算重连延迟：致命慢探测模式下用 SLOW_PROBE_MS，否则用 jittered(base)。
+ * `fatal` 由调用方维护（致命时置 true，成功连上后置 false）。
+ */
+export declare function reconnectDelay(baseMs: number, fatal: boolean): number;

package/dist/shared/reconnect.js

@@ -0,0 +1,56 @@
+/**
+ * 重连韧性共享工具：抖动（jitter）+ 致命错误慢探测。
+ *
+ * 各平台长连接断开后各自重连，原本退避固定无抖动 → 车队重启会锁步重连风暴；
+ * 且致命（鉴权）错误也紧密/无限重试， hammer 网关。
+ *
+ * 策略（已与产品确认）：
+ * - 所有退避加 ±30% 抖动，避免锁步。
+ * - 鉴权类致命错误转为**慢探测**（每 5 分钟一次 + 显眼告警）：
+ *   既不紧密 hammer，也不永久断连（尊重 WeWork「避免永久断连」意图）。
+ */
+import { createLogger } from '../logger.js';
+const log = createLogger('Reconnect');
+/** 慢探测间隔：致命错误后每 5 分钟探测一次。 */
+export const SLOW_PROBE_MS = 5 * 60_000;
+/**
+ * 在 baseMs 上叠加 ±frac 的抖动，避免车队重启锁步重连。
+ * jitteredDelay(1000, 0.3) ∈ [700, 1300]。
+ */
+export function jitteredDelay(baseMs, frac = 0.3) {
+    if (baseMs <= 0)
+        return 0;
+    const jitter = baseMs * frac * (Math.random() * 2 - 1);
+    return Math.max(0, Math.round(baseMs + jitter));
+}
+/**
+ * 判断是否为「致命/不可重试」错误（凭据无效、鉴权失败）。
+ * 这类错误紧密重试无意义，应转慢探测。
+ */
+export function isFatalReconnectError(err) {
+    const msg = (err instanceof Error ? err.message : String(err)).toLowerCase();
+    if (msg.includes('401') || msg.includes('403'))
+        return true;
+    if (msg.includes('unauthorized') || msg.includes('forbidden'))
+        return true;
+    if (msg.includes('invalid signature'))
+        return true;
+    if (msg.includes('not subscribed'))
+        return true;
+    if (msg.includes('请重新登录') || msg.includes('需要重新登录') || msg.includes('token 已过期'))
+        return true;
+    if (msg.includes('invalid') && /token|secret|credential|appid|app_id|corp/.test(msg))
+        return true;
+    return false;
+}
+/**
+ * 计算重连延迟：致命慢探测模式下用 SLOW_PROBE_MS，否则用 jittered(base)。
+ * `fatal` 由调用方维护（致命时置 true，成功连上后置 false）。
+ */
+export function reconnectDelay(baseMs, fatal) {
+    if (fatal) {
+        log.warn(`致命错误，转慢探测（${Math.round(SLOW_PROBE_MS / 1000)}s 一次）`);
+        return jitteredDelay(SLOW_PROBE_MS);
+    }
+    return jitteredDelay(baseMs);
+}

package/dist/shared/task-cleanup.d.ts

@@ -6,3 +6,19 @@
  */
 import type { TaskRunState } from './ai-task.js';
 export declare function startTaskCleanup(runningTasks: Map<string, TaskRunState>): () => void;
+/**
+ * 在进程退出（优雅关闭 / 崩溃）路径上，为仍在运行的任务补发一条终态遥测事件。
+ *
+ * `runningTasks` 中存在的任务代表「已发出 ai.task.start 但尚未走到 complete/error」
+ * 的在途请求。正常流程会在 handle-ai-request 的 extraCleanup 里删除已结算任务，
+ * 因此进入这里时剩下的就是真正被进程退出打断的任务。
+ *
+ * 与用户主动 `/new`、队列超时触发的 `aborted` 区分，统一用 `interrupted` 标记。
+ * 补发后立即调用 state.settle() 置 settled=true：优雅关闭路径随后仍会调用
+ * handle.abort()（释放底层资源），但因已 settled，abort 不会再补发一条 aborted，
+ * 避免对同一任务重复计数。
+ *
+ * 该函数必须同步执行，且应在遥测刷盘（shutdownLoggerTelemetry）之前调用，
+ * 以保证补发的事件能进入上传队列。
+ */
+export declare function emitInterruptedTerminals(runningTasks: Map<string, TaskRunState>): void;

package/dist/shared/task-cleanup.js

@@ -4,7 +4,7 @@
  * Tasks older than 30 minutes are aborted and removed from the running-tasks
  * map so they never accumulate indefinitely.
  */
-import { createLogger } from '../logger.js';
+import { createLogger, emitStructuredEvent } from '../logger.js';
 const log = createLogger('TaskCleanup');
 const CLEANUP_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
 const STALE_THRESHOLD_MS = 30 * 60 * 1000; // 30 minutes
@@ -28,3 +28,36 @@ export function startTaskCleanup(runningTasks) {
     timer.unref();
     return () => clearInterval(timer);
 }
+/**
+ * 在进程退出（优雅关闭 / 崩溃）路径上，为仍在运行的任务补发一条终态遥测事件。
+ *
+ * `runningTasks` 中存在的任务代表「已发出 ai.task.start 但尚未走到 complete/error」
+ * 的在途请求。正常流程会在 handle-ai-request 的 extraCleanup 里删除已结算任务，
+ * 因此进入这里时剩下的就是真正被进程退出打断的任务。
+ *
+ * 与用户主动 `/new`、队列超时触发的 `aborted` 区分，统一用 `interrupted` 标记。
+ * 补发后立即调用 state.settle() 置 settled=true：优雅关闭路径随后仍会调用
+ * handle.abort()（释放底层资源），但因已 settled，abort 不会再补发一条 aborted，
+ * 避免对同一任务重复计数。
+ *
+ * 该函数必须同步执行，且应在遥测刷盘（shutdownLoggerTelemetry）之前调用，
+ * 以保证补发的事件能进入上传队列。
+ */
+export function emitInterruptedTerminals(runningTasks) {
+    if (runningTasks.size === 0)
+        return;
+    const now = Date.now();
+    for (const state of runningTasks.values()) {
+        emitStructuredEvent('AITask', 'ai.task.error', {
+            platform: state.platform,
+            taskKey: state.taskKey,
+            userKey: state.userKey,
+            toolId: state.toolId,
+            durationMs: now - state.startedAt,
+            errorSnippet: 'interrupted',
+            errorType: 'interrupted',
+        });
+        // 标记已结算，使随后 shutdown 的 abort() 跳过重复的 aborted 事件
+        state.settle();
+    }
+}

package/dist/telegram/client.js

@@ -1,5 +1,6 @@
 import { Telegraf } from "telegraf";
 import { createLogger } from "../logger.js";
+import { isFatalReconnectError, jitteredDelay } from "../shared/reconnect.js";
 const log = createLogger("Telegram");
 let bot;
 let botUsername;
@@ -32,8 +33,13 @@ export async function initTelegram(config, setupHandlers) {
             catch {
                 /* ignore */
             }
+            // 致命错误（token 无效等）：不再重试，避免烧满 10 次
+            if (isFatalReconnectError(err)) {
+                log.error("Telegram 致命错误，停止重连（请检查 bot token）:", err);
+                return;
+            }
             const maxAttempts = 10;
-            const delayMs = Math.min(5000 * attempt, 60000);
+            const delayMs = jitteredDelay(Math.min(5000 * attempt, 60000));
             if (attempt < maxAttempts) {
                 log.info(`Telegram reconnect in ${Math.round(delayMs / 1000)}s (attempt ${attempt}/${maxAttempts})`);
                 await new Promise((r) => setTimeout(r, delayMs));

package/dist/telemetry/telemetry-upload.js

@@ -190,7 +190,7 @@ export async function shutdownTelemetryUpload() {
     uploadEnabled = false;
     endpoint = undefined;
     bearer = undefined;
-    let lines = pending;
+    const lines = pending;
     while (lines.length > 0) {
         const batch = lines.splice(0, BATCH_MAX_LINES);
         try {

package/dist/wework/client.js

@@ -10,6 +10,7 @@
 import { WebSocket } from 'ws';
 import { randomBytes } from 'node:crypto';
 import { createLogger } from '../logger.js';
+import { jitteredDelay, SLOW_PROBE_MS, isFatalReconnectError } from '../shared/reconnect.js';
 const log = createLogger('WeWork');
 const DEFAULT_WS_URL = 'wss://openws.work.weixin.qq.com';
 const HEARTBEAT_INTERVAL = 30000; // 30秒
@@ -383,6 +384,8 @@ function stopHeartbeat() {
  * Schedule reconnection attempt
  * 超过 MAX_RECONNECT_ATTEMPTS 后自动重置计数器继续重试，避免永久断连
  */
+/** 致命（鉴权）错误后转慢探测，避免紧密 hammer 网关 */
+let fatalSlowProbe = false;
 function scheduleReconnect() {
     if (isStopping || !shouldReconnect) {
         return;
@@ -395,18 +398,27 @@ function scheduleReconnect() {
         log.warn(`Max reconnect attempts (${MAX_RECONNECT_ATTEMPTS}) reached, resetting counter and retrying at lower frequency`);
         reconnectAttempts = 0;
     }
-    // 逐步增加间隔，5s → 7.5s → 11s → ... 最大 60s
-    const backoff = Math.min(5000 * Math.pow(1.5, Math.floor(reconnectAttempts / 5)), 60000);
-    const interval = Math.round(backoff);
+    // 逐步增加间隔，5s → 7.5s → 11s → ... 最大 60s；致命（鉴权）错误转慢探测
+    const backoff = fatalSlowProbe
+        ? SLOW_PROBE_MS
+        : Math.min(5000 * Math.pow(1.5, Math.floor(reconnectAttempts / 5)), 60000);
+    const interval = jitteredDelay(Math.round(backoff));
     reconnectTimer = setTimeout(async () => {
         reconnectTimer = null;
         reconnectAttempts++;
-        log.info(`Reconnecting... Attempt ${reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS} (interval: ${interval}ms)`);
+        log.info(`Reconnecting... Attempt ${reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS} (interval: ${interval}ms${fatalSlowProbe ? ', slow-probe' : ''})`);
         try {
             await connectWebSocket();
+            fatalSlowProbe = false; // 连上后恢复正常退避
         }
         catch (err) {
-            log.error('Reconnection failed:', err);
+            if (isFatalReconnectError(err)) {
+                fatalSlowProbe = true;
+                log.warn('WeWork 致命错误（鉴权失败），转慢探测:', err);
+            }
+            else {
+                log.error('Reconnection failed:', err);
+            }
         }
     }, interval);
 }

package/dist/wework/event-handler.js

@@ -213,6 +213,9 @@ export function setupWeWorkHandlers(config, sessionManager) {
             const state = ctx.runningTasks.get(taskKey);
             if (state) {
                 log.warn(`[SAFETY_TIMEOUT] Task ${taskKey} exceeded ${WEWORK_TASK_SAFETY_TIMEOUT_MS}ms, aborting`);
+                // 先 settle 再 abort：settled=true 后 abort() 跳过自身的 sendError，由这里的 sendTextReply
+                // 兜底（企微流式消息可能已过期，文本兜底更稳），避免双重终态消息。
+                state.settle();
                 state.handle.abort();
                 ctx.runningTasks.delete(taskKey);
                 sendTextReply(chatId, `AI 处理超时（${Math.round(WEWORK_TASK_SAFETY_TIMEOUT_MS / 1000)}s），已自动取消。请重试。`, senderCtx.reqId).catch(() => { });

package/dist/workbuddy/centrifuge-client.d.ts

@@ -12,6 +12,10 @@ export interface CentrifugeClientConfig {
     userId: string;
     httpBaseUrl?: string;
     httpAccessToken?: string;
+    /** 返回当前有效的 access token（已刷新）。无则用 httpAccessToken 兜底。 */
+    getAccessToken?: () => string;
+    /** 单飞刷新 token；HTTP 401 时调用，刷新后 getAccessToken 返回新 token。 */
+    refreshToken?: () => Promise<void>;
     workspaceSessionId?: string;
     /**
      * Called before sending a WeChat KF reply to update the channel's channelId

package/dist/workbuddy/centrifuge-client.js

@@ -226,20 +226,50 @@ export class WorkBuddyCentrifugeClient {
             };
             const url = `${this.config.httpBaseUrl}/v2/backgroundagent/wecom/local-proxy/receive`;
             log.debug(`${this.logPrefix} HTTP COPILOT_RESPONSE → ${url} chatId=${sessionId} msgLen=${message.length}`);
-            // Retry COPILOT_RESPONSE up to 3 times on network failure
+            // Retry COPILOT_RESPONSE with exponential backoff for rate limits (95002)
+            const MAX_RETRIES = 5;
+            const INITIAL_BACKOFF_MS = 2000;
             let sent = false;
-            for (let attempt = 1; attempt <= 3; attempt++) {
+            let backoffMs = INITIAL_BACKOFF_MS;
+            let refreshedOn401 = false;
+            for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+                const token = this.config.getAccessToken?.() ?? this.config.httpAccessToken ?? '';
                 try {
                     const res = await fetch(url, {
                         method: 'POST',
                         headers: {
                             'Content-Type': 'application/json',
-                            Authorization: `Bearer ${this.config.httpAccessToken}`,
+                            Authorization: `Bearer ${token}`,
                         },
                         body: JSON.stringify(httpPayload),
                         signal: AbortSignal.timeout(30_000),
                     });
                     const body = await res.text().catch(() => '');
+                    // Check for WeChat KF rate limit (95002)
+                    if (body.includes('errcode=95002') || body.includes('"errcode":95002')) {
+                        if (attempt < MAX_RETRIES) {
+                            log.warn(`${this.logPrefix} HTTP COPILOT_RESPONSE rate limited (95002), attempt ${attempt}/${MAX_RETRIES}, retrying in ${backoffMs}ms`);
+                            await new Promise((r) => setTimeout(r, backoffMs));
+                            backoffMs = Math.min(backoffMs * 2, 60_000); // Cap at 60s
+                            continue;
+                        }
+                        else {
+                            log.error(`${this.logPrefix} HTTP COPILOT_RESPONSE rate limited after ${MAX_RETRIES} attempts, giving up`);
+                            break;
+                        }
+                    }
+                    // 401: access token 过期 → 单飞刷新后重试一次
+                    if (res.status === 401 && !refreshedOn401 && this.config.refreshToken) {
+                        refreshedOn401 = true;
+                        try {
+                            await this.config.refreshToken();
+                            log.info(`${this.logPrefix} Token refreshed on 401, retrying COPILOT_RESPONSE`);
+                            continue;
+                        }
+                        catch (refreshErr) {
+                            log.error(`${this.logPrefix} Token refresh failed on 401:`, refreshErr);
+                        }
+                    }
                     if (!res.ok) {
                         log.error(`${this.logPrefix} HTTP COPILOT_RESPONSE failed: ${res.status} ${body.substring(0, 300)}`);
                     }
@@ -250,17 +280,18 @@ export class WorkBuddyCentrifugeClient {
                     break;
                 }
                 catch (err) {
-                    if (attempt < 3) {
-                        log.warn(`${this.logPrefix} HTTP COPILOT_RESPONSE attempt ${attempt} failed, retrying in 2s:`, err);
-                        await new Promise((r) => setTimeout(r, 2000));
+                    if (attempt < MAX_RETRIES) {
+                        log.warn(`${this.logPrefix} HTTP COPILOT_RESPONSE attempt ${attempt} failed, retrying in ${backoffMs}ms:`, err);
+                        await new Promise((r) => setTimeout(r, backoffMs));
+                        backoffMs = Math.min(backoffMs * 2, 60_000);
                     }
                     else {
-                        log.error(`${this.logPrefix} HTTP COPILOT_RESPONSE error after 3 attempts:`, err);
+                        log.error(`${this.logPrefix} HTTP COPILOT_RESPONSE error after ${MAX_RETRIES} attempts:`, err);
                     }
                 }
             }
             if (!sent) {
-                this.enqueuePendingReply(url, httpPayload, this.config.httpAccessToken);
+                this.enqueuePendingReply(url, httpPayload);
             }
             // Release the heartbeat lock so the periodic registration can resume
             this.config.releaseChannelLockFn?.();
@@ -372,7 +403,7 @@ export class WorkBuddyCentrifugeClient {
     /**
      * Enqueue a failed reply for later delivery
      */
-    enqueuePendingReply(url, payload, accessToken) {
+    enqueuePendingReply(url, payload) {
         // Evict expired entries
         const now = Date.now();
         this.pendingReplies = this.pendingReplies.filter((r) => now - r.addedAt < PENDING_REPLY_TTL_MS);
@@ -380,7 +411,7 @@ export class WorkBuddyCentrifugeClient {
             const evicted = this.pendingReplies.shift();
             log.warn(`${this.logPrefix} Pending replies full, evicting oldest (msgId=${evicted?.payload.msgId})`);
         }
-        this.pendingReplies.push({ url, payload, accessToken, addedAt: now });
+        this.pendingReplies.push({ url, payload, addedAt: now });
         log.warn(`${this.logPrefix} Queued pending reply (queue=${this.pendingReplies.length}, msgId=${payload.msgId})`);
     }
     /**
@@ -398,27 +429,44 @@ export class WorkBuddyCentrifugeClient {
             log.info(`${this.logPrefix} Flushing ${toSend.length} pending reply(ies)`);
         }
         for (const reply of toSend) {
-            try {
-                const res = await fetch(reply.url, {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        Authorization: `Bearer ${reply.accessToken}`,
-                    },
-                    body: JSON.stringify(reply.payload),
-                    signal: AbortSignal.timeout(30_000),
-                });
-                const body = await res.text().catch(() => '');
-                if (res.ok) {
-                    log.info(`${this.logPrefix} Flushed pending reply ok: msgId=${reply.payload.msgId}`);
+            // 用当前（可能已刷新的）token；401 时单飞刷新后重试一次
+            let refreshedOn401 = false;
+            for (let attempt = 1; attempt <= 2; attempt++) {
+                const token = this.config.getAccessToken?.() ?? this.config.httpAccessToken ?? '';
+                try {
+                    const res = await fetch(reply.url, {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                            Authorization: `Bearer ${token}`,
+                        },
+                        body: JSON.stringify(reply.payload),
+                        signal: AbortSignal.timeout(30_000),
+                    });
+                    if (res.status === 401 && !refreshedOn401 && this.config.refreshToken) {
+                        refreshedOn401 = true;
+                        try {
+                            await this.config.refreshToken();
+                            continue;
+                        }
+                        catch {
+                            /* 刷新失败，落到下面正常判定 */
+                        }
+                    }
+                    const body = await res.text().catch(() => '');
+                    if (res.ok) {
+                        log.info(`${this.logPrefix} Flushed pending reply ok: msgId=${reply.payload.msgId}`);
+                    }
+                    else {
+                        log.error(`${this.logPrefix} Flushed pending reply failed: ${res.status} ${body.substring(0, 200)}`);
+                    }
+                    break;
                 }
-                else {
-                    log.error(`${this.logPrefix} Flushed pending reply failed: ${res.status} ${body.substring(0, 200)}`);
+                catch (err) {
+                    log.error(`${this.logPrefix} Flushed pending reply error: msgId=${reply.payload.msgId}`, err);
+                    break;
                 }
             }
-            catch (err) {
-                log.error(`${this.logPrefix} Flushed pending reply error: msgId=${reply.payload.msgId}`, err);
-            }
         }
         this.flushing = false;
     }