@wu529778790/open-im 1.10.9-beta.3 → 1.10.9-beta.4

package/dist/adapters/claude-sdk-adapter.js

@@ -49,6 +49,8 @@ loadUserPluginSettings();
 // 存储所有活跃的 SDKSession 对象，key 为 sessionId
 // 使用 Map 而不是 Set，因为我们需要通过 sessionId 获取 session
 const activeSessions = new Map();
+// 记录每个 session 创建/恢复时的 workDir，防止跨 workDir 复用已固定 cwd 的子进程
+const sessionWorkDirs = new Map();
 // 存储正在进行的流式迭代器，用于中断
 const activeStreams = new Set();
 // 空闲会话清理：跟踪最后使用时间，定期清除超时会话
@@ -92,34 +94,53 @@ const cleanupInterval = setInterval(() => {
                 activeSessions.delete(id);
             }
             sessionLastUsed.delete(id);
+            sessionWorkDirs.delete(id);
             log.info(`Cleaned up idle session (unused ${Math.round((now - lastUsed) / 60000)}min): ${id}`);
         }
     }
 }, CLEANUP_INTERVAL_MS);
 cleanupInterval.unref(); // 不阻止进程退出
 /**
- * Serializes process.chdir() calls across concurrent users.
+ * 串行化进程级 process.chdir() —— 同一时刻仅一个 chdir 生效。
  *
- * process.chdir() is a process-wide global side effect — only one chdir can
- * be active at a time. The SDK's createSession/resumeSession do not accept a
- * `cwd` parameter, so we must chdir before calling them. This mutex ensures
- * concurrent requests don't race on the working directory.
+ * SDK V2 的 createSession/resumeSession 不接受 cwd 参数；且 send()/stream()
+ * 会以「调用时的 process.cwd()」派生 Claude Code 子进程。必须用互斥锁串行化
+ * 「整个 turn 的 cwd 切换」，否则并发多用户会让工具跑错目录。
  *
- * **TODO:** Remove this mutex entirely once @anthropic-ai/claude-agent-sdk
- * supports a `cwd` option in createSession/resumeSession. Track upstream:
+ * **TODO:** SDK 支持 cwd 选项后移除此锁。upstream:
  * https://github.com/anthropics/claude-agent-sdk/issues
  */
 let chdirMutex = Promise.resolve();
 function withChdirMutex(fn) {
     const previous = chdirMutex;
-    let resolve;
-    chdirMutex = new Promise((r) => { resolve = r; });
-    return previous.then(() => {
+    let release;
+    chdirMutex = new Promise((r) => { release = r; });
+    return previous.then(async () => {
         try {
-            return fn();
+            return await fn();
         }
         finally {
-            resolve();
+            release();
+        }
+    });
+}
+/**
+ * 在持有全局 chdir 互斥锁期间，把进程 cwd 切到 workDir 执行 fn，结束后恢复。
+ * 用于包裹 session.send()+stream()，确保子进程在正确 workDir 派生。
+ */
+function runWithWorkDir(workDir, fn) {
+    return withChdirMutex(async () => {
+        const originalCwd = process.cwd();
+        if (workDir && workDir !== originalCwd) {
+            process.chdir(workDir);
+        }
+        try {
+            return await fn();
+        }
+        finally {
+            if (workDir && workDir !== originalCwd) {
+                process.chdir(originalCwd);
+            }
         }
     });
 }
@@ -201,18 +222,21 @@ async function getOrCreateSession(sessionId, workDir, model, permissionMode, onS
                 process.chdir(workDir);
             }
             if (sessionId) {
-                // 优先复用内存中已有的 SDKSession，避免每次都启动新进程
+                // 优先复用内存中已有的 SDKSession，避免每次都启动新进程。
+                // 仅当 workDir 与创建时一致才复用：否则子进程 cwd 已固定在旧目录，
+                // 需走 resume 重新派生（在当前 workDir 启动新子进程）。
                 const existing = activeSessions.get(sessionId);
-                if (existing) {
+                if (existing && sessionWorkDirs.get(sessionId) === workDir) {
                     log.info(`Reusing existing in-memory session: ${sessionId}`);
                     sessionLastUsed.set(sessionId, Date.now());
                     return { session: existing, sessionId };
                 }
-                // 内存中没有，尝试通过 resume 恢复（会启动新 CLI 进程）
+                // 内存中没有（或 workDir 变了），尝试通过 resume 恢复（会启动新 CLI 进程）
                 try {
                     log.info(`Attempting to resume session: ${sessionId}`);
                     session = unstable_v2_resumeSession(sessionId, sessionOptions);
                     activeSessions.set(sessionId, session);
+                    sessionWorkDirs.set(sessionId, workDir);
                     sessionLastUsed.set(sessionId, Date.now());
                     log.info(`Successfully resumed session: ${sessionId}`);
                     return { session, sessionId };
@@ -228,6 +252,7 @@ async function getOrCreateSession(sessionId, workDir, model, permissionMode, onS
             // 暂时返回 undefined，稍后在 init 消息中获取
             const tempId = `pending-${++sessionSeq}`;
             activeSessions.set(tempId, session);
+            sessionWorkDirs.set(tempId, workDir);
             sessionLastUsed.set(tempId, Date.now());
             log.info(`Created new session (tempId: ${tempId})`);
             return { session, sessionId: tempId, wasReused: false };
@@ -267,6 +292,7 @@ export class ClaudeSDKAdapter {
         }
         activeSessions.clear();
         sessionLastUsed.clear();
+        sessionWorkDirs.clear();
     }
     /**
      * Remove a specific session from the in-memory cache and close it.
@@ -281,6 +307,7 @@ export class ClaudeSDKAdapter {
             catch { /* ignore */ }
             activeSessions.delete(sessionId);
             sessionLastUsed.delete(sessionId);
+            sessionWorkDirs.delete(sessionId);
             log.info(`Explicitly removed session: ${sessionId}`);
         }
     }
@@ -320,12 +347,16 @@ export class ClaudeSDKAdapter {
                 }
                 runningSessions.add(returnedId);
                 trackedRunningId = returnedId;
-                // 发送用户消息
-                await session.send(prompt);
-                // 获取响应流
-                const stream = session.stream();
-                currentStream = stream;
-                activeStreams.add(stream);
+                // 在持有 chdir 锁期间完成 send() + stream() 获取：SDK V2 会以当前
+                // process.cwd() 派生 Claude Code 子进程，必须保证此刻 cwd 为 workDir。
+                // 锁串行化后，并发多用户的子进程不会在错误的目录派生。
+                const stream = await runWithWorkDir(workDir, async () => {
+                    await session.send(prompt);
+                    const s = session.stream();
+                    currentStream = s;
+                    activeStreams.add(s);
+                    return s;
+                });
                 let accumulated = '';
                 let accumulatedThinking = '';
                 const toolStats = {};
@@ -348,13 +379,19 @@ export class ClaudeSDKAdapter {
                                 // 更新 sessionId 映射
                                 // 清理 pending 临时 ID（actualSessionId 尚未赋值时用 pendingTempId）
                                 const idToClean = actualSessionId ?? pendingTempId;
+                                const inheritedWorkDir = idToClean ? sessionWorkDirs.get(idToClean) : undefined;
                                 if (idToClean?.startsWith('pending-')) {
                                     activeSessions.delete(idToClean);
                                 }
                                 activeSessions.set(newSessionId, session);
+                                if (inheritedWorkDir !== undefined) {
+                                    sessionWorkDirs.set(newSessionId, inheritedWorkDir);
+                                }
                                 sessionLastUsed.set(newSessionId, Date.now());
-                                if (idToClean)
+                                if (idToClean) {
                                     sessionLastUsed.delete(idToClean);
+                                    sessionWorkDirs.delete(idToClean);
+                                }
                                 // 更新 runningSessions：移除旧 ID，添加新 ID
                                 if (idToClean)
                                     runningSessions.delete(idToClean);

package/dist/adapters/registry.js

@@ -3,6 +3,7 @@ import { ClaudeSDKAdapter, configureClaudeSdkSessionIdle } from './claude-sdk-ad
 import { CodexAdapter } from './codex-adapter.js';
 import { CodeBuddyAdapter } from './codebuddy-adapter.js';
 import { createLogger } from '../logger.js';
+import { destroyAllLiveChildren } from '../shared/process-kill.js';
 const log = createLogger('Registry');
 const adapters = new Map();
 export function initAdapters(config) {
@@ -30,5 +31,7 @@ export function getAdapter(aiCommand) {
 }
 export function cleanupAdapters() {
     ClaudeSDKAdapter.destroy();
+    // 强制终止仍在运行的 CLI 子进程（Codex/CodeBuddy），避免僵尸 / 孤儿
+    destroyAllLiveChildren();
     adapters.clear();
 }

package/dist/codebuddy/cli-runner.js

@@ -3,6 +3,7 @@ import { accessSync, constants } from 'node:fs';
 import { isAbsolute, join } from 'node:path';
 import { createLogger } from '../logger.js';
 import { processEnvForNonClaudeCliChild } from '../config/file-io.js';
+import { killProcessTree, trackChild } from '../shared/process-kill.js';
 const log = createLogger('CodeBuddyCli');
 export function buildCodeBuddyArgs(prompt, sessionId, options) {
     const args = ['--print', '--output-format', 'stream-json'];
@@ -200,10 +201,14 @@ export function runCodeBuddy(cliPath, prompt, sessionId, workDir, callbacks, opt
     log.info(`Spawning CodeBuddy CLI: path=${normalizedCliPath}, cwd=${workDir}, session=${sessionId ?? 'new'}, args=${args.join(' ')}`);
     const child = spawn(spawnCmd, spawnArgs, {
         cwd: workDir,
+        // Unix 上放入独立进程组，使 abort/关停能用 process.kill(-pid) 杀掉整棵子树（含 MCP/shell 孙进程）
+        detached: process.platform !== 'win32',
         stdio: ['ignore', 'pipe', 'pipe'],
         env,
         windowsHide: process.platform === 'win32',
     });
+    trackChild(child);
+    let cliTimeoutHandle = null;
     let accumulated = '';
     let accumulatedThinking = '';
     let completed = false;
@@ -311,6 +316,10 @@ export function runCodeBuddy(cliPath, prompt, sessionId, workDir, callbacks, opt
         }
     });
     child.on('close', (code) => {
+        if (cliTimeoutHandle) {
+            clearTimeout(cliTimeoutHandle);
+            cliTimeoutHandle = null;
+        }
         if (completed)
             return;
         if (stdoutState.buffer.trim()) {
@@ -343,16 +352,36 @@ export function runCodeBuddy(cliPath, prompt, sessionId, workDir, callbacks, opt
         });
     });
     child.on('error', (err) => {
+        if (cliTimeoutHandle) {
+            clearTimeout(cliTimeoutHandle);
+            cliTimeoutHandle = null;
+        }
         if (completed)
             return;
         completed = true;
         callbacks.onError(`Failed to start CodeBuddy CLI: ${err.message}`);
     });
+    // 墙钟超时：防止 CLI 挂死永久占用用户队列槽
+    const cliTimeoutMs = Number(process.env.OPEN_IM_CLI_TIMEOUT_MS) || 30 * 60 * 1000;
+    cliTimeoutHandle = setTimeout(() => {
+        if (completed)
+            return;
+        log.warn(`CodeBuddy CLI 超过 ${cliTimeoutMs}ms，强制终止 (pid=${child.pid})`);
+        completed = true;
+        killProcessTree(child);
+        callbacks.onError(`CodeBuddy CLI 运行超时（${Math.round(cliTimeoutMs / 1000)}s），已终止。请重试。`);
+    }, cliTimeoutMs);
+    cliTimeoutHandle.unref();
     return {
         abort: () => {
+            if (completed)
+                return;
             completed = true;
-            if (!child.killed)
-                child.kill('SIGTERM');
+            if (cliTimeoutHandle) {
+                clearTimeout(cliTimeoutHandle);
+                cliTimeoutHandle = null;
+            }
+            killProcessTree(child);
         },
     };
 }

package/dist/codex/cli-runner.js

@@ -7,6 +7,7 @@ import { dirname, join } from 'node:path';
 import { createInterface } from 'node:readline';
 import { createLogger } from '../logger.js';
 import { processEnvForNonClaudeCliChild } from '../config/file-io.js';
+import { killProcessTree, trackChild } from '../shared/process-kill.js';
 const log = createLogger('CodexCli');
 const windowsCodexLaunchCache = new Map();
 const SUPPORTED_IMAGE_EXTENSIONS = new Set([
@@ -201,10 +202,13 @@ export function runCodex(cliPath, prompt, sessionId, workDir, callbacks, options
             : args;
     const child = spawn(spawnCmd, spawnArgs, {
         cwd: workDir,
+        // Unix 上放入独立进程组，使 abort/关停能用 process.kill(-pid) 杀掉整棵子树（含 MCP/shell 孙进程）
+        detached: process.platform !== 'win32',
         stdio: ['pipe', 'pipe', 'pipe'],
         env,
         windowsHide: process.platform === 'win32',
     });
+    trackChild(child);
     child.stdin?.write(prompt);
     child.stdin?.end();
     let accumulated = '';
@@ -327,7 +331,12 @@ export function runCodex(cliPath, prompt, sessionId, workDir, callbacks, options
     let exitCode = null;
     let rlClosed = false;
     let childClosed = false;
+    let cliTimeoutHandle = null;
     const finalize = () => {
+        if (cliTimeoutHandle) {
+            clearTimeout(cliTimeoutHandle);
+            cliTimeoutHandle = null;
+        }
         if (!rlClosed || !childClosed)
             return;
         if (completed)
@@ -387,12 +396,29 @@ export function runCodex(cliPath, prompt, sessionId, workDir, callbacks, options
         childClosed = true;
         finalize();
     });
+    // 墙钟超时：防止 CLI 挂死（网络卡住、工具死循环等）永久占用用户队列槽
+    const cliTimeoutMs = Number(process.env.OPEN_IM_CLI_TIMEOUT_MS) || 30 * 60 * 1000;
+    cliTimeoutHandle = setTimeout(() => {
+        if (completed)
+            return;
+        log.warn(`Codex CLI 超过 ${cliTimeoutMs}ms，强制终止 (pid=${child.pid})`);
+        completed = true;
+        rl.close();
+        killProcessTree(child);
+        callbacks.onError(`Codex CLI 运行超时（${Math.round(cliTimeoutMs / 1000)}s），已终止。请重试。`);
+    }, cliTimeoutMs);
+    cliTimeoutHandle.unref();
     return {
         abort: () => {
+            if (completed)
+                return;
             completed = true;
+            if (cliTimeoutHandle) {
+                clearTimeout(cliTimeoutHandle);
+                cliTimeoutHandle = null;
+            }
             rl.close();
-            if (!child.killed)
-                child.kill('SIGTERM');
+            killProcessTree(child);
         },
     };
 }

package/dist/dingtalk/client.js

@@ -1,5 +1,6 @@
 import { DWClient, TOPIC_ROBOT } from 'dingtalk-stream';
 import { createLogger } from '../logger.js';
+import { jitteredDelay } from '../shared/reconnect.js';
 import { registerSessionWebhook as registerWebhook, clearWebhooks, sendText as webhookSendText, sendMarkdown as webhookSendMarkdown, downloadRobotMessageFile as webhookDownloadFile, sendProactiveText as webhookSendProactive, } from './webhook.js';
 import { prepareStreamingCard as cardPrepare, updateStreamingCard as cardUpdate, finishStreamingCard as cardFinish, createAndDeliverCard as cardCreateAndDeliver, updateCardInstance as cardUpdateInstance, sendRobotInteractiveCard as cardSendInteractive, updateRobotInteractiveCard as cardUpdateInteractive, clearUnionIdCache, } from './streaming-card.js';
 const log = createLogger('DingTalk');
@@ -111,7 +112,7 @@ export async function initDingTalk(cfg, eventHandler) {
             lastErr = err;
             if (is429(err) && attempt < maxTries) {
                 log.warn(`DingTalk gateway 429 (attempt ${attempt}/${maxTries}), retrying in ${retryDelayMs / 1000}s...`);
-                await new Promise((r) => setTimeout(r, retryDelayMs));
+                await new Promise((r) => setTimeout(r, jitteredDelay(retryDelayMs)));
                 continue;
             }
             throw new Error(formatDingTalkInitError(err));

package/dist/dingtalk/event-handler.js

@@ -163,7 +163,7 @@ export function setupDingTalkHandlers(config, sessionManager) {
         sessionManager,
         sender: { sendTextReply, sendDirectorySelection },
     });
-    const { accessControl, requestQueue, runningTasks, commandHandler } = ctx;
+    const { accessControl, requestQueue, runningTasks } = ctx;
     // DingTalk-specific sender callbacks for the factory
     const dingtalkSender = {
         sendThinkingMessage: async (chatId, replyToMessageId, toolId) => {

package/dist/index.js

@@ -27,11 +27,13 @@ import { sendTextReply as sendWorkBuddyTextReply } from "./workbuddy/message-sen
 import { initAdapters, cleanupAdapters } from "./adapters/registry.js";
 import { SessionManager } from "./session/session-manager.js";
 import { loadActiveChats, getActiveChatId, flushActiveChats, } from "./shared/active-chats.js";
+import { destroyAllLiveChildren } from "./shared/process-kill.js";
 import { initLogger, createLogger, closeLogger, emitStructuredEvent, shutdownLoggerTelemetry, } from "./logger.js";
 import { APP_HOME, SHUTDOWN_PORT } from "./constants.js";
 import { createRequire } from "node:module";
 import { escapePathForMarkdown } from "./shared/utils.js";
 import { applyOpenImGitCoauthorToProcessEnv } from "./shared/git-coauthor.js";
+import { emitInterruptedTerminals } from "./shared/task-cleanup.js";
 const require = createRequire(import.meta.url);
 const { version: APP_VERSION } = require("../package.json");
 const log = createLogger("Main");
@@ -262,6 +264,15 @@ export async function main() {
         const uptimeSec = Math.floor((Date.now() - startedAt) / 1000);
         const m = Math.floor(uptimeSec / 60);
         const shutdownMsg = buildShutdownMessage(m);
+        // 在任何异步等待之前，先为仍在运行的任务补发终态遥测事件。
+        // 这样即使后续 await（通知发送、platform.stop）期间进程被第二次信号杀死，
+        // ai.task.start 也有对应的 interrupted 终态，避免遥测里的 miss。
+        for (const platform of successfulPlatforms) {
+            const handle = activeHandles.get(platform);
+            if (handle?.runningTasks && handle.runningTasks.size > 0) {
+                emitInterruptedTerminals(handle.runningTasks);
+            }
+        }
         // Send notification only to successfully initialized platforms
         for (const platform of successfulPlatforms) {
             await sendLifecycleNotification(platform, shutdownMsg).catch((err) => {
@@ -299,6 +310,16 @@ export async function main() {
     };
     process.on("SIGINT", () => shutdown().catch(() => process.exit(1)));
     process.on("SIGTERM", () => shutdown().catch(() => process.exit(1)));
+    // 兜底：进程退出（含异常路径，如未捕获异常 / SIGKILL）时强制清理 CLI 子进程，
+    // 避免僵尸 / 孤儿。正常 shutdown 已在 cleanupAdapters() 里清理过。
+    process.on("exit", () => {
+        try {
+            destroyAllLiveChildren();
+        }
+        catch {
+            /* 退出期间 best effort */
+        }
+    });
     // Global error handlers to prevent unhandled crashes
     process.on("unhandledRejection", (reason) => {
         log.error("Unhandled Promise rejection (this indicates a bug — the affected request may hang without a response):", reason);
@@ -312,6 +333,18 @@ export async function main() {
             return;
         }
         log.error("Uncaught exception (process will exit):", err);
+        // 进程即将因未捕获异常退出：补发在途任务的终态，避免 miss
+        for (const platform of successfulPlatforms) {
+            const handle = activeHandles.get(platform);
+            if (handle?.runningTasks && handle.runningTasks.size > 0) {
+                try {
+                    emitInterruptedTerminals(handle.runningTasks);
+                }
+                catch {
+                    /* best effort：不能因遥测失败再次抛出 */
+                }
+            }
+        }
         void shutdownLoggerTelemetry()
             .then(() => closeLogger())
             .finally(() => process.exit(1));

package/dist/qq/client.js

@@ -1,5 +1,6 @@
 import WebSocket from "ws";
 import { createLogger } from "../logger.js";
+import { jitteredDelay, SLOW_PROBE_MS } from "../shared/reconnect.js";
 const log = createLogger("QQ");
 const TOKEN_URL = "https://bots.qq.com/app/getAppAccessToken";
 const API_BASE = "https://api.sgroup.qq.com";
@@ -271,7 +272,12 @@ async function connectWebSocket(config, handler) {
                     sessionId = null;
                     seq = null;
                 }
-                const delay = RECONNECT_DELAYS_MS[Math.min(reconnectAttempt, RECONNECT_DELAYS_MS.length - 1)];
+                const isFatalClose = code === 4004 || code === 4006 || code === 4007;
+                const baseDelay = RECONNECT_DELAYS_MS[Math.min(reconnectAttempt, RECONNECT_DELAYS_MS.length - 1)];
+                const delay = isFatalClose ? jitteredDelay(SLOW_PROBE_MS) : jitteredDelay(baseDelay);
+                if (isFatalClose) {
+                    log.warn(`QQ 致命关闭码 ${code}（鉴权失败），转慢探测（每 ${Math.round(SLOW_PROBE_MS / 1000)}s 一次）`);
+                }
                 reconnectAttempt += 1;
                 reconnectTimer = setTimeout(() => {
                     if (currentConfig && currentHandler) {

package/dist/queue/request-queue.js

@@ -80,17 +80,18 @@ export class RequestQueue {
         finally {
             this.runningControllers.delete(key);
             const q = this.queues.get(key);
-            if (!q)
-                return;
-            const next = q.tasks.shift();
-            if (next) {
-                setImmediate(() => this.run(key, next.prompt, next.execute).catch((err) => {
-                    log.error(`Unhandled error in next task execution for ${key}:`, err);
-                }));
-            }
+            if (!q) { /* queue already cleared */ }
             else {
-                q.running = false;
-                this.queues.delete(key);
+                const next = q.tasks.shift();
+                if (next) {
+                    setImmediate(() => this.run(key, next.prompt, next.execute).catch((err) => {
+                        log.error(`Unhandled error in next task execution for ${key}:`, err);
+                    }));
+                }
+                else {
+                    q.running = false;
+                    this.queues.delete(key);
+                }
             }
         }
     }

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

@@ -42,5 +42,19 @@ export interface TaskRunState {
     startedAt: number;
     /** AI 工具标识，用于动态显示工具名称。 */
     toolId: string;
+    /**
+     * 进程退出（shutdown / 崩溃）时，用于为仍在运行的任务补发一条终态遥测事件，
+     * 避免 `ai.task.start` 没有对应的 complete/error（遥测里的 `miss`）。
+     * 已哈希（与 ai.task.* emit 处一致），不含原始 userId/msgId。
+     */
+    taskKey: string;
+    platform: string;
+    /** 已哈希的 userId，与 ai.task.start/complete/error 中的 userKey 一致。 */
+    userKey: string;
 }
+/**
+ * 将 AI/CLI 错误文本归类为一个稳定的 errorType 字符串，用于遥测聚合。
+ * 分类基于线上真实错误签名（见 logs/r2-events），新增分支时同步更新测试。
+ */
+export declare function classifyErrorType(error: string): string;
 export declare function runAITask(deps: TaskDeps, ctx: TaskContext, prompt: string, toolAdapter: ToolAdapter, platformAdapter: TaskAdapter): Promise<void>;

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;
     }

package/dist/workbuddy/client.js

@@ -9,6 +9,7 @@ import { existsSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { hostname, homedir } from 'node:os';
 import { createLogger } from '../logger.js';
+import { jitteredDelay, SLOW_PROBE_MS, isFatalReconnectError } from '../shared/reconnect.js';
 import { WorkBuddyOAuth } from './oauth.js';
 import { WorkBuddyCentrifugeClient } from './centrifuge-client.js';
 const log = createLogger('WorkBuddy');
@@ -23,8 +24,11 @@ let stateChangeHandler = null;
 let heartbeatTimer = null;
 let reconnectTimer = null;
 let reconnectAttempt = 0;
+let fatalSlowProbe = false;
 let stopped = false;
 let platformConfig = null;
+/** 单飞刷新 token 的在途 Promise，避免并发 401 重复刷新 */
+let refreshInFlight = null;
 export function getChannelState() {
     return channelState;
 }
@@ -78,6 +82,10 @@ async function connect() {
     }
     catch (err) {
         log.error('Host workspace registration failed:', err);
+        if (isFatalReconnectError(err)) {
+            fatalSlowProbe = true;
+            log.warn('WorkBuddy 致命错误（鉴权失败），转慢探测（token 可能已过期）:', err);
+        }
         scheduleReconnect();
         return;
     }
@@ -120,6 +128,8 @@ async function connect() {
         userId: pc.userId ?? '',
         httpBaseUrl: baseUrl,
         httpAccessToken: pc.accessToken ?? '',
+        getAccessToken: () => oauthClient?.accessToken ?? pc.accessToken ?? '',
+        refreshToken: refreshWorkBuddyToken,
         workspaceSessionId,
         registerChannelFn,
         releaseChannelLockFn,
@@ -128,6 +138,7 @@ async function connect() {
             log.info('WorkBuddy Centrifuge connected');
             log.info(`WeChat KF sessionId: ${workspaceSessionId}`);
             reconnectAttempt = 0;
+            fatalSlowProbe = false;
             updateState('connected');
             // Step 2: Register Claw workspace to get WeChat KF routing channel + sessionId
             oauth.registerWorkspace({
@@ -234,9 +245,10 @@ function scheduleReconnect() {
         clearTimeout(reconnectTimer);
         reconnectTimer = null;
     }
-    const delay = RECONNECT_DELAYS_MS[Math.min(reconnectAttempt, RECONNECT_DELAYS_MS.length - 1)];
+    const baseDelay = RECONNECT_DELAYS_MS[Math.min(reconnectAttempt, RECONNECT_DELAYS_MS.length - 1)];
+    const delay = fatalSlowProbe ? jitteredDelay(SLOW_PROBE_MS) : jitteredDelay(baseDelay);
     reconnectAttempt++;
-    log.info(`Reconnecting in ${delay}ms (attempt ${reconnectAttempt})...`);
+    log.info(`Reconnecting in ${delay}ms (attempt ${reconnectAttempt})${fatalSlowProbe ? ' [slow-probe]' : ''}...`);
     reconnectTimer = setTimeout(async () => {
         reconnectTimer = null;
         if (stopped)
@@ -261,6 +273,31 @@ export function getCentrifugeClient() {
 export function getOAuth() {
     return oauthClient;
 }
+/**
+ * 单飞刷新 WorkBuddy access token：并发 401 只触发一次刷新，复用同一 Promise。
+ * 刷新成功后 oauthClient.accessToken 原地更新，所有 HTTP 调用（含心跳）自动用新 token。
+ */
+async function refreshWorkBuddyToken() {
+    if (!oauthClient)
+        return;
+    if (refreshInFlight)
+        return refreshInFlight;
+    refreshInFlight = (async () => {
+        try {
+            log.info('Refreshing WorkBuddy access token...');
+            await oauthClient.refreshTokenAuth();
+            log.info('WorkBuddy access token refreshed');
+        }
+        catch (err) {
+            log.error('WorkBuddy token refresh failed:', err);
+            throw err;
+        }
+        finally {
+            refreshInFlight = null;
+        }
+    })();
+    return refreshInFlight;
+}
 export function stopWorkBuddy() {
     log.info('Stopping WorkBuddy client...');
     stopped = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wu529778790/open-im",
-  "version": "1.10.9-beta.3",
+  "version": "1.10.9-beta.4",
   "description": "Multi-platform IM bridge for AI CLI tools (Claude, Codex, CodeBuddy)",
   "type": "module",
   "main": "dist/index.js",