@jeik/dingtalk-connector 0.8.21-fix2 → 0.8.21-fix20

package/README.en.md

@@ -25,6 +25,11 @@
 
 | Date | Tag | Update |
 |------|------|--------|
+| 2026-06-29 | ✨ | **Answer-card mode** (on by default): when the final answer exceeds `answerActToken` (default 600) tokens, the streaming card finalizes to "✅ Done thinking" and the full reply is delivered on a separate **static answer card**, sidestepping DingTalk's official bug where a FINISHED streaming card keeps flickering; short answers stay on the original card. Template/threshold configurable (`answerCardTemplateId` / `answerActToken`) |
+| 2026-06-29 | ✨ | **Tool-call progress**: while a tool runs, the card streams `🔧 Calling tool: <name>`, then updates to the reply when done |
+| 2026-06-29 | 🐛 | **Fixed tool failures being treated as the final answer**: failed tool results (carrying `isError`/`isStatusNotice`, e.g. dws) were occasionally taken as the final answer and stopped rendering early; now excluded per OpenClaw's own rule — shown transiently, never counted as the answer |
+| 2026-06-29 | 🎯 | **Reply marker system**: works with prompt-rewriter's `[-process-]`/`[-final-]` markers — process segments stream token-by-token, `[-final-]` triggers one-shot finalize (no "fake-stream replay"); markers never shown to the user, and take priority over OpenClaw's default fallback |
+| 2026-06-29 | 🔧 | Install wizard: `getInstallSpec` now pins the exact version (fixes "installing the fix build but getting the stable one"); asks whether to skip dws update when already installed; detects & can disable a local plugin copy shadowing the npm version |
 | 2026-06-28 | ✨ | Install wizard now detects existing config: skip QR when a bot already exists; after QR, choose to overwrite or add a bot (bindings maintained automatically, other configs untouched) |
 | 2026-06-28 | 📦 | Now published to npm (`@jeik/dingtalk-connector`) with one-command scan-to-install; `--force` overwrites for updates, no uninstall needed |
 | 2026-06-28 | 🐛 | Fixed the connector mistaking an intermediate progress message for the final answer and ending AI Card rendering too early when the model emits multiple progress messages in one turn (card now finalized only at turn end) |
@@ -68,11 +73,30 @@ Full update log: [FIXES.md](FIXES.md)（[🇨🇳 中文](FIXES.en.md)）
 | `cardContentVar` | Final response content variable, defaults to `msgContent` |
 | `cardProcessVar` | Intermediate process (block status) variable, defaults to `cardContentVar` if not set |
 | `cardToolVar` | Tool call output variable, not written to card if not set |
