chatccc 0.2.281 → 0.2.283

package/README.md

@@ -448,8 +448,12 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
 `/restart safe`（短别名 `/restartsf`）与 `/update safe`（短别名 `/updatesf`）会先建立全局准入门禁：指令到达前已经运行或进入单会话缓存队列的工作会继续完成，之后到达的新普通任务会被提示在维护完成后重发。维护任务持久化到 `~/.chatccc/state/safe-maintenance.json`，进程意外退出后可继续排空；依赖安装、会话收尾、自动恢复和 Agent Teams 执行也计入等待条件。内存缓存随重启自然重建，磁盘会话、看板、图片等持久数据不会被清理。
 
 ChatCCC 的内部重启和更新使用跨平台父子进程握手：替代进程完成启动预检后通知父进程退出，再等待旧监听端口实际释放并接管 PID；替代进程未就绪或握手超时时，父进程会保留并继续服务。
+
+飞书接收长连接启用 15 秒握手超时和 30 秒心跳应答超时；首次启动最多等待 45 秒真实连接确认后才提示就绪。运行期间连接持续异常 90 秒时，会关闭并重新建立接收连接，保留会话、消息去重和正在执行的任务。没有用户消息不会触发重连。连接状态与恢复记录写入运行日志和 `startup-trace.log`（`FEISHU-CONNECTION` / `feishu-connection`）。卡片更新遇到网络失败或序号冲突时不会当成送达成功，错误通知保留文本兜底；TLS 断线会明确显示为网络连接失败，已中断的 Agent 任务不会因此自动重放。
 
-> **模型切换**：`/model` 查看当前会话 Agent 的可选模型清单，`/model <名称>` 模糊匹配切换，`/model clear` 恢复默认。可选模型来自当前 Agent 的配置：Claude 使用 `claude.model` / `claude.subagentModel`；Cursor、Codex、CCC Agent 和 DSH 使用各自的 `model` / `alternativeModel`。
+> **模型切换**：`/model` 查看当前会话 Agent 的可选模型清单，`/model <名称>` 模糊匹配切换，`/model clear` 恢复默认。可选模型来自当前 Agent 的配置：Claude 使用 `claude.model` / `claude.subagentModel`；Cursor、Codex、CCC Agent 和 DSH 使用各自的 `model` / `alternativeModel`。
+
+Agent 的初始化、输入回显与重连通知不代表任务成功。Cursor、Codex 和 Claude 缺少成功完成事件，或任一 Agent 没有产生有效回复时，会明确提示异常；已生成的部分回复会保留并标为可能不完整。Cursor 重连过程显示在状态区，上游的 `resource_exhausted` / `unavailable` 分别提示请求受限 / 服务暂不可用，不推断为余额耗尽。执行失败不会自动重放整条任务。
 
 > **Codex Fast 模式**：Web UI 中的“Fast 模式”设置新 Codex 会话的全局默认值，默认关闭。进入 Codex 会话后，`/fast` 查询当前状态，`/fast on` 和 `/fast off` 只覆盖当前会话并从下一条消息生效。ChatCCC 会显式向 Codex CLI 传入 `service_tier="fast"` 或 `service_tier="default"`，因此关闭时不会继承用户 `config.toml` 中可能开启的 Fast。
 

package/deepccc-agent/README.md

@@ -8,6 +8,8 @@ DeepCCC 是一个本地优先的开源 Coding Agent，同时提供浏览器多
 
 ## 安装与快速开始
 
