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

package/README.md

@@ -4,6 +4,10 @@
 
 Multi-platform IM bridge for AI CLI tools. Connect Telegram, Feishu, WeCom, DingTalk, QQ, and WeChat (WorkBuddy) to Claude Code, Codex, and CodeBuddy — use your AI coding assistant from any phone or chat window.
 
+## Architecture
+
+![Open-IM Architecture](./diagram/architecture/open-im-architecture.svg)
+
 ## Features
 
 - **Six IM platforms** — Telegram, Feishu, WeCom, DingTalk, QQ, WorkBuddy

package/README.zh-CN.md

@@ -4,6 +4,10 @@
 
 多平台 IM 桥接：把 Telegram、飞书、企业微信、钉钉、QQ、微信（WorkBuddy）接到 Claude Code、Codex、CodeBuddy，在手机或聊天里使用 AI 编程助手。
 
+## 架构
+
+![Open-IM 架构图](./diagram/architecture/open-im-architecture.svg)
+
 ## 功能特性
 
 - **六个 IM 平台** — Telegram、飞书、企业微信、钉钉、QQ、WorkBuddy

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/config/file-io.d.ts

@@ -19,8 +19,11 @@ export declare function getClaudeSdkRuntimeIssue(): string | null;
 export declare function parseCommaSeparated(value: string): string[];
 /**
  * 将最新的 Claude 认证环境变量按优先级合并到 process.env。
- * 优先级：shell 环境变量 > ~/.open-im/config.json 的 tools.claude.env >
- * 本机 Claude 配置（~/.claude/settings.json，与 Claude Code 共用）。
- * 多数用户只维护本机 settings；每次创建 Claude SDK 会话前调用，本机文件变更后下次会话即生效。
+ * 优先级：shell 环境变量 > 本机 Claude 配置（~/.claude/settings.json，与 Claude Code 共用）>
+ * ~/.open-im/config.json 的 tools.claude.env。
+ *
+ * 设计意图：用户只需维护 ~/.claude/settings.json（与 Claude Code CLI 共用），
+ * open-im 自动跟随本地 Claude 配置，无需单独配置。config.json 的 tools.claude.env
+ * 仅作为兜底，供没有本地 Claude 安装的场景使用。
  */
 export declare function refreshClaudeEnvToProcess(): void;

package/dist/config/file-io.js

@@ -350,9 +350,12 @@ export function parseCommaSeparated(value) {
 }
 /**
  * 将最新的 Claude 认证环境变量按优先级合并到 process.env。
- * 优先级：shell 环境变量 > ~/.open-im/config.json 的 tools.claude.env >
- * 本机 Claude 配置（~/.claude/settings.json，与 Claude Code 共用）。
- * 多数用户只维护本机 settings；每次创建 Claude SDK 会话前调用，本机文件变更后下次会话即生效。
+ * 优先级：shell 环境变量 > 本机 Claude 配置（~/.claude/settings.json，与 Claude Code 共用）>
+ * ~/.open-im/config.json 的 tools.claude.env。
+ *
+ * 设计意图：用户只需维护 ~/.claude/settings.json（与 Claude Code CLI 共用），
+ * open-im 自动跟随本地 Claude 配置，无需单独配置。config.json 的 tools.claude.env
+ * 仅作为兜底，供没有本地 Claude 安装的场景使用。
  */
 export function refreshClaudeEnvToProcess() {
     const file = loadFileConfig();
@@ -363,14 +366,16 @@ export function refreshClaudeEnvToProcess() {
             process.env[key] = originalShellEnv[key];
             continue;
         }
-        if (key in claudeToolEnv) {
-            process.env[key] = claudeToolEnv[key];
-            continue;
-        }
+        // 优先读取 ~/.claude/settings.json（与 Claude Code CLI 共用同一配置）
         if (key in claudeSettingsEnv) {
             process.env[key] = claudeSettingsEnv[key];
             continue;
         }
+        // 兜底：config.json tools.claude.env（仅在没有本地 Claude 安装时需要）
+        if (key in claudeToolEnv) {
+            process.env[key] = claudeToolEnv[key];
+            continue;
+        }
         delete process.env[key];
     }
 }

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