chatccc 0.1.1 → 0.1.3

package/README.md

@@ -1,106 +1,143 @@
-# ChatCCC
-
-**飞书聊天控制 Claude Code，未来支持 Cursor、Codex**
-
----
-
-## 解决的核心痛点
-
-传统的 Claude Code（尤其是使用第三方 API 的，如 DeepSeek），需要坐在电脑桌前才能用。**离开电脑就没法用了。**
-
-ChatCCC 把 Claude Code 接入了飞书群聊：
-
-- **手机上也能用 Claude Code** —— 在飞书群里发消息就等于在终端输入指令，Claude 的思考和回复会流式展示在群卡片里
-- **多会话并行** —— 一个群就是一个 Claude 会话，完全隔离、互不干扰，并行工作效率更高
-- **流式打字机效果** —— 体验丝滑，流式输出响应迅速
-
-一句话：**在任何设备上打开飞书，就能让 Claude 帮你写代码、排查问题、分析项目。**
-
----
-
-## 怎么部署
-
-### 1. 创建飞书应用
-
-打开 [飞书开放平台](https://open.feishu.cn)，创建一个**企业自建应用**。
-
-**添加应用能力**：开启「机器人」功能。
-
-**权限配置**（在「权限管理」中搜索并开通以下权限）：
-
-| 权限 | 用途 |
-|------|------|
-| `im:chat` | 创建和管理群聊 |
-| `im:message` | 收发消息 |
-| `im:message:send_as_bot` | 以机器人身份发消息 |
-| `im:message.p2p_msg:readonly` | 读取私聊消息 |
-| `im:message.group_msg:readonly` | 读取群聊消息 |
-
-**事件订阅**（在「事件与回调」中）：订阅 `im.message.receive_v1` 和 `card.action.trigger` 事件。
-
-**发布版本**：配置完成后创建应用版本并发布（仅企业内部可用即可）。
-
-### 2. 获取凭证
-
-在飞书应用详情页的「凭证与基础信息」中，复制 **App ID** 和 **App Secret**。
-
-### 3. 配置环境变量
-
-```bash
-cp .env.example .env
-```
-
-编辑 `.env`，填入上一步拿到的凭证：
-
-```env
-FEISHU_CLAUDER_APP_ID=cli_xxxxxxxxxxxx
-FEISHU_CLAUDER_APP_SECRET=xxxxxxxxxxxxxxxxxxxxxxxxxx
-```
-
-可选的高级配置：
-
-```env
-# Claude 模型（见下方优先级说明）
-CHATCCC_ANTHROPIC_MODEL=dashscope/deepseek-v4-pro-anthropic
-
-# 思考深度，可选值: low | medium | high | max
-CHATCCC_ANTHROPIC_EFFORT=max
-```
-
-**`CHATCCC_ANTHROPIC_MODEL` 优先级**：环境变量设置的值 > 代码内默认值 `dashscope/deepseek-v4-pro-anthropic`。不设或设为空白时自动使用默认模型。
-
-**`CHATCCC_ANTHROPIC_EFFORT` 优先级**：环境变量设置的值 > 代码内默认值 `max`。
-
-> **权限说明**：目前 ChatCCC 以 `bypassPermissions` 模式运行，即跳过所有权限确认、允许所有操作。后续会考虑引入细粒度权限控制，让你可以按需放行特定操作。
-
-> **Linux 用户注意**：不能将项目装在 `/root` 目录下运行。
-
-### 4. 安装依赖并启动
-
-```bash
-# 要求 Node.js >= 20
-npm install
-npm run dev
-```
-
-启动后机器人通过 WebSocket 连接飞书服务器，日志会写入 `logs/` 目录。
-
-### 5. 开始使用
-
-在飞书中找到你的机器人，发送 `/new`，机器人会自动创建一个群聊并把你的 Claude 会话绑定到该群。之后直接在群里发消息就能和 Claude 对话。
-
-### 可用指令
-
-| 指令 | 作用 |
-|------|------|
-| `/new` | 创建新的 Claude 会话（绑定一个新群聊） |
-| `/stop` | 停止当前正在生成的回复 |
-| `/status` | 查看当前会话的状态（轮数、模型、上下文 token 等） |
-| `/cd` | 查看/切换工作目录 |
-| `/restart` | 重启机器人进程 |
-
----
-
-## 技术栈
-
+# ChatCCC
+
+**飞书聊天控制 Claude Code，未来支持 Cursor、Codex**
+
+---
+
+## 解决的核心痛点
+
+传统的 Claude Code（尤其是使用第三方 API 的，如 DeepSeek），需要坐在电脑桌前才能用。**离开电脑就没法用了。**
+
+ChatCCC 把 Claude Code 接入了飞书群聊：
+
+- **手机上也能用 Claude Code** —— 在飞书群里发消息就等于在终端输入指令，Claude 的思考和回复会流式展示在群卡片里
+- **多会话并行** —— 一个群就是一个 Claude 会话，完全隔离、互不干扰，并行工作效率更高
+- **体验丝滑** —— 思考过程完整，响应迅速
+
+一句话：**在任何设备上打开飞书，就能让 Claude 帮你写代码、排查问题、分析项目。**
+
+<p align="center">
+  <img src="images/img_readme_0.jpg" alt="飞书群聊中使用 ChatCCC" width="280" />
+  &emsp;
+  <img src="images/img_readme_1.jpg" alt="思考过程和工具调用" width="280" />
+</p>
+
+---
+
+## 怎么部署
+
+### 1. 安装
+
+#### npm 全局安装（推荐）
+
+```bash
+npm install -g chatccc
+```
+
+要求 Node.js >= 20。安装完成后在项目目录创建 `.env`文件（参照.env.example文件），然后输入启动指令就启动了：
+
+```bash
+chatccc
+```
+
+#### 从源码安装
+
+```bash
+git clone https://github.com/wzj998/ChatCCC.git
+cd ChatCCC
+npm install
+npm run dev
+```
+
+启动后机器人通过 WebSocket 连接飞书服务器，日志会写入 `logs/` 目录。
+
+### 2. 创建飞书应用
+
+打开 [飞书开放平台](https://open.feishu.cn)，创建一个**企业自建应用**。
+
+**添加应用能力**：开启「机器人」功能。
+
+**权限配置**（在「权限管理」中搜索并开通以下权限）：
+
+
+| 权限                              | 用途        |
+| ------------------------------- | --------- |
+| `im:chat`                       | 创建和管理群聊   |
+| `im:message`                    | 收发消息      |
+| `im:message:send_as_bot`        | 以机器人身份发消息 |
+| `im:message.p2p_msg:readonly`   | 读取私聊消息    |
+| `im:message.group_msg:readonly` | 读取群聊消息    |
+
+
+**事件订阅**（在「事件与回调」中）：订阅 `im.message.receive_v1` 和 `card.action.trigger` 事件。
+
+**发布版本**：配置完成后创建应用版本并发布（仅企业内部可用即可）。
+
+### 3. 获取凭证
+
+在飞书应用详情页的「凭证与基础信息」中，复制 **App ID** 和 **App Secret**。
+
+### 4. 配置环境变量
+
+```bash
+cp .env.example .env
+```
+
+编辑 `.env`，填入上一步拿到的凭证：
+
+```env
+FEISHU_CLAUDER_APP_ID=cli_xxxxxxxxxxxx
+FEISHU_CLAUDER_APP_SECRET=xxxxxxxxxxxxxxxxxxxxxxxxxx
+```
+
+可选的高级配置：
+
+```env
+# Claude 模型（见下方优先级说明）
+CHATCCC_ANTHROPIC_MODEL=dashscope/deepseek-v4-pro-anthropic
+
+# 思考深度，可选值: low | medium | high | max
+CHATCCC_ANTHROPIC_EFFORT=max
+```
+
+`**CHATCCC_ANTHROPIC_MODEL` 优先级**：环境变量设置的值 > 代码内默认值 `dashscope/deepseek-v4-pro-anthropic`。不设或设为空白时自动使用默认模型。
+
+`**CHATCCC_ANTHROPIC_EFFORT` 优先级**：环境变量设置的值 > 代码内默认值 `max`。
+
+`**CHATCCC_PORT` 端口配置**：默认端口为 `18080`。如果你需要在一台机器上同时运行多个 ChatCCC 实例（例如用不同飞书应用分别接入不同项目），可以在各自的 `.env` 中设置不同的端口：
+
+```env
+# 实例 A（项目1）的 .env
+CHATCCC_PORT=18080
+
+# 实例 B（项目2）的 .env
+CHATCCC_PORT=18081
+```
+
+不同端口的实例互不冲突，启动时会自动清理各自端口上的旧进程。
+
+> **权限说明**：目前 ChatCCC 以 `bypassPermissions` 模式运行，即跳过所有权限确认、允许所有操作。后续会考虑引入细粒度权限控制，让你可以按需放行特定操作。
+
+> **Linux 用户注意**：不能将项目装在 `/root` 目录下运行。
+
+### 5. 开始使用
+
+在飞书中找到你的机器人，发送 `/new`，机器人会自动创建一个群聊并把你的 Claude 会话绑定到该群。之后直接在群里发消息就能和 Claude 对话。
+
+### 可用指令
+
+
+| 指令         | 作用                           |
+| ---------- | ---------------------------- |
+| `/new`     | 创建新的 Claude 会话（绑定一个新群聊）      |
+| `/stop`    | 停止当前正在生成的回复                  |
+| `/status`  | 查看当前会话的状态（轮数、模型、上下文 token 等） |
+| `/cd`      | 查看/切换工作目录                    |
+| `/restart` | 重启机器人进程                      |
+
+
+---
+
+## 技术栈
+
 TypeScript / Node.js >= 20 / tsx / Anthropic Claude Agent SDK / 飞书 WebSocket API / CardKit

package/bin/chatccc.mjs

@@ -1,7 +1,10 @@
-#!/usr/bin/env node
-import { register } from "node:module";
-import { pathToFileURL } from "node:url";
-
-register("tsx/esm", pathToFileURL("./"));
-
-await import("../src/index.js");
+#!/usr/bin/env node
+import { createRequire, register } from "node:module";
+import { pathToFileURL } from "node:url";
+
+const pkgRoot = new URL("../", import.meta.url);
+// 勿用 pathToFileURL("./")：会相对于进程 cwd。用 createRequire 从本脚本所在包解析 tsx
+const require = createRequire(import.meta.url);
+register(pathToFileURL(require.resolve("tsx/esm")), pkgRoot);
+
+await import(new URL("../src/index.ts", import.meta.url));

package/package.json

@@ -1,40 +1,40 @@
-{
-  "name": "chatccc",
-  "version": "0.1.1",
-  "description": "Feishu bot bridge for Claude Code",
-  "type": "module",
-  "main": "./src/index.ts",
-  "bin": {
-    "chatccc": "./bin/chatccc.mjs"
-  },
-  "files": [
-    "src/",
-    "bin/",
-    "package.json",
-    "README.md"
-  ],
-  "scripts": {
-    "dev": "tsx --env-file=.env src/index.ts",
-    "chatccc": "tsx --env-file=.env src/index.ts",
-    "start": "tsx --env-file=.env src/index.ts",
-    "demo:bot-test": "tsx --env-file=.env demo/bot_test.ts",
-    "demo:bot-test:local": "tsx --env-file=.env demo/bot_test.ts --local",
-    "demo:create-group": "tsx --env-file=.env src/index.ts",
-    "demo:create-group:local": "tsx --env-file=.env src/index.ts --local",
-    "demo:permission-check": "tsx --env-file=.env demo/permission_check.ts"
-  },
-  "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.133",
-    "@larksuiteoapi/node-sdk": "^1.59.0",
-    "tsx": "^4.0.0",
-    "ws": "^8.18.0"
-  },
-  "devDependencies": {
-    "@types/node": "^20.0.0",
-    "@types/ws": "^8.18.1",
-    "typescript": "^5.0.0"
-  },
-  "engines": {
-    "node": ">=20"
-  }
-}
+{
+  "name": "chatccc",
+  "version": "0.1.3",
+  "description": "Feishu bot bridge for Claude Code",
+  "type": "module",
+  "main": "./src/index.ts",
+  "bin": {
+    "chatccc": "bin/chatccc.mjs"
+  },
+  "files": [
+    "src/",
+    "bin/",
+    "package.json",
+    "README.md"
+  ],
+  "scripts": {
+    "dev": "tsx --env-file=.env src/index.ts",
+    "chatccc": "tsx --env-file=.env src/index.ts",
+    "start": "tsx --env-file=.env src/index.ts",
+    "demo:bot-test": "tsx --env-file=.env demo/bot_test.ts",
+    "demo:bot-test:local": "tsx --env-file=.env demo/bot_test.ts --local",
+    "demo:create-group": "tsx --env-file=.env src/index.ts",
+    "demo:create-group:local": "tsx --env-file=.env src/index.ts --local",
+    "demo:permission-check": "tsx --env-file=.env demo/permission_check.ts"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.133",
+    "@larksuiteoapi/node-sdk": "^1.59.0",
+    "tsx": "^4.0.0",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/ws": "^8.18.1",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}

package/src/cards.ts

@@ -93,7 +93,7 @@ export function buildThinkingCardV2(
     schema: "2.0",
     config: {
       update_multi: true,
-      streaming_mode: showStop,
+      streaming_mode: false,
     },
     header: {
       template: headerTemplate,
@@ -133,8 +133,8 @@ export function buildCdContent(
   const listing = display.map(e => e.isDir ? `📁 ${e.name}/` : `📄 ${e.name}`).join("\n");
 
   const statusLine = isUpdate
-    ? `**工作路径已更新为:** \`${dirPath}\``
-    : `**当前工作路径:** \`${dirPath}\``;
+    ? `**新会话工作路径已切换至:** \`${dirPath}\``
+    : `**新会话默认工作路径:** \`${dirPath}\``;
 
   return [
     statusLine,

package/src/config.ts

@@ -1,6 +1,6 @@
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import { appendFile, mkdir, readFile, stat, writeFile } from "node:fs/promises";
 
 import { setupFileLogging } from "./shared.ts";
 
@@ -38,25 +38,36 @@ export const APP_SECRET: string = process.env.FEISHU_CLAUDER_APP_SECRET ?? "";
 export const BASE_URL = "https://open.feishu.cn/open-apis";
 export const LOCAL_RELAY_URL = "ws://127.0.0.1:18080";
 
+export const CHATCCC_PORT = parseInt(process.env.CHATCCC_PORT?.trim() ?? "18080", 10);
+
 export const CLAUDE_MODEL =
   process.env.CHATCCC_ANTHROPIC_MODEL?.trim() || "dashscope/deepseek-v4-pro-anthropic";
 
 export const CLAUDE_EFFORT =
   process.env.CHATCCC_ANTHROPIC_EFFORT?.trim() || "max";
 
-export const WORKING_DIR_FILE = join(PROJECT_ROOT, ".claude", "working_dir.txt");
+// 新建会话的默认工作路径（/cd 命令设置，持久化到本地文件）
+// 该路径仅影响通过 /new 新建的 Claude 会话，不影响已有会话的 resume。
+export const DEFAULT_CWD_FILE = join(PROJECT_ROOT, ".claude", "working_dir.txt");
 
-export async function getWorkingDir(): Promise<string> {
+/** 读取 /cd 设置的默认工作路径。若文件不存在或路径已失效，回退到 PROJECT_ROOT。 */
+export async function getDefaultCwd(): Promise<string> {
   try {
-    const content = await readFile(WORKING_DIR_FILE, "utf-8");
+    const content = await readFile(DEFAULT_CWD_FILE, "utf-8");
     const dir = content.trim();
-    if (dir) return dir;
+    if (dir) {
+      try {
+        const s = await stat(dir);
+        if (s.isDirectory()) return dir;
+      } catch { /* path gone, fall through */ }
+    }
   } catch { /* file doesn't exist yet */ }
   return PROJECT_ROOT;
 }
 
-export async function setWorkingDir(dir: string): Promise<void> {
-  await writeFile(WORKING_DIR_FILE, dir, "utf-8");
+/** 设置新建会话的默认工作路径（由 /cd 命令调用） */
+export async function setDefaultCwd(dir: string): Promise<void> {
+  await writeFile(DEFAULT_CWD_FILE, dir, "utf-8");
 }
 
 // ---------------------------------------------------------------------------

package/src/index.ts

@@ -30,6 +30,7 @@ import WebSocket from "ws";
 
 import { ensureSingleInstance, createRelayServer } from "./shared.ts";
 import {
+  CHATCCC_PORT,
   APP_ID,
   APP_SECRET,
   BASE_URL,
@@ -40,8 +41,8 @@ import {
   USE_LOCAL,
   appendChatLog,
   fileLog,
-  getWorkingDir,
-  setWorkingDir,
+  getDefaultCwd,
+  setDefaultCwd,
   ts,
 } from "./config.ts";
 import {
@@ -58,7 +59,7 @@ import {
   sendRestartCard,
 } from "./feishu-api.ts";
 import { buildHelpCard, buildStatusCard, buildThinkingCardV2, buildCdContent } from "./cards.ts";
-import { setCardKitSettings, updateCardKitCard } from "./cardkit.ts";
+import { updateCardKitCard } from "./cardkit.ts";
 import {
   MAX_PROCESSED,
   chatSessionMap,
@@ -171,7 +172,7 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
 
   if (text === "/cd" || text.startsWith("/cd ")) {
     const cdToken = await getTenantAccessToken();
-    const currentDir = await getWorkingDir();
+    const currentDir = await getDefaultCwd();
     const arg = text.slice(3).trim(); // everything after "/cd" (may be empty)
 
     // Resolve target directory
@@ -188,18 +189,18 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
     try {
       const s = await stat(targetDir);
       if (!s.isDirectory()) {
-        await sendCardReply(cdToken, chatId, "工作路径", `路径存在但不是目录:\n\`${targetDir}\``, "red");
+        await sendCardReply(cdToken, chatId, "新会话工作路径", `路径存在但不是目录:\n\`${targetDir}\``, "red");
         return;
       }
     } catch {
-      await sendCardReply(cdToken, chatId, "工作路径", `路径不存在:\n\`${targetDir}\``, "red");
+      await sendCardReply(cdToken, chatId, "新会话工作路径", `路径不存在:\n\`${targetDir}\``, "red");
       return;
     }
 
     // Change working dir if user provided a path
     const isUpdate = !!arg && targetDir !== currentDir;
     if (isUpdate) {
-      await setWorkingDir(targetDir);
+      await setDefaultCwd(targetDir);
     }
 
     // Read directory entries
@@ -207,7 +208,7 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
     try {
       entries = await readdir(targetDir);
     } catch (err) {
-      await sendCardReply(cdToken, chatId, "工作路径", `无法读取目录:\n\`${targetDir}\`\n\n${(err as Error).message}`, "red");
+      await sendCardReply(cdToken, chatId, "新会话工作路径", `无法读取目录:\n\`${targetDir}\`\n\n${(err as Error).message}`, "red");
       return;
     }
 
@@ -225,7 +226,7 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
     });
 
     const content = buildCdContent(targetDir, withStats, isUpdate);
-    await sendCardReply(cdToken, chatId, "工作路径", content, "blue");
+    await sendCardReply(cdToken, chatId, "新会话工作路径", content, "blue");
     return;
   }
 
@@ -386,7 +387,6 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
             { showStop: false, headerTitle: "已中断", headerTemplate: "yellow" }
           );
           let nextSeq = existing.sequence + 1;
-          await setCardKitSettings(freshToken, cardId, { streaming_mode: false }, nextSeq++).catch(() => {});
           await updateCardKitCard(freshToken, cardId, interruptedCard, nextSeq).catch((err) => {
             console.error(`[${ts()}] [INTERRUPT] CardKit update failed: ${(err as Error).message}`);
           });
@@ -427,14 +427,14 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
 // ---------------------------------------------------------------------------
 
 async function main(): Promise<void> {
-  ensureSingleInstance(PID_FILE, 18080);
+  ensureSingleInstance(PID_FILE, CHATCCC_PORT);
 
   if (!APP_ID || !APP_SECRET) {
     console.log("ERROR: FEISHU_CLAUDER_APP_ID / FEISHU_CLAUDER_APP_SECRET not set");
     process.exit(1);
   }
 
-  const { server: relayServer, broadcast } = createRelayServer(18080);
+  const { server: relayServer, broadcast } = createRelayServer(CHATCCC_PORT);
   broadcastToRelay = broadcast;
 
   const modeTag = USE_LOCAL ? " (local relay mode)" : "";

package/src/session.ts

@@ -1,12 +1,10 @@
-import { unstable_v2_createSession, unstable_v2_resumeSession } from "@anthropic-ai/claude-agent-sdk";
+import { getSessionInfo, unstable_v2_createSession, unstable_v2_resumeSession } from "@anthropic-ai/claude-agent-sdk";
 
-import { CLAUDE_EFFORT, CLAUDE_MODEL, fileLog, ts } from "./config.ts";
+import { CLAUDE_EFFORT, CLAUDE_MODEL, fileLog, getDefaultCwd, ts } from "./config.ts";
 import { buildThinkingCardV2, getToolEmoji, truncateContent } from "./cards.ts";
 import {
   createCardKitCard,
   sendCardKitMessage,
-  setCardKitSettings,
-  streamCardKitElement,
   updateCardKitCard,
 } from "./cardkit.ts";
 import { sendTextReply } from "./feishu-api.ts";
@@ -58,11 +56,13 @@ export function resetState(): void {
 // ---------------------------------------------------------------------------
 
 export async function initClaudeSession(): Promise<string> {
-  console.log(`[${ts()}] [STEP 1/5] Creating Claude session via SDK (model=${CLAUDE_MODEL}, effort=${CLAUDE_EFFORT})`);
+  const cwd = await getDefaultCwd();
+  console.log(`[${ts()}] [STEP 1/5] Creating Claude session via SDK (model=${CLAUDE_MODEL}, effort=${CLAUDE_EFFORT}, cwd=${cwd})`);
 
   const session = unstable_v2_createSession({
     model: CLAUDE_MODEL,
     effort: CLAUDE_EFFORT,
+    cwd,
     permissionMode: "bypassPermissions",
     allowDangerouslySkipPermissions: true,
     autoCompactEnabled: true,
@@ -104,18 +104,19 @@ export async function resumeAndPrompt(
   chatId: string,
   msgTimestamp: number
 ): Promise<void> {
-  console.log(`[${ts()}] Resuming Claude session: ${sessionId} (model=${CLAUDE_MODEL}, effort=${CLAUDE_EFFORT})`);
+  const cwd = (await getSessionInfo(sessionId))?.cwd ?? (await getDefaultCwd());
+  console.log(`[${ts()}] Resuming Claude session: ${sessionId} (model=${CLAUDE_MODEL}, effort=${CLAUDE_EFFORT}, cwd=${cwd})`);
 
   const session = unstable_v2_resumeSession(sessionId, {
     model: CLAUDE_MODEL,
     effort: CLAUDE_EFFORT,
+    cwd,
     permissionMode: "bypassPermissions",
     allowDangerouslySkipPermissions: true,
     autoCompactEnabled: true,
   } as any);
 
   let cardId: string | null = null;
-  let streamingEnabled = false;
   chatSessionMap.set(chatId, {
     gen: ++sessionGen,
     close: () => session.close(),
@@ -152,25 +153,16 @@ export async function resumeAndPrompt(
   });
   if (cardId) {
     const cEntry = chatSessionMap.get(chatId);
-    if (cEntry) { cEntry.cardId = cardId; }
-    const settingsOk = await setCardKitSettings(token, cardId, { streaming_mode: true }, 1).catch((err) => {
-      console.error(`[${ts()}] [CARDIKT] enableStreaming FAIL: chatId=${chatId} cardId=${cardId} ${(err as Error).message}`);
-      fileLog.flush();
-      return false;
-    });
-    const settingsSucceeded = settingsOk !== false;
-    if (settingsSucceeded && cEntry) { cEntry.sequence = 1; }
-    const sendOk = settingsSucceeded ? await sendCardKitMessage(token, chatId, cardId).catch((err) => {
+    if (cEntry) { cEntry.cardId = cardId; cEntry.sequence = 1; }
+    const sendOk = await sendCardKitMessage(token, chatId, cardId).catch((err) => {
       console.error(`[${ts()}] [CARDIKT] sendMessage FAIL: chatId=${chatId} cardId=${cardId} ${(err as Error).message}`);
       fileLog.flush();
       return false;
-    }) : false;
+    });
     if (!sendOk) {
       sendTextReply(token, chatId, "⚠️ 卡片发送失败，将使用文本回复。").catch(() => {});
       cardId = null;
       if (cEntry) { cEntry.cardId = null; cEntry.sequence = 0; }
-    } else {
-      streamingEnabled = true;
     }
   }
 
@@ -181,8 +173,6 @@ export async function resumeAndPrompt(
   let finalText = "";
 
   let cardCreatedAt = Date.now();
-  let cardStartThinkingLen = 0;
-  let cardStartTextLen = 0;
   const CARD_ROTATE_MS = 9 * 60 * 1000; // 飞书 CardKit 流式超时 10 分钟，提前 1 分钟切换
 
   let dotCount = 0;
@@ -199,26 +189,20 @@ export async function resumeAndPrompt(
       cEntry.cardBusy = true;
       const oldCardId = cardId;
       try {
-        // 1. 结束旧卡片的流式模式
+        // 1. 用当前累积内容更新旧卡片为静态版本
         const oldSeqBase = cEntry.sequence;
-        await setCardKitSettings(token, oldCardId!, { streaming_mode: false }, oldSeqBase + 1).catch(() => {});
-        // 2. 用当前累积内容更新旧卡片为静态版本
         const oldDisplay = truncateContent(accumulatedThinking + finalText) || "处理中...";
         const oldCard = buildThinkingCardV2(oldDisplay, { showStop: false, headerTitle: "生成中...（上轮）" });
-        await updateCardKitCard(token, oldCardId!, oldCard, oldSeqBase + 2).catch(() => {});
-        // 3. 创建新卡片
+        await updateCardKitCard(token, oldCardId!, oldCard, oldSeqBase + 1).catch(() => {});
+        // 2. 创建新卡片并发送
         const newCardId = await createCardKitCard(token, buildThinkingCardV2("", { showStop: true, headerTitle: "生成中..." }));
         if (!newCardId) throw new Error("createCardKitCard returned empty");
-        // 4. 开启流式模式并发送
-        await setCardKitSettings(token, newCardId, { streaming_mode: true }, 1);
         await sendCardKitMessage(token, chatId, newCardId);
-        // 5. 切换到新卡片
+        // 3. 切换到新卡片
         cardId = newCardId;
         cEntry.cardId = newCardId;
         cEntry.sequence = 1;
         cardCreatedAt = Date.now();
-        cardStartThinkingLen = accumulatedThinking.length;
-        cardStartTextLen = finalText.length;
         lastSentContent = "";
         streamErrorNotified = false;
         console.log(`[${ts()}] [CARDIKT] rotated: old=${oldCardId} new=${newCardId} (9min timeout)`);
@@ -231,27 +215,27 @@ export async function resumeAndPrompt(
     }
 
     dotCount = (dotCount % 9) + 1;
-    const currentContent = accumulatedThinking.slice(cardStartThinkingLen) + finalText.slice(cardStartTextLen);
-    const content = truncateContent(currentContent + "\n" + ".".repeat(dotCount));
+    const content = truncateContent(accumulatedThinking + finalText + "\n" + "。".repeat(dotCount));
     if (content === lastSentContent) return;
 
     lastSentContent = content;
     cEntry.cardBusy = true;
     const mySeq = cEntry.sequence + 1;
     try {
-      await streamCardKitElement(token, cardId!, "main_content", content, mySeq);
+      const card = buildThinkingCardV2(content, { showStop: true, headerTitle: "生成中..." });
+      await updateCardKitCard(token, cardId!, card, mySeq);
       cEntry.sequence = mySeq;
       cEntry.accumulatedThinking = accumulatedThinking;
       streamErrorNotified = false;
       healthLogTicks++;
       if (healthLogTicks % 10 === 0) {
-        console.log(`[${ts()}] [CARDIKT] stream health: seq=${mySeq} thinking=${accumulatedThinking.length}chars text=${finalText.length}chars cardAge=${Math.round((Date.now() - cardCreatedAt) / 1000)}s`);
+        console.log(`[${ts()}] [CARDIKT] update health: seq=${mySeq} thinking=${accumulatedThinking.length}chars text=${finalText.length}chars cardAge=${Math.round((Date.now() - cardCreatedAt) / 1000)}s`);
       }
     } catch (err) {
-      console.error(`[${ts()}] CardKit stream error: chatId=${chatId} cardId=${cardId} seq=${mySeq} ${(err as Error).message}`);
+      console.error(`[${ts()}] CardKit update error: chatId=${chatId} cardId=${cardId} seq=${mySeq} ${(err as Error).message}`);
       if (!streamErrorNotified) {
         streamErrorNotified = true;
-        sendTextReply(token, chatId, "⚠️ 卡片流式更新失败，结果将以文本形式发送。").catch(() => {});
+        sendTextReply(token, chatId, "⚠️ 卡片更新失败，结果将以文本形式发送。").catch(() => {});
       }
     } finally {
       cEntry.cardBusy = false;
@@ -335,10 +319,7 @@ export async function resumeAndPrompt(
     while (cEntry.cardBusy) {
       await new Promise(r => setTimeout(r, 20));
     }
-    let nextSeq = cEntry.sequence + 1;
-    if (streamingEnabled) {
-      await setCardKitSettings(token, cardId, { streaming_mode: false }, nextSeq++).catch(() => {});
-    }
+    const nextSeq = cEntry.sequence + 1;
     if (wasStopped) {
       const stopCard = buildThinkingCardV2(accumulatedThinking || "已停止", { showStop: false, headerTitle: "已停止", headerTemplate: "red" });
       await updateCardKitCard(token, cardId, stopCard, nextSeq).catch((err) => {