+| `answerCard` | Answer-card mode switch, **on by default**; set `false` to disable |
+| `answerActToken` | Answer-card trigger threshold (tokens), default `600`; final answer ≤ this stays on the original card, > this opens a separate answer card |
+| `answerCardTemplateId` | Answer-card template ID, uses the built-in default if not set (must contain a `content` variable) |
 
 > Card template must be created in [DingTalk Open Platform](https://open.dingtalk.com/) with matching variable fields.
 
 ---
 
+## 🎯 Reply markers + Answer card + Tool progress (core enhancements)
+
+These make the "process → final answer" rendering on DingTalk cleaner and more stable, working around DingTalk's official streaming AI Card bug:
+
+- **Reply markers**: work with the `[-process-]` (process) / `[-final-]` (final) markers injected by [prompt-rewriter](https://www.npmjs.com/package/@jeik/prompt-rewriter).
+  - Process segments stream token-by-token; once `[-final-]` appears, streaming stops and the card is **finalized in one shot** (no DingTalk "fake-stream replay").
+  - Markers are **never visible to the user** (stripped before writing to the card) and take **priority over** OpenClaw's default fallback — preventing intermediate process text from being mistaken for the final answer and stopping rendering early.
+  - With no markers, behavior follows OpenClaw's default entirely.
+- **Answer-card mode** (on by default): when the final answer exceeds `answerActToken` (default 600) tokens, the **streaming card finalizes to "✅ Done thinking"** and a separate **static answer card** carries the full reply — avoiding DingTalk's bug where a FINISHED streaming card keeps flickering/re-rendering. Short answers stay on the original card, no extra card.
+- **Tool-call progress**: while the Agent calls a tool, the card streams `🔧 Calling tool: <name>`, then updates to the reply when the tool finishes.
+- **Tool failures no longer mis-rendered**: failed tool results (carrying `isError`/`isStatusNotice`) are shown transiently but **never treated as the final answer**.
+
+> Markers require the prompt-rewriter plugin; answer card / tool progress are built into the connector and work out of the box.
+
+---
+
 ## Why Fork?
 
 Due to the sluggish pace of the official DingTalk connector's updates and bug fixes, this repository was forked to keep up with critical fixes.

package/README.md

@@ -25,6 +25,11 @@
 
 | 日期 | 标识 | 更新内容 |
 |------|------|---------|
+| 2026-06-29 | ✨ | **答案卡模式**（默认开启）：最终答案超过 `answerActToken`（默认 600）token 时，原流式卡定格"✅ 思考完成"、另投一张**静态答案卡**，规避钉钉流式卡 FINISHED 后仍抖动的官方 bug；短答案仍在原卡定稿。模板/阈值可配（`answerCardTemplateId` / `answerActToken`） |
+| 2026-06-29 | ✨ | **工具调用进度**：调用工具时原卡流式显示 `🔧 正在调用工具：<工具名>`，结束后正常更新为回复 |
+| 2026-06-29 | 🐛 | **修复工具调用失败被当最终答案**：dws 等工具失败结果（带 `isError`/`isStatusNotice`）以前偶发被当最终答案、提前停渲染；现按 OpenClaw 官方标准排除，仅展示不计入答案 |
+| 2026-06-29 | 🎯 | **回复标记系统**：配合 prompt-rewriter 的 `[-process-]`/`[-final-]` 标记——过程段逐字流式、出现 `[-final-]` 一次性定稿（去掉"假流式回放"）；标记不展示给用户，优先级高于 OpenClaw 默认兜底 |
+| 2026-06-29 | 🔧 | 安装向导：`getInstallSpec` 钉死精确版本（修复"装修复版却被装成正式版"）；dws 已安装时询问是否跳过更新；检测并可禁用遮蔽 npm 版的本地插件副本 |
 | 2026-06-28 | ✨ | 安装向导新增「已存在配置」检测：已有机器人配置可跳过扫码；扫码后可选覆盖或新增机器人（自动维护 bindings、不覆盖其它配置） |
 | 2026-06-28 | 📦 | 改为发布到 npm（`@jeik/dingtalk-connector`），新增一键扫码安装命令；`--force` 覆盖更新无需卸载 |
 | 2026-06-28 | 🐛 | 修复模型一轮内发送多条过程消息时，连接器把中间过程消息当成最终答案、提前结束 AI Card 渲染的问题（改为整轮结束才定稿卡片） |
@@ -104,9 +109,28 @@
 | `cardContentVar` | 最终回复内容变量名，不填默认 `msgContent` |
 | `cardProcessVar` | 中间过程（block 状态）变量名，不填默认使用 `cardContentVar` |
 | `cardToolVar` | 工具调用输出变量名，不填则不写入卡片 |
+| `answerCard` | 答案卡模式开关，**默认开启**；显式设 `false` 关闭 |
+| `answerActToken` | 答案卡触发阈值（token），默认 `600`；最终答案 ≤ 此值直接在原卡定稿，> 此值才另开答案卡 |
+| `answerCardTemplateId` | 答案卡模板 ID，不填用内置默认模板（需含 `content` 变量） |
 
 > 卡片模板需在[钉钉开放平台](https://open.dingtalk.com/)创建，并添加对应的变量字段。
 
+---
+
+## 🎯 回复标记 + 答案卡 + 工具进度（核心增强）
+
+这套机制让钉钉侧的「过程 → 最终答案」渲染更干净、更稳定，规避钉钉流式 AI Card 的官方渲染 bug：
+
+- **回复标记**：配合 [prompt-rewriter](https://www.npmjs.com/package/@jeik/prompt-rewriter) 注入的 `[-process-]`（过程段）/`[-final-]`（最终答案）标记。
+  - 过程段逐字流式滚动；出现 `[-final-]` 后**停止流式、一次性定稿**（去掉钉钉"假流式回放"）。
+  - 标记对用户**完全不可见**（进卡前统一剥离），且**优先级高于** OpenClaw 默认兜底——避免中间过程被误判成最终答案、提前停渲染。
+  - 无标记时完全走 OpenClaw 默认逻辑。
+- **答案卡模式**（默认开启）：最终答案 token 超过 `answerActToken`（默认 600）时，**原流式卡定格"✅ 思考完成"**，另投一张**静态答案卡**承载完整回复——规避钉钉流式卡 FINISHED 后仍抖动/重渲染的 bug。短答案仍在原卡定稿，不多开卡。
+- **工具调用进度**：Agent 调用工具时，原卡流式显示 `🔧 正在调用工具：<工具名>`，工具结束后正常更新为回复。
+- **工具失败不再误判**：工具调用失败的结果（带 `isError`/`isStatusNotice`）只在卡片短暂展示，**不会被当成最终答案**。
+
+> 标记功能需安装并启用 prompt-rewriter 插件；答案卡/工具进度为连接器内置，开箱即用。
+
 **效果预览：**
 
 ![自定义卡片效果](assets/image.png)

package/bin/dingtalk-connector.js

@@ -7,7 +7,7 @@
  *   node bin/dingtalk-connector.js install --local              # local dev
  */
 import { createRequire } from 'node:module';
-import { readFileSync, writeFileSync, mkdirSync, rmSync, existsSync } from 'node:fs';
+import { readFileSync, writeFileSync, mkdirSync, rmSync, existsSync, readdirSync, renameSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import {
@@ -294,16 +294,68 @@ function saveCredentials(clientId, clientSecret, { isLocal = false, pluginInstal
 
 // ── plugin install ─────────────────────────────────────────────
 function getInstallSpec() {
-  // Read version from own package.json to pass the exact version to openclaw
+  // 永远钉住"本包自己的精确版本"，让 openclaw 内部装的版本 == 你 npx 实际下到的版本。
+  // npx @fix / @0.8.21-fix7 / @latest / 不带 → 各自下到对应包 → 这里读到的就是那个版本。
+  // 不带版本号会让 openclaw 装 latest，导致"跑 fix 向导却装了正式版"那个坑。
   try {
-    const require = createRequire(import.meta.url);
-    const { version } = require('../package.json');
-    if (version && /-(alpha|beta|rc|canary)/.test(version)) {
-      // prerelease → use exact version so openclaw accepts it
-      return `${PKG_NAME}@${version}`;
-    }
+    const { version } = createRequire(import.meta.url)('../package.json');
+    if (version) return `${PKG_NAME}@${version}`;
   } catch {}
-  return PKG_NAME;
+  return PKG_NAME; // 兜底：读不到版本才退回不带版本（极少见）
+}
+
+// 在 plugins.load.paths 扫描范围内找会"遮蔽"npm 版的本地 dingtalk 插件副本。
+// 原理：load.paths 扫到的插件 origin=config，优先级（rank 0）高于 npm 安装的 global（rank 2），
+// 所以一份本地克隆会永久压过 npm 版，--force 重装也没用。这里浅扫一层定位它。
+// ponytail: 只扫 load.paths 下一层目录；克隆嵌套更深的极少见，需要再加深度。
+function findShadowingLocalPlugin(paths = readConfig()?.plugins?.load?.paths) {
+  if (!Array.isArray(paths)) return null;
+  const npmRoot = join(homedir(), '.openclaw', 'npm');
+  for (const p of paths) {
+    if (typeof p !== 'string') continue;
+    const base = p.startsWith('~') ? join(homedir(), p.slice(1)) : p;
+    let entries;
+    try { entries = readdirSync(base, { withFileTypes: true }); } catch { continue; }
+    for (const e of entries) {
+      if (!e.isDirectory()) continue;
+      // OpenClaw 扫描会跳过这些名字（discovery shouldIgnoreScannedDirectory），它们不会遮蔽，
+      // 已禁用的 .disabled 目录也在此跳过，避免重复禁用成 .disabled.disabled。
+      const lower = e.name.toLowerCase();
+      if (lower.endsWith('.bak') || lower.includes('.backup-') || lower.includes('.disabled')) continue;
+      const dir = join(base, e.name);
+      if (dir.startsWith(npmRoot)) continue; // npm 安装目录本身不算遮蔽
+      try {
+        const pkg = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf-8'));
+        const channels = pkg?.openclaw?.channels;
+        if (pkg?.name === PKG_NAME || (Array.isArray(channels) && channels.includes(CHANNEL_ID))) {
+          return dir;
+        }
+      } catch {}
+    }
+  }
+  return null;
+}
+
+// 检测并（经确认后）禁用遮蔽 npm 版的本地副本：把目录重命名为 .disabled（可随时改回）。
+async function resolvePluginShadow() {
+  const shadow = findShadowingLocalPlugin();
+  if (!shadow) return;
+  console.log('\n' + orange('⚠ 检测到本地插件副本会覆盖刚装的 npm 版：'));
+  console.log(dim(`    ${shadow}`));
+  console.log(dim('    它在 plugins.load.paths 扫描范围内，优先级高于 npm 版，网关会一直用这份旧本地代码。') + '\n');
+  const ans = await askUserConfirmation('  是否禁用它（重命名为 .disabled，随时可改回）？[Y/n] ');
+  if (ans === 'n' || ans === 'no') {
+    console.log(dim('  已跳过。网关仍会用本地版；如需用 npm 版，请手动移走该目录或从 plugins.load.paths 移除其父路径。') + '\n');
+    return;
+  }
+  const disabled = shadow + '.disabled';
+  try {
+    if (existsSync(disabled)) rmSync(disabled, { recursive: true, force: true });
+    renameSync(shadow, disabled);
+    console.log(green(`  ✔ 已禁用：${shadow} → ${disabled}`) + '\n');
+  } catch (err) {
+    console.log(red(`  ⚠ 重命名失败：${err.message}。请手动处理该目录。`) + '\n');
+  }
 }
 
 function installPlugin(force = false) {
@@ -611,14 +663,21 @@ async function ensureDwsCli() {
     const versionDisplay = installedVersion ? `v${installedVersion}` : 'unknown version';
 
     if (!targetVersion) {
-      // @latest 模式：解析不到固定版本号 → 始终重装拉最新（latest 不会降级，无需比较/询问）
-      console.log(dim(`  ℹ dws CLI detected (${versionDisplay}), ensuring latest (@latest)...`) + '\n');
-      const ok = installDwsCli();
-      if (ok) {
-        const nv = getInstalledDwsVersion();
-        console.log(green(`  ✔ dws CLI is now ${nv ? 'v' + nv : 'latest'}`) + '\n');
+      // @latest 模式：已安装则询问是否跳过更新（默认跳过，保留当前版本）
+      const ans = await askUserConfirmation(
+        `  检测到 dws CLI 已安装 (${versionDisplay})，是否跳过更新？(skip dws update?) [Y/n] `,
+      );
+      if (ans === 'n' || ans === 'no') {
+        console.log(dim(`  正在更新 dws CLI 到最新版...`) + '\n');
+        const ok = installDwsCli();
+        if (ok) {
+          const nv = getInstalledDwsVersion();
+          console.log(green(`  ✔ dws CLI is now ${nv ? 'v' + nv : 'latest'}`) + '\n');
+        } else {
+          console.log(red('  ⚠ Update failed. Continuing with current version.') + '\n');
+        }
       } else {
-        console.log(red('  ⚠ Update failed. Continuing with current version.') + '\n');
+        console.log(dim(`  已跳过更新，保留当前版本 ${versionDisplay}。`) + '\n');
       }
       // 鉴权状态检查（与下方同逻辑）
       if (isDwsAuthenticated()) {
@@ -731,10 +790,18 @@ Options:
     globalThis['proc' + 'ess'].exit(1);
   }
 
+  // 打印当前安装向导版本（= 本包版本），方便确认装的是哪一版
+  try {
+    const { version } = createRequire(import.meta.url)('../package.json');
+    console.log('\n' + cyan(`${PKG_NAME} v${version}`) + dim(' (install wizard)'));
+  } catch {}
+
   // Step 1: Install connector plugin (unless --local)
   let pluginInstalled = true;
   if (!isLocal) {
     pluginInstalled = installPlugin(force);
+    // 安装成功后检查是否有本地副本会遮蔽 npm 版（load.paths 优先级更高），有则确认禁用
+    if (pluginInstalled) await resolvePluginShadow();
   } else {
     console.log('\n' + dim('📦 --local mode: skipping plugin install') + '\n');
   }

package/dist/entry-bundled.mjs

@@ -23,7 +23,7 @@ var entry_bundled_default = defineBundledChannelEntry({
 		exportName: "setDingtalkRuntime"
 	},
 	async registerFull(api) {
-		const { registerGatewayMethods } = await import("./gateway-methods-Ci31A3vg.mjs");
+		const { registerGatewayMethods } = await import("./gateway-methods-B0DOSk85.mjs");
 		registerGatewayMethods(api);
 	}
 });

package/dist/{gateway-methods-Ci31A3vg.mjs → gateway-methods-B0DOSk85.mjs}

@@ -1,2 +1,2 @@
-import { t as registerGatewayMethods } from "./gateway-methods-C4tcgI7P.mjs";
+import { t as registerGatewayMethods } from "./gateway-methods-C_-LGxry.mjs";
 export { registerGatewayMethods };

package/dist/{gateway-methods-C4tcgI7P.mjs → gateway-methods-C_-LGxry.mjs}

@@ -1,7 +1,7 @@
 import { a as resolveDingtalkAccount, t as listDingtalkAccountIds } from "./accounts-BAzdqkAV.mjs";
 import { t as dingtalkHttp } from "./http-client-DFWZgO1n.mjs";
 import { r as getAccessToken, t as DINGTALK_API } from "./utils-CIfI_3Jh.mjs";
-import { c as prepareMultiBotMentions, i as sendProactive, s as buildBotMentionTable, u as finishAICard } from "./messaging-B6l1sRvX.mjs";
+import { c as prepareMultiBotMentions, d as finishAICard, i as sendProactive, s as buildBotMentionTable } from "./messaging-CwnCFf5X.mjs";
 import { c as getUnionId, d as recallEmotionReply } from "./utils-legacy-CALCPP1t.mjs";
 //#region src/docs.ts
 var DingtalkDocsClient = class {

package/dist/index.d.mts

@@ -78,6 +78,9 @@ declare const DingtalkConfigSchema: z$1.ZodObject<{
     cardContentVar: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodString>>;
     cardProcessVar: z$1.ZodOptional<z$1.ZodString>;
     cardToolVar: z$1.ZodOptional<z$1.ZodString>;
+    answerCard: z$1.ZodOptional<z$1.ZodBoolean>;
+    answerActToken: z$1.ZodOptional<z$1.ZodNumber>;
+    answerCardTemplateId: z$1.ZodOptional<z$1.ZodString>;
     enabled: z$1.ZodOptional<z$1.ZodBoolean>;
     name: z$1.ZodOptional<z$1.ZodString>;
     clientId: z$1.ZodOptional<z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodNumber]>>;
@@ -133,6 +136,9 @@ declare const DingtalkConfigSchema: z$1.ZodObject<{
   cardContentVar: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodString>>;
   cardProcessVar: z$1.ZodOptional<z$1.ZodString>;
   cardToolVar: z$1.ZodOptional<z$1.ZodString>;
+  answerCard: z$1.ZodOptional<z$1.ZodBoolean>;
+  answerActToken: z$1.ZodOptional<z$1.ZodNumber>;
+  answerCardTemplateId: z$1.ZodOptional<z$1.ZodString>;
   enabled: z$1.ZodOptional<z$1.ZodBoolean>;
   defaultAccount: z$1.ZodOptional<z$1.ZodString>;
   clientId: z$1.ZodOptional<z$1.ZodUnion<readonly [z$1.ZodString, z$1.ZodNumber]>>;

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { a as initDingtalkPluginConfigSchema, i as dingtalkPlugin, n as setDingtalkRuntime } from "./runtime-DUgpo5zC.mjs";
-import { t as registerGatewayMethods } from "./gateway-methods-C4tcgI7P.mjs";
+import { a as initDingtalkPluginConfigSchema, i as dingtalkPlugin, n as setDingtalkRuntime } from "./runtime-BwR6sJlg.mjs";
+import { t as registerGatewayMethods } from "./gateway-methods-C_-LGxry.mjs";
 //#region index.ts
 /**
 * 检测同一 plugin id 在多个路径被加载的情况。

package/dist/{message-handler-DESzFFDc.mjs → message-handler-bAfOGSbU.mjs}

@@ -1,10 +1,10 @@
 import { u as uploadMediaToDingTalk } from "./media-cz72EVS3.mjs";
 import { a as resolveDingtalkAccount } from "./accounts-BAzdqkAV.mjs";
-import { r as CHANNEL_ID, t as getDingtalkRuntime } from "./runtime-DUgpo5zC.mjs";
+import { r as CHANNEL_ID, t as getDingtalkRuntime } from "./runtime-BwR6sJlg.mjs";
 import { n as createLoggerFromConfig } from "./logger-mZ9OSbmD.mjs";
 import { t as dingtalkHttp } from "./http-client-DFWZgO1n.mjs";
 import { i as getOapiAccessToken } from "./utils-CIfI_3Jh.mjs";
-import { a as sendTextMessage, f as isQpsLimitError, h as unregisterActiveCard, i as sendProactive, l as createAICardForTarget, m as streamAICard, p as registerActiveCard, r as sendMessage, t as sendMarkdownMessage, u as finishAICard } from "./messaging-B6l1sRvX.mjs";
+import { S as finalClean, _ as FINAL_TAG, a as sendTextMessage, b as estimateTokens, d as finishAICard, g as unregisterActiveCard, h as streamAICard, i as sendProactive, m as registerActiveCard, p as isQpsLimitError, r as sendMessage, t as sendMarkdownMessage, u as createAICardForTarget, v as PROCESS_TAG, x as extractFinal, y as displayClean } from "./messaging-CwnCFf5X.mjs";
 import { a as QUEUE_BUSY_ACK_PHRASES, n as normalizeSlashCommand, t as buildSessionContext } from "./session-DJ4jYqPv.mjs";
 import { d as recallEmotionReply, o as getAccessToken, r as addEmotionReply, s as getOapiAccessToken$1, t as DINGTALK_API } from "./utils-legacy-CALCPP1t.mjs";
 import "./chunk-upload-BBQgGtcZ.mjs";
@@ -204,42 +204,6 @@ async function uploadAndReplaceFileMarkers(content, sessionWebhook, config, oapi
 	return result;
 }
 //#endregion
-//#region src/services/reply-markers.ts
-const PROCESS_TAG = "[-process-]";
-const FINAL_TAG = "[-final-]";
-const EDGE_WS = /^[ \t\r\n]+|[ \t\r\n]+$/g;
-/** 取最终答案：去掉那一个 [-final-]（开头/中间/结尾都行），其余原样，首尾空白清掉。
-*  没有 [-final-] 返回 null。多处出现取最后一个当信号。 */
-function extractFinal(text) {
-	if (!text) return null;
-	const i = text.lastIndexOf(FINAL_TAG);
-	if (i < 0) return null;
-	return (text.slice(0, i) + text.slice(i + 9)).replace(EDGE_WS, "");
-}
-/** 剥掉一个标记 token（[-process-] 或 [-final-]，位置无关，取最后一个），其余原样，首尾空白清掉。 */
-function stripOneMarker(text) {
-	if (!text) return "";
-	const pi = text.lastIndexOf(PROCESS_TAG);
-	const fi = text.lastIndexOf(FINAL_TAG);
-	if (pi < 0 && fi < 0) return text.replace(EDGE_WS, "");
-	const [i, len] = fi >= pi ? [fi, 9] : [pi, 11];
-	return (text.slice(0, i) + text.slice(i + len)).replace(EDGE_WS, "");
-}
-/** 去掉流式途中末尾未闭合的半截标记（如 "[-fin"，缺右 "]"）。完整标记交给上面两个函数。 */
-function stripPartialTail(text) {
-	if (!text) return "";
-	return text.replace(/\[-[a-z]*-?$/i, "");
-}
-/** 定稿用：有 [-final-] 去掉它；否则剥一个标记。正文不动。 */
-function finalClean(text) {
-	return extractFinal(text) ?? stripOneMarker(text);
-}
-/** 流式展示用：有 [-final-] 直接显示最终答案；否则剥一个标记 + 半截标记，正文不动。 */
-function displayClean(text) {
-	const fin = extractFinal(text);
-	return fin !== null ? fin : stripPartialTail(stripOneMarker(text));
-}
-//#endregion
 //#region src/reply-dispatcher.ts
 const { createReplyPrefixOptions, createTypingCallbacks, logTypingFailure } = await import("openclaw/plugin-sdk/channel-runtime");
 function createDingtalkReplyDispatcher(params) {
@@ -265,24 +229,34 @@ function createDingtalkReplyDispatcher(params) {
 	let lastAnswerText = "";
 	let processMarkerLogged = false;
 	let finalMarkerLogged = false;
-	const observeReply = (raw, isReasoning) => {
+	let markerSystemActive = false;
+	const isNonAnswerPayload = (p) => Boolean(p) && Boolean(p.isError || p.isStatusNotice || p.isCompactionNotice || p.isFallbackNotice);
+	const observeReply = (raw, payload) => {
 		const text = raw ?? "";
 		if (!text) return;
-		if (!processMarkerLogged && text.includes("[-process-]")) {
-			processMarkerLogged = true;
-			log.info(`[DingTalk][marker] 检测到过程标记 ${PROCESS_TAG}（已剥离，不展示给用户）`);
-		}
+		if (isNonAnswerPayload(payload)) return;
+		const isReasoning = payload?.isReasoning;
 		const fin = extractFinal(text);
 		if (fin !== null) {
 			if (!finalMarkerLogged) {
 				finalMarkerLogged = true;
-				log.info(`[DingTalk][marker] 检测到最终标记 ${FINAL_TAG}（已剥离，以其后内容为最终答案）`);
+				log.info(`[DingTalk][marker] 检测到 ${FINAL_TAG}，最终答案=剥光标记的完整正文，跳过 OpenClaw 兜底`);
 			}
 			finalMarkedText = fin;
+			markerSystemActive = true;
+			return;
+		}
+		if (text.includes("[-process-]")) {
+			if (!processMarkerLogged) {
+				processMarkerLogged = true;
+				log.info(`[DingTalk][marker] 检测到 ${PROCESS_TAG}（过程段），抑制 OpenClaw 默认兜底`);
+			}
+			markerSystemActive = true;
+			return;
 		}
-		if (!isReasoning && text.trim()) lastAnswerText = text;
+		if (!markerSystemActive && !isReasoning && text.trim()) lastAnswerText = text;
 	};
-	const pickFinalText = () => finalMarkedText ?? (lastAnswerText || accumulatedText);
+	const pickFinalText = () => markerSystemActive ? finalMarkedText ?? accumulatedText : lastAnswerText || accumulatedText;
 	const applyReplyTemplate = async (text) => {
 		try {
 			const runner = getGlobalHookRunner?.();
@@ -428,6 +402,7 @@ function createDingtalkReplyDispatcher(params) {
 		log.info(`[DingTalk][closeStreaming] 开始关闭 AI Card...`);
 		try {
 			let finalText = finalClean(pickFinalText());
+			const hadRealAnswer = finalText.trim().length > 0;
 			log.info(`[DingTalk][closeStreaming] 最终答案来源=${finalMarkedText !== null ? "marker[-final-]" : lastAnswerText ? "非reasoning答案" : "accumulatedText兜底"}，长度=${finalText.length}`);
 			if (!finalText.trim()) {
 				finalText = "✅ 任务执行完成（无文本输出）";
@@ -479,9 +454,45 @@ function createDingtalkReplyDispatcher(params) {
 				log.warn(`[DingTalk][closeStreaming] 养成系统处理失败（不影响主流程）: ${gamErr?.message || gamErr}`);
 			}
 			finalText = await applyReplyTemplate(finalText);
-			log.info(`[DingTalk][closeStreaming] 准备调用 finishAICard，文本长度=${finalText.length}`);
-			log.debug(`[DingTalk][closeStreaming] 最终发送内容长度=${finalText.length}`);
-			await finishAICard(cardSnapshot, finalText, account.config, log);
+			if (account.config?.answerCard !== false) {
+				const finalizeOriginalToDone = async () => {
+					try {
+						await streamAICard(cardSnapshot, "✅ 思考完成", true, account.config, log);
+						await finishAICard(cardSnapshot, "✅ 思考完成", account.config, log);
+					} catch (e) {
+						log.warn(`[DingTalk][closeStreaming] 原卡定格思考完成失败（忽略）：${e?.message || e}`);
+					}
+				};
+				const answerTplId = (account.config?.answerCardTemplateId)?.trim() || "d246b7f5-1783-4e9b-bb46-bef52d63050e.schema";
+				const answerActToken = Number(account.config?.answerActToken) || 600;
+				const answerTokens = estimateTokens(finalText);
+				if (!hadRealAnswer) {
+					log.info(`[DingTalk][closeStreaming] answerCard 模式：无真实答案，仅定格原卡思考完成（不建答案卡）`);
+					await finalizeOriginalToDone();
+				} else if (answerTokens <= answerActToken) {
+					log.info(`[DingTalk][closeStreaming] answerCard 模式：答案约 ${answerTokens} token ≤ ${answerActToken}，原卡直接定稿（不建答案卡）`);
+					try {
+						await streamAICard(cardSnapshot, finalText, true, account.config, log);
+					} catch (e) {
+						if (!isQpsLimitError(e)) log.warn(`[DingTalk][closeStreaming] 原卡流式覆盖最终答案失败（忽略，继续 FINISHED）：${e?.message || e}`);
+					}
+					await finishAICard(cardSnapshot, finalText, account.config, log);
+				} else {
+					log.info(`[DingTalk][closeStreaming] answerCard 模式：答案约 ${answerTokens} token > ${answerActToken}，原卡思考完成 + 新建答案卡（模板=${answerTplId}）`);
+					await finalizeOriginalToDone();
+					const answerCard = await createAICardForTarget(account.config, target, log, answerTplId);
+					if (answerCard) {
+						await finishAICard(answerCard, finalText, account.config, log);
+						log.info(`[DingTalk][closeStreaming] ✅ 答案卡投放成功`);
+					} else {
+						log.warn(`[DingTalk][closeStreaming] 答案卡创建失败，降级定稿原卡`);
+						await finishAICard(cardSnapshot, finalText, account.config, log);
+					}
+				}
+			} else {
+				log.info(`[DingTalk][closeStreaming] 准备调用 finishAICard，文本长度=${finalText.length}`);
+				await finishAICard(cardSnapshot, finalText, account.config, log);
+			}
 			log.info(`[DingTalk][closeStreaming] ✅ AI Card 关闭成功`);
 		} catch (error) {
 			log.error(`[DingTalk][closeStreaming] ❌ AI Card 关闭失败：${error?.message || String(error)}`);
@@ -511,14 +522,28 @@ function createDingtalkReplyDispatcher(params) {
 			lastAnswerText = "";
 			processMarkerLogged = false;
 			finalMarkerLogged = false;
-			if (streamingEnabled) startStreaming();
+			markerSystemActive = false;
 			typingCallbacks.onActive?.();
 		},
 		deliver: async (payload, info) => {
 			let text = payload.text ?? "";
-			log.info(`[DingTalk][deliver] 被调用：kind=${info?.kind}, textLength=${text.length}, hasText=${Boolean(text.trim())}`);
-			log.debug(`[DingTalk][deliver] payload keys=${Object.keys(payload).join(",")}, info.kind=${info?.kind}`);
-			observeReply(payload.text, payload.isReasoning);
+			log.debug(`[DingTalk][deliver] kind=${info?.kind}, textLength=${text.length}`);
+			observeReply(payload.text, payload);
+			if (isNonAnswerPayload(payload)) {
+				if (streamingEnabled && currentCardTarget && !asyncMode && finalMarkedText === null) {
+					const now = Date.now();
+					if (now - lastUpdateTime >= updateInterval) {
+						lastUpdateTime = now;
+						try {
+							await streamAICard(currentCardTarget, displayClean(text), false, account.config, log, account.config?.cardContentVar || "msgContent");
+						} catch (e) {
+							if (!isQpsLimitError(e)) log.warn(`[DingTalk][deliver] 状态/错误 payload 写卡失败：${e?.message || e}`);
+						}
+					}
+				}
+				log.info(`[DingTalk][deliver] 非答案 payload（isError=${payload.isError},isStatusNotice=${payload.isStatusNotice}），仅展示不计入最终答案`);
+				return;
+			}
 			if (info?.kind === "final" && text.trim()) {
 				const target = isDirect ? {
 					type: "user",
@@ -638,32 +663,30 @@ function createDingtalkReplyDispatcher(params) {
 		replyOptions: {
 			...replyOptions,
 			onModelSelected,
+			allowToolLifecycleWhenProgressHidden: true,
+			suppressDefaultToolProgressMessages: true,
 			...streamingEnabled && { onPartialReply: async (payload) => {
-				log.info(`[DingTalk][onPartialReply] 被调用，payload.text=${payload.text ? payload.text.length : "null"}`);
-				log.debug(`[DingTalk][onPartialReply] textLength=${payload.text?.length ?? 0}`);
-				if (!payload.text) {
-					log.debug(`[DingTalk][onPartialReply] 空文本，跳过`);
-					return;
-				}
-				log.debug(`[DingTalk][onPartialReply] 收到部分响应，文本长度=${payload.text.length}`);
-				observeReply(payload.text, payload.isReasoning);
+				if (!payload.text) return;
+				observeReply(payload.text, payload);
+				if (isNonAnswerPayload(payload)) return;
 				if (asyncMode) {
-					log.debug(`[DingTalk][onPartialReply] 异步模式，累积响应`);
 					asyncModeFullResponse = finalClean(finalMarkedText ?? payload.text);
 					return;
 				}
+				if (finalMarkedText !== null) {
+					accumulatedText = payload.text;
+					return;
+				}
 				await startStreaming();
 				if (currentCardTarget) {
 					accumulatedText = payload.text;
 					const now = Date.now();
 					if (now - lastUpdateTime >= updateInterval) {
 						const { FILE_MARKER_PATTERN, VIDEO_MARKER_PATTERN, AUDIO_MARKER_PATTERN } = await import("./common-C8pYKU_y.mjs");
-						const displayContent = displayClean(finalMarkedText ?? accumulatedText).replace(FILE_MARKER_PATTERN, "").replace(VIDEO_MARKER_PATTERN, "").replace(AUDIO_MARKER_PATTERN, "").trim();
-						log.debug(`[DingTalk][onPartialReply] 更新 AI Card，显示文本长度=${displayContent.length}`);
+						const displayContent = displayClean(accumulatedText).replace(FILE_MARKER_PATTERN, "").replace(VIDEO_MARKER_PATTERN, "").replace(AUDIO_MARKER_PATTERN, "").trim();
 						lastUpdateTime = now;
 						try {
 							await streamAICard(currentCardTarget, displayContent, false, account.config, log, account.config?.cardContentVar || "msgContent");
-							log.debug(`[DingTalk][onPartialReply] ✅ AI Card 更新成功`);
 						} catch (err) {
 							if (isQpsLimitError(err)) log.warn(`[DingTalk][onPartialReply] AI Card 流式更新遇到 QPS 限流，已在内部退避重试；本次跳过，等待下一次 partial 更新补齐内容`);
 							else {
@@ -671,9 +694,26 @@ function createDingtalkReplyDispatcher(params) {
 								await sendFallbackErrorMessage("sendMessage", err.message);
 							}
 						}
-					} else log.debug(`[DingTalk][onPartialReply] 节流控制，跳过本次更新（距离上次更新 ${now - lastUpdateTime}ms）`);
-				} else log.warn(`[DingTalk][onPartialReply] ⚠️ AI Card 不存在，跳过更新`);
+					}
+				}
 			} },
+			onToolStart: async (payload) => {
+				const toolName = (payload?.name || "").trim();
+				if (!toolName) return;
+				if (payload?.phase === "end" || payload?.phase === "complete") return;
+				if (!streamingEnabled || asyncMode || finalMarkedText !== null) return;
+				try {
+					await startStreaming();
+					if (!currentCardTarget) return;
+					const now = Date.now();
+					if (now - lastUpdateTime < updateInterval) return;
+					lastUpdateTime = now;
+					await streamAICard(currentCardTarget, `🔧 正在调用工具：${toolName}`, false, account.config, log, account.config?.cardContentVar || "msgContent");
+					log.debug(`[DingTalk][onToolStart] 工具进度写卡：${toolName}（phase=${payload?.phase}）`);
+				} catch (e) {
+					if (!isQpsLimitError(e)) log.warn(`[DingTalk][onToolStart] 工具进度写卡失败：${e?.message || e}`);
+				}
+			},
 			onCommandOutput: (payload) => {
 				const dwsMatch = (payload.title || payload.name || "").match(DWS_PRODUCT_PATTERN) || payload.output?.match(DWS_PRODUCT_PATTERN);
 				if (dwsMatch) {