+模型原生流未收到完成事件、返回错误结束原因或达到输出长度限制时，会报告异常并保留已经输出的内容，不将不完整回复判为成功。没有回复且没有工具执行的空结果也会明确报错。用户主动取消仍按中断处理。
+
 全局安装：
 
 ```bash

package/deepccc-agent/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepccc",
-  "version": "0.2.11",
+  "version": "0.2.12",
   "description": "A lightweight coding agent with OpenAI-compatible and Anthropic Messages API support.",
   "license": "Apache-2.0",
   "keywords": [

package/dist/deepccc-agent/src/index.js

@@ -478,16 +478,25 @@ export class ChatSession {
                     messages: attemptMessages,
                 };
                 let stream;
+                let requiresFinish = false;
+                let receivedFinish = false;
+                let finishReason;
                 if (this.streaming) {
                     const result = streamText(generationOptions);
+                    requiresFinish = result.fullStream != null;
                     stream = result.fullStream ?? textStreamToFullStream(result.textStream);
                 }
                 else {
                     const result = await generateText(generationOptions);
+                    finishReason = result.finishReason;
                     stream = generateResultToFullStream(result);
                 }
                 for await (const part of stream) {
                     rawLog?.writeLine(safeRawStreamJson(part));
+                    if (part.type === "finish") {
+                        receivedFinish = true;
+                        finishReason = part.finishReason;
+                    }
                     if (part.type === "reasoning-start" || part.type === "reasoning-delta") {
                         // Reasoning content remains private. A throttled heartbeat is enough
                         // for ChatCCC to distinguish active inference from a stalled stream.
@@ -561,6 +570,14 @@ export class ChatSession {
                         throw new Error(message);
                     }
                 }
+                if (!signal?.aborted) {
+                    if (requiresFinish && !receivedFinish)
+                        throw new Error("DeepCCC 输出流中断：未收到模型完成事件，回复可能不完整");
+                    if (finishReason === "error" || finishReason === "length")
+                        throw new Error(`DeepCCC 未正常完成：finishReason=${finishReason}，回复可能不完整`);
+                    if (!fullText.trim() && toolCallOrder.length === 0)
+                        throw new Error("DeepCCC 本轮未产生有效回复");
+                }
                 if (hasMalformedToolProtocolText(fullText)) {
                     console.warn(`[DeepCCC] malformed tool protocol text detected for ${this.context.sessionId} `
                         + `(attempt ${attempt + 1}/2, structuredToolCalls=${toolCallOrder.length})`);

package/dist/src/adapters/ccc-adapter.js

@@ -2,6 +2,7 @@ import { ChatSession } from "../../deepccc-agent/src/index.js";
 import { config as deepCccConfig } from "../../deepccc-agent/src/config.js";
 import { getBuiltinContextSession, newBuiltinSessionId, normalizeBuiltinSessionId, } from "../../deepccc-agent/src/context.js";
 import { config, CCC_SESSION_PREFIX } from "../config.js";
+import { createTurnCompletion } from "./turn-completion.js";
 function toChatSessionOptions(sessionId, cwd, options) {
     return {
         cwd,
@@ -50,7 +51,12 @@ export function createCccAdapter(options = {}) {
         async *prompt(sessionId, userText, cwd, signal, _promptOptions) {
             const normalizedSessionId = normalizeBuiltinSessionId(sessionId);
             const session = new ChatSession(chatConfig, toChatSessionOptions(normalizedSessionId, cwd, options));
+            const completion = createTurnCompletion("CCC Agent");
             for await (const event of session.chat(userText, signal)) {
+                if (event.type === "text")
+                    completion.observe({ type: "assistant", blocks: [{ type: "text", text: event.text }] });
+                if (event.type === "text_reset")
+                    completion.observe({ type: "assistant", blocks: [{ type: "text_reset" }] });
                 if (event.type === "status") {
                     yield {
                         type: "assistant",
@@ -101,6 +107,7 @@ export function createCccAdapter(options = {}) {
                     };
                 }
                 else if (event.type === "done" && !signal?.aborted) {
+                    completion.complete();
                     yield {
                         type: "assistant",
                         blocks: [],
@@ -111,6 +118,8 @@ export function createCccAdapter(options = {}) {
                     throw new Error(event.message);
                 }
             }
+            if (!signal?.aborted)
+                completion.assertComplete();
         },
         async getSessionInfo(sessionId) {
             const normalizedSessionId = normalizeBuiltinSessionId(sessionId);

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

@@ -11,6 +11,8 @@ import { homedir } from "node:os";
 import { delimiter, join } from "node:path";
 import { pathToFileURL } from "node:url";
 import { parseUserCommand } from "./adapter-interface.js";
+import { createTurnCompletion } from "./turn-completion.js";
+import { sanitizeTerminalErrorDetail } from "../terminal-error.js";
 import { CHATCCC_PORT, config, PROJECT_ROOT, RAW_STREAM_LOGS_DIR } from "../config.js";
 import { defaultClaudeSessionMetaStore, } from "./claude-session-meta-store.js";
 import { createRawStreamLog, } from "./raw-stream-log.js";
@@ -127,6 +129,9 @@ function logMcpConfig() {
     }
 }
 export function normalizeSdkMessage(msg) {
+    if (msg.type === "result" && (msg.subtype !== "success" || msg.is_error === true)) {
+        throw new Error(`Claude 执行失败：${sanitizeTerminalErrorDetail(JSON.stringify(msg.errors ?? msg.result ?? msg.subtype ?? "未提供错误详情"))}`);
+    }
     // SDK result/success 是 Claude 对本轮完整结束的权威确认。文本已经由之前的
     // assistant 消息累计，因此这里只发送终态信号，避免重复追加 result 文本。
     if (msg.type === "result" && msg.subtype === "success") {
@@ -399,6 +404,7 @@ class ClaudeAdapter {
             return;
         let aborted = false;
         let completed = false;
+        const completion = createTurnCompletion("Claude");
         const rawLogConfig = config.rawStreamLogs.claude;
         let rawLog = null;
         const sdk = await loadClaudeSdkModule();
@@ -449,10 +455,24 @@ class ClaudeAdapter {
                     }
                 }
                 const normalized = normalizeSdkMessage(msg);
+                completion.observe(normalized);
+                if (msg.type === "result") {
+                    // Some SDK modes only put the final reply in result.result.
+                    if (msg.result?.trim()) {
+                        const final = { type: "assistant", blocks: [{ type: "text_final", text: msg.result }] };
+                        completion.observe(final);
+                        yield final;
+                    }
+                    completion.complete();
+                    completed = true;
+                }
                 if (normalized)
                     yield normalized;
+                if (completed)
+                    break;
             }
-            completed = !aborted && !abortController.signal.aborted;
+            if (!aborted && !abortController.signal.aborted)
+                completion.assertComplete();
         }
         finally {
             removeAbortListener?.();

package/dist/src/adapters/codex-adapter.js

@@ -7,6 +7,7 @@
 // - getSessionInfo: 从持久化映射读取 cwd / threadId
 // =============================================================================
 import { spawn } from "node:child_process";
+import { createTurnCompletion } from "./turn-completion.js";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
@@ -71,8 +72,8 @@ function resolveCodexEffort() {
 // normalizeCodexMessage — Codex 事件 → UnifiedStreamMessage | null
 // ---------------------------------------------------------------------------
 export function normalizeCodexMessage(msg) {
-    if (msg.type === "error" && msg.message?.trim()) {
-        throw new Error(`Codex turn failed: ${msg.message.trim()}`);
+    if (msg.type === "error") {
+        throw new Error(`Codex turn failed: ${msg.message?.trim() || "未提供错误详情"}`);
     }
     if (msg.type === "turn.failed") {
         const detail = typeof msg.error === "string" ? msg.error : msg.error?.message;
@@ -160,10 +161,18 @@ function spawnCodex(args, cwd, stdinText, modelOverride, effortOverride, fastMod
         shell: true,
     });
     let stderr = "";
+    let exitCode = null;
+    let signal = null;
+    let settleClose = () => { };
+    const closed = new Promise(resolve => { settleClose = resolve; });
+    proc.once("error", (error) => { stderr += `\n${error.message}`; settleClose(); });
     proc.stderr.on("data", (chunk) => {
         stderr += chunk.toString();
     });
-    proc.on("close", (code) => {
+    proc.on("close", (code, exitSignal) => {
+        exitCode = code;
+        signal = exitSignal;
+        settleClose();
         if (code !== 0 && stderr.trim()) {
             console.error(`[Codex stderr] exit=${code}: ${stderr.trim().slice(0, 2000)}`);
         }
@@ -172,7 +181,17 @@ function spawnCodex(args, cwd, stdinText, modelOverride, effortOverride, fastMod
         proc.stdin.write(stdinText);
         proc.stdin.end();
     }
-    return proc;
+    return { proc, async failureDetail() {
+            let timer;
+            try {
+                await Promise.race([closed, new Promise(resolve => { timer = setTimeout(resolve, 2_000); })]);
+                return `exit=${exitCode ?? "unknown"}; signal=${signal ?? "none"}; ${stderr.trim() || "无 stderr 详情"}`;
+            }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+            }
+        } };
 }
 async function* readJsonLines(proc, signal, rawLog) {
     yield* readJsonLinesWithBadJsonIdleWatchdog({
@@ -219,7 +238,8 @@ class CodexAdapter {
         const args = isFirstPrompt
             ? [...baseArgs, "-C", cwd, "-"]
             : [...baseArgs, "resume", threadId, "-"];
-        const proc = spawnCodex(args, cwd, buildCodexPromptText(userText), this.modelOverride, this.effortOverride, this.fastModeOverride);
+        const handle = spawnCodex(args, cwd, buildCodexPromptText(userText), this.modelOverride, this.effortOverride, this.fastModeOverride);
+        const proc = handle.proc;
         if (proc.pid !== undefined)
             options?.onProcessStart?.({ pid: proc.pid });
         const rawLogConfig = config.rawStreamLogs.codex;
@@ -245,12 +265,11 @@ class CodexAdapter {
         const onAbort = () => { void killProcessTree(proc.pid); };
         signal?.addEventListener("abort", onAbort, { once: true });
         let completed = false;
+        const completion = createTurnCompletion("Codex");
         try {
             for await (const raw of readJsonLines(proc, signal, rawLog)) {
                 if (signal?.aborted)
                     break;
-                if (raw.type === "turn.completed")
-                    completed = true;
                 if (isFirstPrompt &&
                     raw.type === "thread.started" &&
                     raw.thread_id) {
@@ -259,9 +278,18 @@ class CodexAdapter {
                         .catch(() => { });
                 }
                 const normalized = normalizeCodexMessage(raw);
+                completion.observe(normalized);
+                if (raw.type === "turn.completed") {
+                    completion.complete();
+                    completed = true;
+                }
                 if (normalized)
                     yield normalized;
+                if (completed)
+                    break;
             }
+            if (!signal?.aborted && !completed)
+                completion.assertComplete(await handle.failureDetail());
         }
         finally {
             signal?.removeEventListener("abort", onAbort);

package/dist/src/adapters/cursor-adapter.js

@@ -8,6 +8,7 @@ import { spawn } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { parseUserCommand } from "./adapter-interface.js";
+import { createTurnCompletion } from "./turn-completion.js";
 import { config, CURSOR_AGENT_COMMAND, CURSOR_AGENT_ARGS, PROJECT_ROOT, RAW_STREAM_LOGS_DIR } from "../config.js";
 import { defaultCursorSessionMetaStore, } from "./cursor-session-meta-store.js";
 import { killProcessTree } from "./proc-tree-kill.js";
@@ -106,6 +107,15 @@ function mapToolCallKey(key) {
     return KEY_MAP[key] ?? key;
 }
 export function normalizeCursorMessage(msg) {
+    if (msg.type === "error" || (msg.type === "result" && (msg.is_error === true || msg.subtype?.startsWith("error")))) {
+        throw new Error(`Cursor 执行失败：${formatCursorVisibleStderr(JSON.stringify(msg.errors ?? msg.error ?? msg.result ?? msg.subtype ?? "未提供错误详情"))}`);
+    }
+    if (msg.type === "connection" || msg.type === "retry") {
+        return { type: "system", blocks: [{ type: "agent_status",
+                    status: msg.subtype === "reconnected" ? "responding" : "reconnecting",
+                    ...(Number.isInteger(msg.attempt) && msg.attempt > 0 ? { attempt: msg.attempt } : {}),
+                }] };
+    }
     if (msg.type === "assistant" && msg.message?.content) {
         // 按 cursor 官方 stream-json 规范区分三类 assistant 事件，避免 text 重复累加：
         //   ┌────────────────┬───────────────┬─────────────────┐
@@ -312,8 +322,17 @@ function spawnAgent(extraArgs, cwd, stdinText, modelOverride, mode, spawnImpl =
         waitForClose: async () => {
             if (closeInfo)
                 return { ...closeInfo, stderr };
-            const info = await closePromise;
-            return { ...info, stderr };
+            let timer;
+            try {
+                const info = await Promise.race([closePromise, new Promise(resolve => {
+                        timer = setTimeout(() => resolve({ code: null, signal: null, stderr }), 2_000);
+                    })]);
+                return { ...info, stderr };
+            }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+            }
         },
     };
 }
@@ -425,6 +444,7 @@ class CursorAdapter {
         const onAbort = () => { void killProcessTree(proc.pid); };
         signal?.addEventListener("abort", onAbort, { once: true });
         let sawResult = false;
+        const completion = createTurnCompletion("Cursor");
         const stats = createCursorStreamStats();
         try {
             for await (const raw of readJsonLines(proc, signal, sessionId, rawLog, stats, this.badJsonIdleTimeoutMs)) {
@@ -439,10 +459,15 @@ class CursorAdapter {
                         .catch(() => { });
                 }
                 const normalized = normalizeCursorMessage(raw);
+                completion.observe(normalized);
+                if (raw.type === "result")
+                    completion.complete();
                 if (normalized)
                     yield normalized;
                 // result 是流末事件，收到后立即结束进程，防止 CLI 僵死导致 readline 挂起。
                 if (raw.type === "result") {
+                    if (!normalized?.isFinalResponse)
+                        yield { type: "assistant", blocks: [], isFinalResponse: true };
                     sawResult = true;
                     void killProcessTree(proc.pid);
                     break;
@@ -462,6 +487,7 @@ class CursorAdapter {
                     };
                     throw createCursorAgentFailureError(closeInfo);
                 }
+                completion.assertComplete(`exit=${closeInfo.code ?? "unknown"}; signal=${closeInfo.signal ?? "none"}; ${formatCursorVisibleStderr(closeInfo.stderr) || "无 stderr 详情"}`);
             }
         }
         finally {

package/dist/src/adapters/dsh-adapter.js

@@ -125,22 +125,18 @@ export function createDshAdapter(options = {}) {
                                 queue.push(message);
                         },
                     });
-                    if (result.finalResponse) {
+                    if (turnError) {
+                        if (result.finalResponse?.trim())
+                            queue.push({ type: "assistant", blocks: [{ type: "text_final", text: result.finalResponse }] });
+                        queue.fail(turnError);
+                    }
+                    else if (result.finalResponse?.trim()) {
                         rawLog?.writeLine(JSON.stringify({ type: "run.result", result }));
                         queue.push({ type: "assistant", blocks: [{ type: "text_final", text: result.finalResponse }], isFinalResponse: true });
                         completed = true;
                     }
-                    else if (turnError) {
-                        queue.fail(turnError);
-                    }
                     else {
-                        // 引擎正常结束但零输出（无错误、无回复）：给出明确提示，避免用户只看到"失败"。
-                        queue.push({
-                            type: "assistant",
-                            blocks: [{ type: "text_final", text: "DeepSeek Harness 本轮未产生任何回复（引擎未报告错误）。" }],
-                            isFinalResponse: true,
-                        });
-                        completed = true;
+                        queue.fail(new Error("DeepSeek Harness 本轮未产生有效回复（引擎未报告错误）。"));
                     }
                     if (completed) {
                         knownSessions.set(sessionId, { sessionId, cwd, lastModified: Date.now(), model: options.model ?? "deepseek-v4-flash" });

package/dist/src/adapters/turn-completion.js

@@ -0,0 +1,25 @@
+import { sanitizeTerminalErrorDetail } from "../terminal-error.js";
+/** Protocol output (init, echo, heartbeat, tools) is not a successful reply. */
+export function createTurnCompletion(tool) {
+    let hasReply = false;
+    let completed = false;
+    return {
+        observe(message) {
+            for (const block of message?.blocks ?? []) {
+                if (block.type === "text_reset")
+                    hasReply = false;
+                if (message?.type === "assistant" && (block.type === "text" || block.type === "text_final") && block.text.trim())
+                    hasReply = true;
+            }
+        },
+        complete() {
+            if (!hasReply)
+                throw new Error(`${tool} 本轮未产生有效回复（收到结束事件，但回复为空）。`);
+            completed = true;
+        },
+        assertComplete(detail = "") {
+            if (!completed)
+                throw new Error(`${tool} 未正常完成：输出流结束但未收到成功完成事件${detail ? `；${sanitizeTerminalErrorDetail(detail)}` : ""}。`);
+        },
+    };
+}

package/dist/src/agent-activity.js

@@ -7,6 +7,7 @@ export function createAgentActivityTracker(now = Date.now()) {
 }
 function sameVisibleActivity(left, right) {
     return left.kind === right.kind
+        && left.attempt === right.attempt
         && left.toolName === right.toolName
         && left.toolCount === right.toolCount;
 }
@@ -73,8 +74,9 @@ export function updateAgentActivity(tracker, block, now = Date.now()) {
             return setActivity(tracker, { kind: "responding", startedAt: now });
         case "agent_status":
             return setActivity(tracker, {
-                kind: block.status === "compacting" ? "compacting" : "responding",
+                kind: block.status,
                 startedAt: now,
+                ...(block.attempt ? { attempt: block.attempt } : {}),
             });
         case "thinking":
         case "redacted_thinking":
@@ -126,6 +128,9 @@ export function formatAgentActivityTitle(activity, now = Date.now()) {
         case "responding":
             label = "正在生成回复";
             break;
+        case "reconnecting":
+            label = `正在重新连接模型服务${activity.attempt ? `（第 ${activity.attempt} 次）` : ""}`;
+            break;
         case "searching":
             label = "正在处理搜索结果";
             break;

package/dist/src/cardkit.js

@@ -103,7 +103,31 @@ export async function streamCardKitElement(token, cardId, elementId, content, se
     // success log is intentionally sparse — uncomment to debug streaming throughput
     // console.log(`[${ts()}] [CARDIKT] streamElement OK cardId=${cardId} seq=${sequence}`);
 }
-export async function updateCardKitCard(token, cardId, cardJson, sequence) {
+// Keep bounded per-card sequence history; never reuse an attempted sequence
+// because a failed fetch can mean the response (not the update) was lost.
+const cardUpdateQueues = new Map();
+export function updateCardKitCard(token, cardId, cardJson, sequence) {
+    let state = cardUpdateQueues.get(cardId);
+    if (!state) {
+        for (const [key, candidate] of cardUpdateQueues) {
+            if (cardUpdateQueues.size < 512)
+                break;
+            if (candidate.pending === 0)
+                cardUpdateQueues.delete(key);
+        }
+        state = { sequence: 0, tail: Promise.resolve(), pending: 0 };
+        cardUpdateQueues.set(cardId, state);
+    }
+    const queue = state;
+    queue.pending++;
+    const result = queue.tail.then(async () => {
+        queue.sequence = Math.max(sequence, queue.sequence + 1);
+        await performCardKitUpdate(token, cardId, cardJson, queue.sequence);
+    });
+    queue.tail = result.catch(() => { }).finally(() => { queue.pending--; });
+    return result;
+}
+async function performCardKitUpdate(token, cardId, cardJson, sequence) {
     const { resp, respText } = await fetchCardKit(`${BASE_URL}/cardkit/v1/cards/${cardId}`, {
         method: "PUT",
         headers: {

package/dist/src/feishu-connection.js

@@ -0,0 +1,144 @@
+import { sanitizeTerminalErrorDetail } from "./terminal-error.js";
+/** Owns only the receiving transport. It never resets sessions or replays tasks. */
+export function createFeishuConnectionSupervisor(options) {
+    const stalledAfterMs = options.stalledAfterMs ?? 90_000;
+    let stopped = false;
+    let client;
+    let timer;
+    let startupTimer;
+    let startup;
+    let resolveStartup;
+    let rejectStartup;
+    let unhealthySince;
+    let lastState = "idle";
+    let connected = false;
+    let launching = false;
+    let lastAttempt = 0;
+    const log = (event, detail) => {
+        try {
+            options.log(event, detail);
+        }
+        catch { /* diagnostics cannot break recovery */ }
+    };
+    const reportError = (error) => {
+        if (stopped)
+            return;
+        connected = false;
+        unhealthySince ??= Date.now();
+        log("connection error", { reason: sanitizeTerminalErrorDetail(error instanceof Error ? error.message : String(error)) });
+    };
+    const becameConnected = () => {
+        if (stopped) {
+            // A handshake already in flight can finish after close(); never resurrect
+            // a transport belonging to a stopped setup attempt or shutting-down app.
+            try {
+                client?.close({ force: true });
+            }
+            catch { /* best effort */ }
+            return;
+        }
+        if (connected)
+            return;
+        connected = true;
+        unhealthySince = undefined;
+        lastState = "connected";
+        log("connected");
+        if (startupTimer)
+            clearTimeout(startupTimer);
+        resolveStartup?.();
+        resolveStartup = undefined;
+        rejectStartup = undefined;
+        void Promise.resolve().then(() => stopped ? undefined : options.onConnected()).catch((error) => {
+            log("binding recovery failed", { reason: sanitizeTerminalErrorDetail(String(error)) });
+        });
+    };
+    const stop = () => {
+        if (stopped)
+            return;
+        stopped = true;
+        if (timer)
+            clearInterval(timer);
+        if (startupTimer)
+            clearTimeout(startupTimer);
+        try {
+            client?.close({ force: true });
+        }
+        catch { /* best effort shutdown */ }
+        rejectStartup?.(new Error("飞书长连接在就绪前已停止"));
+        resolveStartup = undefined;
+        rejectStartup = undefined;
+        log("stopped");
+    };
+    const launch = () => {
+        if (stopped || launching || !client)
+            return;
+        launching = true;
+        lastAttempt = Date.now();
+        unhealthySince = lastAttempt;
+        void Promise.resolve().then(() => stopped ? undefined : client.start())
+            .catch(reportError).finally(() => { launching = false; });
+    };
+    const check = () => {
+        if (stopped || !client)
+            return;
+        try {
+            const status = client.getConnectionStatus();
+            if (status.state !== lastState) {
+                lastState = status.state;
+                log("state", { ...status });
+            }
+            if (status.state === "connected") {
+                becameConnected();
+                return;
+            }
+            connected = false;
+            unhealthySince ??= Date.now();
+            // SDK gets a bounded chance to recover. Silence from users is irrelevant.
+            if (launching || Date.now() - unhealthySince < stalledAfterMs
+                || Date.now() - lastAttempt < stalledAfterMs)
+                return;
+            log("restarting receiving connection", { ...status, disconnectedForMs: Date.now() - unhealthySince });
+            client.close({ force: true });
+            launch();
+        }
+        catch (error) {
+            reportError(error);
+        }
+    };
+    const start = () => {
+        if (startup)
+            return startup;
+        if (stopped)
+            return Promise.reject(new Error("飞书长连接已停止"));
+        startup = new Promise((resolve, reject) => { resolveStartup = resolve; rejectStartup = reject; });
+        startupTimer = setTimeout(() => {
+            rejectStartup?.(new Error("飞书长连接握手超时，尚未收到连接成功确认"));
+            rejectStartup = undefined;
+            stop();
+        }, options.startupTimeoutMs ?? 45_000);
+        try {
+            client = options.createClient({
+                onReady: becameConnected,
+                onReconnected: becameConnected,
+                onReconnecting() {
+                    if (stopped)
+                        return;
+                    connected = false;
+                    unhealthySince ??= Date.now();
+                    log("reconnecting");
+                },
+                onError: reportError,
+            });
+            timer = setInterval(check, options.checkIntervalMs ?? 10_000);
+            timer.unref();
+            launch();
+        }
+        catch (error) {
+            rejectStartup?.(error instanceof Error ? error : new Error(String(error)));
+            rejectStartup = undefined;
+            stop();
+        }
+        return startup;
+    };
+    return { start, stop };
+}

package/dist/src/index.js

@@ -23,6 +23,7 @@
  */
 import { createServer } from "node:http";
 import { WSClient, EventDispatcher, Domain } from "@larksuiteoapi/node-sdk";
+import { createFeishuConnectionSupervisor } from "./feishu-connection.js";
 import WebSocket from "ws";
 import { appendStartupTrace, attachRelayWebSocket, ensureSingleInstance, freeRelayListenPort, installCrashLogging, installEpipeGuard, waitForPortFree } from "./shared.js";
 import { createUiRouter, setExtraApiHandler, setReloadConfigHook, startSetupMode } from "./web-ui.js";
@@ -256,6 +257,7 @@ async function startBotService(opts) {
         throw err;
     }
 }
+let feishuConnection;
 async function startBotServiceCore() {
     const modeTag = USE_LOCAL ? " (local relay mode)" : "";
     console.log(`${"=".repeat(60)}`);
@@ -420,20 +422,33 @@ async function startBotServiceCore() {
         //   - 已处理消息的去重 set 必须保留,避免 SDK 重推老消息时 prompt 跑两遍
         // 历史 bug:此处曾误调 resetState() 导致重连即让所有后台任务变孤儿,
         // 同一 session 还可能双开 prompt(详见 session.ts::resetState 注释)。
-        const wsClient = new WSClient({
-            appId: APP_ID,
-            appSecret: APP_SECRET,
-            domain: FEISHU_PLATFORM_TYPE === "lark" ? Domain.Lark : Domain.Feishu,
-            onReady: async () => {
-                await rebuildBindingsFromRegistry().catch((err) => console.error(`[${ts()}] [SDK READY] rebuild bindings failed: ${err.message}`));
+        feishuConnection?.stop();
+        feishuConnection = createFeishuConnectionSupervisor({
+            createClient(callbacks) {
+                const client = new WSClient({
+                    appId: APP_ID,
+                    appSecret: APP_SECRET,
+                    domain: FEISHU_PLATFORM_TYPE === "lark" ? Domain.Lark : Domain.Feishu,
+                    autoReconnect: true,
+                    handshakeTimeoutMs: 15_000,
+                    wsConfig: { pingTimeout: 30 },
+                    ...callbacks,
+                });
+                return {
+                    start: () => client.start({ eventDispatcher }),
+                    close: (options) => client.close(options),
+                    getConnectionStatus: () => client.getConnectionStatus(),
+                };
             },
-            onReconnected: async () => {
-                await rebuildBindingsFromRegistry().catch((err) => console.error(`[${ts()}] [SDK RECONNECT] rebuild bindings failed: ${err.message}`));
+            onConnected: rebuildBindingsFromRegistry,
+            log(event, detail) {
+                appendStartupTrace(`feishu-connection: ${event}`, detail);
+                console.log(`[${ts()}] [FEISHU-CONNECTION] ${event}${detail ? ` ${JSON.stringify(detail)}` : ""}`);
             },
         });
         console.log(`\n[启动 6/7] 飞书长连接：正在通过 SDK 建立 WebSocket …`);
         try {
-            await wsClient.start({ eventDispatcher });
+            await feishuConnection.start();
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
@@ -790,6 +805,7 @@ function installShutdownHandlers(httpServer, serviceLifecycle) {
     process.on("SIGINT", () => {
         console.log("\nShutting down...");
         serviceLifecycle.beginShutdown("SIGINT");
+        feishuConnection?.stop();
         wechatSignal.stopped = true;
         stopChromeDevtoolsGuard();
         httpServer.close();
@@ -797,6 +813,7 @@ function installShutdownHandlers(httpServer, serviceLifecycle) {
     });
     process.on("SIGTERM", () => {
         serviceLifecycle.beginShutdown("SIGTERM");
+        feishuConnection?.stop();
         wechatSignal.stopped = true;
         stopChromeDevtoolsGuard();
         httpServer.close();

package/dist/src/session.js

@@ -1785,7 +1785,6 @@ export function startUnifiedDisplayLoop() {
                                         console.error(`[${ts()}] [DISPLAY] terminal cardUpdate failed: ${err.message}`);
                                         if (isCardKitSequenceConflict(err)) {
                                             display.sequence = nextSeq;
-                                            terminalCardUpdateAccepted = true;
                                         }
                                     });
                                     if (terminalCardUpdateAccepted) {
@@ -1943,6 +1942,8 @@ export function startUnifiedDisplayLoop() {
                                     catch (err) {
                                         const errMsg = err.message;
                                         console.error(`[${ts()}] CardKit update error: chatId=${chatId} ${errMsg}`);
+                                        display.lastSentContent = "";
+                                        display.lastSentHeaderTitle = "";
                                         if (errMsg.includes("300317")) {
                                             display.sequence = mySeq;
                                         }
@@ -1977,6 +1978,8 @@ export function startUnifiedDisplayLoop() {
                                 catch (err) {
                                     const errMsg = err.message;
                                     console.error(`[${ts()}] CardKit update error: chatId=${chatId} ${errMsg}`);
+                                    display.lastSentContent = "";
+                                    display.lastSentHeaderTitle = "";
                                     if (errMsg.includes("300317")) {
                                         display.sequence = mySeq;
                                     }

package/dist/src/terminal-error.js

@@ -37,7 +37,7 @@ export function classifyTerminalError(error, occurredAt = Date.now()) {
     const lower = raw.toLowerCase();
     const attempts = parsePositiveInt(raw, /\bafter\s+(\d+)\s+attempts?\b/i);
     const timeoutMs = parsePositiveInt(raw, /\btimeout\s*:\s*(\d+)\s*ms\b/i);
-    if (/\b429\b|rate[ _-]?limit|too many requests/.test(lower)) {
+    if (/\b429\b|rate[ _-]?limit|too many requests|resource_exhausted/.test(lower)) {
         return {
             kind: "rate_limit",
             title: "请求受到限流",
@@ -64,7 +64,7 @@ export function classifyTerminalError(error, occurredAt = Date.now()) {
             occurredAt,
         };
     }
-    if (/econnrefused|econnreset|enotfound|eai_again|socket hang up|network error|cannot connect/.test(lower)) {
+    if (/econnrefused|econnreset|enotfound|eai_again|socket hang up|network error|cannot connect|tls handshake|before secure tls connection|stream disconnected before completion|websocket closed/.test(lower)) {
         return {
             kind: "network",
             title: "无法连接模型服务",
@@ -73,7 +73,7 @@ export function classifyTerminalError(error, occurredAt = Date.now()) {
         };
     }
     const httpStatus = raw.match(/\b(?:HTTP\s*)?(5\d\d)\b/i)?.[1];
-    if (httpStatus || /service unavailable|bad gateway|gateway timeout|provider error/.test(lower)) {
+    if (httpStatus || /service unavailable|\[unavailable\]|bad gateway|gateway timeout|provider error/.test(lower)) {
         return {
             kind: "provider",
             title: "模型服务暂时不可用",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chatccc",
-  "version": "0.2.281",
+  "version": "0.2.283",
   "description": "Feishu bot bridge for Claude Code",
   "license": "Apache-2.0",
   "type": "module",
@@ -53,7 +53,7 @@
   "dependencies": {
     "@ai-sdk/anthropic": "^3.0.105",
     "@ai-sdk/openai-compatible": "^2.0.47",
-    "@larksuiteoapi/node-sdk": "^1.59.0",
+    "@larksuiteoapi/node-sdk": "^1.66.1",
     "@openilink/openilink-sdk-node": "^0.6.0",
     "@vscode/ripgrep": "^1.18.0",
     "ai": "^6.0.184",