@jeik/dingtalk-connector 0.8.21-fix7 → 0.8.21-fix9

package/bin/dingtalk-connector.js

@@ -294,16 +294,14 @@ 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');
-    // 任何预发布版（含 -）都钉精确版本，否则 openclaw 会装 latest（如 -fix6 被当稳定版误装成 0.8.21）
-    if (version && version.includes('-')) {
-      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 插件副本。
@@ -665,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()) {

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-D7aACzCW.mjs");
+		const { registerGatewayMethods } = await import("./gateway-methods-B9kuAOFf.mjs");
 		registerGatewayMethods(api);
 	}
 });

package/dist/{gateway-methods-D7aACzCW.mjs → gateway-methods-B9kuAOFf.mjs}

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

package/dist/{gateway-methods-DM8lWI4F.mjs → gateway-methods-DfW2oZ6c.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-CBQl0D00.mjs";
+import { c as prepareMultiBotMentions, i as sendProactive, s as buildBotMentionTable, u as finishAICard } from "./messaging-CvZBBMgv.mjs";
 import { c as getUnionId, d as recallEmotionReply } from "./utils-legacy-CALCPP1t.mjs";
 //#region src/docs.ts
 var DingtalkDocsClient = class {

package/dist/index.mjs

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

package/dist/{message-handler-CqC0-7FJ.mjs → message-handler-CWW2dKz0.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-5-KOSMI9.mjs";
+import { r as CHANNEL_ID, t as getDingtalkRuntime } from "./runtime-CUSz0JLV.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 { _ as PROCESS_TAG, a as sendTextMessage, b as finalClean, f as isQpsLimitError, g as FINAL_TAG, h as unregisterActiveCard, i as sendProactive, l as createAICardForTarget, m as streamAICard, p as registerActiveCard, r as sendMessage, t as sendMarkdownMessage, u as finishAICard, v as displayClean, y as extractFinal } from "./messaging-CBQl0D00.mjs";
+import { _ as PROCESS_TAG, a as sendTextMessage, b as finalClean, f as isQpsLimitError, g as FINAL_TAG, h as unregisterActiveCard, i as sendProactive, l as createAICardForTarget, m as streamAICard, p as registerActiveCard, r as sendMessage, t as sendMarkdownMessage, u as finishAICard, v as displayClean, y as extractFinal } from "./messaging-CvZBBMgv.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";
@@ -233,22 +233,20 @@ function createDingtalkReplyDispatcher(params) {
 	const observeReply = (raw, isReasoning) => {
 		const text = raw ?? "";
 		if (!text) return;
-		const headTag = text.startsWith("[-final-]") ? "final" : text.startsWith("[-process-]") ? "process" : null;
-		const tailTag = text.endsWith("[-final-]") ? "final" : text.endsWith("[-process-]") ? "process" : null;
-		const abnormal = headTag !== null && tailTag !== null && headTag !== tailTag;
-		if (!abnormal && (headTag === "final" || tailTag === "final")) {
+		const fin = extractFinal(text);
+		if (fin !== null) {
 			if (!finalMarkerLogged) {
 				finalMarkerLogged = true;
-				log.info(`[DingTalk][marker] 检测到最终标记 ${FINAL_TAG}（头尾），标记系统激活，跳过 OpenClaw 默认兜底`);
+				log.info(`[DingTalk][marker] 检测到 ${FINAL_TAG}，最终答案取最后一个 ${PROCESS_TAG} 之后内容，跳过 OpenClaw 兜底`);
 			}
-			finalMarkedText = extractFinal(text);
+			finalMarkedText = fin;
 			markerSystemActive = true;
 			return;
 		}
-		if (!abnormal && (headTag === "process" || tailTag === "process")) {
+		if (text.includes("[-process-]")) {
 			if (!processMarkerLogged) {
 				processMarkerLogged = true;
-				log.info(`[DingTalk][marker] 检测到过程标记 ${PROCESS_TAG}（头尾），标记系统激活，抑制 OpenClaw 默认兜底`);
+				log.info(`[DingTalk][marker] 检测到 ${PROCESS_TAG}（过程段），抑制 OpenClaw 默认兜底`);
 			}
 			markerSystemActive = true;
 			return;
@@ -485,7 +483,6 @@ function createDingtalkReplyDispatcher(params) {
 			processMarkerLogged = false;
 			finalMarkerLogged = false;
 			markerSystemActive = false;
-			if (streamingEnabled) startStreaming();
 			typingCallbacks.onActive?.();
 		},
 		deliver: async (payload, info) => {

package/dist/{messaging-CBQl0D00.mjs → messaging-CvZBBMgv.mjs}

@@ -7,43 +7,44 @@ import { r as MEDIA_MSG_TYPES } from "./session-DJ4jYqPv.mjs";
 const PROCESS_TAG = "[-process-]";
 const FINAL_TAG = "[-final-]";
 const EDGE_WS = /^[ \t\r\n]+|[ \t\r\n]+$/g;
-/** 取最终答案：只剥头尾的 [-final-]，中间的保留。
-*  头尾都没有 [-final-] → null（不是最终答案）。
-*  剥完头尾 final 后若另一端仍是 [-process-]（如 [-process-]X[-final-]）→ 异常，返回 null 走兜底。 */
+const HR_LINE = /^[ \t]*(?:[-*_][ \t]*){3,}(?:\r?\n|$)/;
+/** 剥掉文本中所有 [-process-] / [-final-] 标记（含中间的），首尾空白清掉。 */
+function stripAllMarkers(text) {
+	if (!text) return "";
+	return text.split(PROCESS_TAG).join("").split(FINAL_TAG).join("").replace(EDGE_WS, "");
+}
+/** 清掉段落开头的空白行 + markdown 分割横线（反复剥，处理 "\n\n---\n" 这种）。 */
+function stripLeadingSeparators(text) {
+	let s = text.replace(/^[ \t\r\n]+/, "");
+	let m;
+	while ((m = s.match(HR_LINE)) && m[0].length > 0) s = s.slice(m[0].length).replace(/^[ \t\r\n]+/, "");
+	return s;
+}
+/** 取最终答案：取「最后一个 [-process-] 右边、[-final-] 左边」那段，剥残留标记 + 开头分隔，首尾清白。
+*  没有 [-final-] → null（不是最终答案，交给 OpenClaw 兜底）。 */
 function extractFinal(text) {
 	if (!text) return null;
-	const headIsFinal = text.startsWith(FINAL_TAG);
-	const tailIsFinal = text.endsWith(FINAL_TAG);
-	if (!headIsFinal && !tailIsFinal) return null;
-	let result = text;
-	if (headIsFinal) result = result.slice(9);
-	if (tailIsFinal) result = result.slice(0, -9);
-	if (result.startsWith("[-process-]") || result.endsWith("[-process-]")) return null;
-	return result.replace(EDGE_WS, "");
-}
-/** 剥掉开头和结尾的一个标记 token（[-process-] 或 [-final-]，头尾优先，中间的保留）。 */
-function stripOneMarker(text) {
-	if (!text) return "";
-	let result = text;
-	if (result.startsWith("[-process-]")) result = result.slice(11);
-	else if (result.startsWith("[-final-]")) result = result.slice(9);
-	if (result.endsWith("[-process-]")) result = result.slice(0, -11);
-	else if (result.endsWith("[-final-]")) result = result.slice(0, -9);
-	return result.replace(EDGE_WS, "");
+	const fi = text.lastIndexOf(FINAL_TAG);
+	if (fi < 0) return null;
+	const before = text.slice(0, fi);
+	const pi = before.lastIndexOf(PROCESS_TAG);
+	let seg = pi >= 0 ? before.slice(pi + 11) : before;
+	seg = seg.split(PROCESS_TAG).join("").split(FINAL_TAG).join("");
+	seg = stripLeadingSeparators(seg).replace(EDGE_WS, "");
+	return seg || stripAllMarkers(text);
 }
-/** 去掉流式途中末尾未闭合的半截标记（如 "[-fin"，缺右 "]"）。完整标记交给上面两个函数。 */
+/** 去掉流式途中末尾未闭合的半截标记（如 "[-fin"，缺右 "]"）。完整标记交给 stripAllMarkers。 */
 function stripPartialTail(text) {
 	if (!text) return "";
 	return text.replace(/\[-[a-z]*-?$/i, "");
 }
-/** 定稿用：剥掉头尾各一个标记（final 或 process），中间的保留。正文不动。 */
+/** 定稿/单条消息用：剥光所有标记，保留完整正文（message 工具单条消息走这里）。 */
 function finalClean(text) {
-	return stripOneMarker(text);
+	return stripAllMarkers(text);
 }
-/** 流式展示用：有 [-final-] 直接显示最终答案；否则剥一个标记 + 半截标记，正文不动。 */
+/** 流式展示用：剥光所有标记 + 末尾半截标记。 */
 function displayClean(text) {
-	const fin = extractFinal(text);
-	return fin !== null ? fin : stripPartialTail(stripOneMarker(text));
+	return stripPartialTail(stripAllMarkers(text));
 }
 //#endregion
 //#region src/services/messaging/card.ts

package/dist/{runtime-5-KOSMI9.mjs → runtime-CUSz0JLV.mjs}

@@ -3,7 +3,7 @@ import { a as resolveDingtalkAccount, c as addWildcardAllowFrom, d as hasConfigu
 import { t as createLogger } from "./logger-mZ9OSbmD.mjs";
 import { t as dingtalkHttp } from "./http-client-DFWZgO1n.mjs";
 import "./utils-CIfI_3Jh.mjs";
-import { b as finalClean, d as getActiveCardForConversation, n as sendMediaToDingTalk, o as sendTextToDingTalk } from "./messaging-CBQl0D00.mjs";
+import { b as finalClean, d as getActiveCardForConversation, n as sendMediaToDingTalk, o as sendTextToDingTalk } from "./messaging-CvZBBMgv.mjs";
 import { createRequire } from "node:module";
 import { z, z as z$1 } from "zod";
 //#region src/secret-input.ts
@@ -919,7 +919,7 @@ async function monitorDingtalkProvider(opts = {}) {
 	const log = createLogger(cfg.channels?.["dingtalk-connector"]?.debug ?? false);
 	const [accountsModule, monitorAccountModule, monitorSingleModule] = await Promise.all([
 		import("./accounts-BQptOmgB.mjs"),
-		import("./message-handler-CqC0-7FJ.mjs"),
+		import("./message-handler-CWW2dKz0.mjs"),
 		import("./connection-DHHFFNQJ.mjs")
 	]);
 	const { resolveDingtalkAccount, listEnabledDingtalkAccounts } = accountsModule;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jeik/dingtalk-connector",
-  "version": "0.8.21-fix7",
+  "version": "0.8.21-fix9",
   "description": "OpenClaw DingTalk channel plugin (fork) | 钉钉 OpenClaw 渠道插件（fork 自官方，含标记/卡片渲染修复）",
   "type": "module",
   "exports": {

package/src/reply-dispatcher.ts

@@ -116,50 +116,44 @@ export function createDingtalkReplyDispatcher(params: CreateDingtalkReplyDispatc
   let finalMarkerLogged = false;
 
   // 观察每段到达的文本，更新标记认定状态。
-  // 标记系统激活规则：
-  //   [-final-] 出现在头/尾 → 直接认定为最终答案，跳过 OpenClaw 兜底
-  //   [-process-] 出现在头/尾 → 抑制 OpenClaw 的最终答案判定，防止中间过程被误判，流式继续渲染
-  //   无标记 / 头尾标记类型不同 → 走 OpenClaw 默认兜底
+  //   含 [-final-] → 最终答案 = 最后一个 [-process-] 右边、[-final-] 左边那段（extractFinal），跳过兜底
+  //   含 [-process-]（无 [-final-]）→ 过程段，激活标记系统抑制 OpenClaw 兜底
+  //   无标记 → 走 OpenClaw 默认兜底
   let markerSystemActive = false;
 
   const observeReply = (raw: string | undefined, isReasoning: boolean | undefined) => {
     const text = raw ?? "";
     if (!text) return;
 
-    const headTag = text.startsWith(FINAL_TAG) ? "final" : text.startsWith(PROCESS_TAG) ? "process" : null;
-    const tailTag = text.endsWith(FINAL_TAG) ? "final" : text.endsWith(PROCESS_TAG) ? "process" : null;
-    // 异常：头尾标记类型不同（如 [-process-]…[-final-]）→ 不激活标记系统，按普通文本走 OpenClaw 兜底
-    const abnormal = headTag !== null && tailTag !== null && headTag !== tailTag;
-
-    // [-final-] 在头/尾（非异常）→ 标记系统激活，提取最终答案，跳过 OpenClaw 兜底
-    if (!abnormal && (headTag === "final" || tailTag === "final")) {
+    // [-final-] 出现 → 提取最终段（最后一个 [-process-] 之后），跳过 OpenClaw 兜底
+    const fin = extractFinal(text);
+    if (fin !== null) {
       if (!finalMarkerLogged) {
         finalMarkerLogged = true;
-        log.info(`[DingTalk][marker] 检测到最终标记 ${FINAL_TAG}（头尾），标记系统激活，跳过 OpenClaw 默认兜底`);
+        log.info(`[DingTalk][marker] 检测到 ${FINAL_TAG}，最终答案取最后一个 ${PROCESS_TAG} 之后内容，跳过 OpenClaw 兜底`);
       }
-      finalMarkedText = extractFinal(text);
+      finalMarkedText = fin;
       markerSystemActive = true;
       return;
     }
 
-    // [-process-] 在头/尾（非异常）→ 标记系统激活，抑制 OpenClaw 默认兜底
-    if (!abnormal && (headTag === "process" || tailTag === "process")) {
+    // 只有 [-process-]（无 [-final-]）→ 过程段，激活标记系统抑制兜底
+    if (text.includes(PROCESS_TAG)) {
       if (!processMarkerLogged) {
         processMarkerLogged = true;
-        log.info(`[DingTalk][marker] 检测到过程标记 ${PROCESS_TAG}（头尾），标记系统激活，抑制 OpenClaw 默认兜底`);
+        log.info(`[DingTalk][marker] 检测到 ${PROCESS_TAG}（过程段），抑制 OpenClaw 默认兜底`);
       }
       markerSystemActive = true;
       return;
     }
 
-    // 无头尾标记 或 头尾标记异常：标记系统未激活时走 OpenClaw 兜底（标记由 finalClean 善后剥离）
-    // 已激活则保持沉默，让标记系统独占最终答案判定
+    // 无标记：标记系统未激活时走 OpenClaw 兜底；已激活则沉默，让标记系统独占判定
     if (!markerSystemActive && !isReasoning && text.trim()) lastAnswerText = text;
   };
 
   // 选定本轮最终答案：
-  //   标记系统激活 → finalMarkedText（[-final-] 在头/尾）优先，accumulatedText 流式兜底（跳过 OpenClaw）
-  //   未激活（无标记 / 头尾异常）→ lastAnswerText（OpenClaw isReasoning 兜底），accumulatedText 兜底
+  //   标记系统激活 → finalMarkedText（最终段）优先，accumulatedText 流式兜底（跳过 OpenClaw）
+  //   未激活（无标记）→ lastAnswerText（OpenClaw isReasoning 兜底），accumulatedText 兜底
   const pickFinalText = (): string =>
     markerSystemActive ? (finalMarkedText ?? accumulatedText) : (lastAnswerText || accumulatedText);
 
@@ -556,10 +550,9 @@ export function createDingtalkReplyDispatcher(params: CreateDingtalkReplyDispatc
         processMarkerLogged = false;
         finalMarkerLogged = false;
         markerSystemActive = false;
-        if (streamingEnabled) {
-          // fire-and-forget：提前创建 AI Card，onPartialReply 会等待创建完成
-          void startStreaming();
-        }
+        // 延迟建卡：不在 onReplyStart 抢先建卡，改由第一段真正的对话内容（onPartialReply /
+        // deliver block/final）按需创建。否则纯 message 工具轮次（无对话回复，deliver 计数全 0）
+        // 会留下一张没人喂的孤儿卡，收尾兜底成"无文本输出"。
         typingCallbacks.onActive?.();
       },
       deliver: async (payload, info) => {

package/src/services/reply-markers.ts

@@ -1,65 +1,63 @@
-// 回复标记工具 —— 配合 prompt-rewriter 插件注入的"打标记"指令使用。
-//
-// 【头尾标记方案】只 stripping 文本【开头】和【结尾】的标记 token，中间的保留。
-// 原因：agent 可能在正文中解释标记含义，这些解释性的标记不能删。
-//   最终答案 = 去掉开头/结尾的 [-final-] 后的内容。
-//   没有 [-final-] 在头尾 → 返回 null（表示不是最终答案）。
-//
-// ⚠️ 标记字面量与逻辑必须与 prompt-rewriter 的 rewriter.ts 保持一致（两处重复，改一处要同步另一处）。
-
-export const PROCESS_TAG = "[-process-]";
-export const FINAL_TAG = "[-final-]";
-
-const EDGE_WS = /^[ \t\r\n]+|[ \t\r\n]+$/g;
-
-/** 取最终答案：只剥头尾的 [-final-]，中间的保留。
- *  头尾都没有 [-final-] → null（不是最终答案）。
- *  剥完头尾 final 后若另一端仍是 [-process-]（如 [-process-]X[-final-]）→ 异常，返回 null 走兜底。 */
-export function extractFinal(text: string | undefined | null): string | null {
-  if (!text) return null;
-  const headIsFinal = text.startsWith(FINAL_TAG);
-  const tailIsFinal = text.endsWith(FINAL_TAG);
-  if (!headIsFinal && !tailIsFinal) return null;
-  let result = text;
-  if (headIsFinal) result = result.slice(FINAL_TAG.length);
-  if (tailIsFinal) result = result.slice(0, -FINAL_TAG.length);
-  // 头尾混入 process（标记类型不同）→ 异常，不认定为最终答案
-  if (result.startsWith(PROCESS_TAG) || result.endsWith(PROCESS_TAG)) return null;
-  return result.replace(EDGE_WS, "");
-}
-
-/** 剥掉开头和结尾的一个标记 token（[-process-] 或 [-final-]，头尾优先，中间的保留）。 */
-export function stripOneMarker(text: string | undefined | null): string {
-  if (!text) return "";
-  let result = text;
-  // Strip start: process or final
-  if (result.startsWith(PROCESS_TAG)) {
-    result = result.slice(PROCESS_TAG.length);
-  } else if (result.startsWith(FINAL_TAG)) {
-    result = result.slice(FINAL_TAG.length);
-  }
-  // Strip end: process or final
-  if (result.endsWith(PROCESS_TAG)) {
-    result = result.slice(0, -PROCESS_TAG.length);
-  } else if (result.endsWith(FINAL_TAG)) {
-    result = result.slice(0, -FINAL_TAG.length);
-  }
-  return result.replace(EDGE_WS, "");
-}
-
-/** 去掉流式途中末尾未闭合的半截标记（如 "[-fin"，缺右 "]"）。完整标记交给上面两个函数。 */
-export function stripPartialTail(text: string | undefined | null): string {
-  if (!text) return "";
-  return text.replace(/\[-[a-z]*-?$/i, "");
-}
-
-/** 定稿用：剥掉头尾各一个标记（final 或 process），中间的保留。正文不动。 */
-export function finalClean(text: string | undefined | null): string {
-  return stripOneMarker(text);
-}
-
-/** 流式展示用：有 [-final-] 直接显示最终答案；否则剥一个标记 + 半截标记，正文不动。 */
-export function displayClean(text: string | undefined | null): string {
-  const fin = extractFinal(text);
-  return fin !== null ? fin : stripPartialTail(stripOneMarker(text));
-}
+// 回复标记工具 —— 配合 prompt-rewriter 插件注入的"打标记"指令使用。
+//
+// 【段落方案】过程段末尾打 [-process-]，最终段末尾打 [-final-]。agent 常把整轮写成一段：
+//   过程1…[-process-] 过程2…[-process-] … 最终汇总…[-final-]
+//   最终答案 = 「最后一个 [-process-] 右边、[-final-] 左边」那段（即最终汇总），剥掉残留标记，
+//   并清掉该段开头的换行 / markdown 分割横线（---、***、___）。
+//   没有 [-process-] 时 = [-final-] 左边的全部。没有 [-final-] → 不是最终答案。
+//
+// ⚠️ 标记字面量必须与 prompt-rewriter 的 rewriter.ts 保持一致（两处重复，改一处要同步另一处）。
+
+export const PROCESS_TAG = "[-process-]";
+export const FINAL_TAG = "[-final-]";
+
+const EDGE_WS = /^[ \t\r\n]+|[ \t\r\n]+$/g;
+// markdown 分割横线整行：3+ 个 - / * / _（其间可有空格），如 ---、***、- - -
+const HR_LINE = /^[ \t]*(?:[-*_][ \t]*){3,}(?:\r?\n|$)/;
+
+/** 剥掉文本中所有 [-process-] / [-final-] 标记（含中间的），首尾空白清掉。 */
+export function stripAllMarkers(text: string | undefined | null): string {
+  if (!text) return "";
+  return text.split(PROCESS_TAG).join("").split(FINAL_TAG).join("").replace(EDGE_WS, "");
+}
+
+/** 清掉段落开头的空白行 + markdown 分割横线（反复剥，处理 "\n\n---\n" 这种）。 */
+function stripLeadingSeparators(text: string): string {
+  let s = text.replace(/^[ \t\r\n]+/, "");
+  let m: RegExpMatchArray | null;
+  while ((m = s.match(HR_LINE)) && m[0].length > 0) {
+    s = s.slice(m[0].length).replace(/^[ \t\r\n]+/, "");
+  }
+  return s;
+}
+
+/** 取最终答案：取「最后一个 [-process-] 右边、[-final-] 左边」那段，剥残留标记 + 开头分隔，首尾清白。
+ *  没有 [-final-] → null（不是最终答案，交给 OpenClaw 兜底）。 */
+export function extractFinal(text: string | undefined | null): string | null {
+  if (!text) return null;
+  const fi = text.lastIndexOf(FINAL_TAG); // [-final-] = 最终段右边界
+  if (fi < 0) return null;
+  const before = text.slice(0, fi);
+  const pi = before.lastIndexOf(PROCESS_TAG); // 最后一个 [-process-] = 最终段左边界
+  let seg = pi >= 0 ? before.slice(pi + PROCESS_TAG.length) : before;
+  seg = seg.split(PROCESS_TAG).join("").split(FINAL_TAG).join(""); // 残留标记保险
+  seg = stripLeadingSeparators(seg).replace(EDGE_WS, "");
+  // 段为空（如 [-final-] 在最前）→ 退回剥光全文，避免空答案
+  return seg || stripAllMarkers(text);
+}
+
+/** 去掉流式途中末尾未闭合的半截标记（如 "[-fin"，缺右 "]"）。完整标记交给 stripAllMarkers。 */
+export function stripPartialTail(text: string | undefined | null): string {
+  if (!text) return "";
+  return text.replace(/\[-[a-z]*-?$/i, "");
+}
+
+/** 定稿/单条消息用：剥光所有标记，保留完整正文（message 工具单条消息走这里）。 */
+export function finalClean(text: string | undefined | null): string {
+  return stripAllMarkers(text);
+}
+
+/** 流式展示用：剥光所有标记 + 末尾半截标记。 */
+export function displayClean(text: string | undefined | null): string {
+  return stripPartialTail(stripAllMarkers(text));
+}