wezard 1.2.31 → 1.3.1

package/dist/daemon/mirror-bridge.js

@@ -354,20 +354,6 @@ const oneLineSummary = (s, max = 40) => {
     const flat = s.replace(/\s+/g, " ").trim();
     return truncate(flat, max);
 };
-// think-style 收口去重: 软后端最终正文会先作为非 final 文本进 briefThinking, 收口
-// 再当正文用一次。剥掉 think 尾部恰好等于 body 的那段 (含其前的 \n\n 分隔), 让正文
-// 只出现在 </think> 之后。只剥完整尾段, 中途出现过的同句子片段不动 —— 那是真的思考。
-const stripTrailingBody = (think, body) => {
-    if (!think || !body)
-        return think || undefined;
-    if (think === body)
-        return undefined;
-    if (think.endsWith(body)) {
-        const cut = think.slice(0, think.length - body.length).replace(/\n{2,}$/, "").trimEnd();
-        return cut || undefined;
-    }
-    return think;
-};
 // WeCom's markdown sanitizer strips HTML-like `<...>` runs even inside inline
 // code spans — so a Bash command containing `<<'EOF'` (heredoc), `<file>`,
 // `<noreply@x>` etc. silently swallows the rest of the line plus the closing
@@ -536,8 +522,8 @@ const renderLine = (raw, deps) => {
         const sr = line.message?.stop_reason;
         const isFinal = sr === "end_turn";
         // final 是三态: true=终句, false=已知的中途输出, undefined=后端说不清 (软收口)。
-        // 软后端不能填 false —— 那会让每句叙述都触发 earlyLinkBubble, 把 loading 气泡
-        // 提前收成详情链接, 一句话答完的 turn 也要拆成两条消息。
+        // 软后端不能填 false —— 那会让每句叙述都被当成中途输出标记上 briefHadTool, 一句
+        // 话答完的 turn 也要被当成"有工具"处理。
         const textFinal = isFinal ? true : line.softTurnEnd ? undefined : false;
         let pending = [];
         const flushPending = () => {
@@ -570,7 +556,7 @@ const renderLine = (raw, deps) => {
                 if (t && !deps.isOwnAssistantSend?.(t))
                     out.push({ kind: "text", body: t, final: textFinal });
             }
-            else if (b?.type === "tool_use" && (deps.includeTools || deps.thinkStyle)) {
+            else if (b?.type === "tool_use" && deps.includeTools) {
                 const name = b.name ?? "tool";
                 const toolUseId = b.id ?? "";
                 // 同名扩展当前 group; 不同名先 flush 再起新组。
@@ -578,14 +564,13 @@ const renderLine = (raw, deps) => {
                     flushPending();
                 pending.push({ toolUseId, name, input: b.input });
             }
-            else if (b?.type === "thinking" && deps.thinkStyle) {
-                flushPending();
-                const raw = typeof b.thinking === "string" ? b.thinking : typeof b.text === "string" ? b.text : "";
-                const t = raw.trim();
-                if (t)
-                    out.push({ kind: "thinking", body: t });
+            else if (b?.type === "thinking" && typeof b.thinking === "string") {
+                // codebuddy 的 reasoning 记录已被 normalizeLine 归一成这个形状。
+                // 只作为 CoT 进度源发出: onItem 里它唯一的下游是 brief 进度行, 不进正文。
+                const thought = b.thinking.trim();
+                if (thought)
+                    out.push({ kind: "thinking", body: thought });
             }
-            // thinking blocks otherwise intentionally skipped (只进详情页)
         }
         flushPending();
         // Emit per-line usage snapshot BEFORE turn_end so brief store gets the last
@@ -666,8 +651,9 @@ const renderLine = (raw, deps) => {
 // Block-wise packing (shared/md-chunk): never cuts mid-line, and never cuts a
 // fenced block or table in a way that breaks rendering — see splitMarkdown.
 const splitChunks = splitMarkdown;
-// Room reserved in every chunk for the `emoji \`#tag\` \`2/5\`` header line.
-const TAG_HEADER_BUDGET = 32;
+// Room reserved in every chunk for the `emoji \`#tag\` \`2/5\`` header line
+// (up to ~110 bytes in its linked `[🧙 #tag](url)` form).
+const TAG_HEADER_BUDGET = 64;
 export const startMirrorTail = (deps) => {
     const { log } = deps;
     // A single logical tail follows ONE sessionId whose transcript file may move
@@ -1353,8 +1339,6 @@ const enqueue = (key, job) => {
 };
 export const startMirror = (deps) => {
     const { cfg, log, client } = deps;
-    // think-style: brief 模式下把 thinking 直接流进气泡, 且全程不下发任何详情链接。
-    const thinkStyle = cfg.wrc.mirror.thinkStyle && cfg.wrc.mirror.brief;
     // Multi-mirror: each (sessionId, target) pair is one Attachment. Same
     // sessionId reattaches → replace. Same target with different sessionId →
     // replace too (one WeCom chat can only show one mirror at a time).
@@ -1440,8 +1424,6 @@ export const startMirror = (deps) => {
     // for >60s mid-turn and we don't want to drop the bubble while it's chewing.
     const FLUSH_MS = 250;
     const HARD_TIMEOUT_MS = 350_000;
-    /** 首条 CLI 产出到达前的早期超时: 3s 无响应则先收气泡为详情链接。 */
-    const EARLY_LINK_MS = 3_000;
     /** 软收口静默期。后端只能说"这条消息写完了"(codebuddy) 时, 等这么久没有新 item
      *  才认定一轮结束。取值只需盖住"叙述消息落盘 → 紧随其后的 function_call 落盘"
      *  这一段, 与模型思考/工具执行时长无关。
@@ -1452,19 +1434,6 @@ export const startMirror = (deps) => {
     const softTurnEndMsFor = (a) => cfg.wrc.mirror.softTurnEndMs ?? (backendForPath(a.jsonlPath).name === "codebuddy" ? SOFT_TURN_END_DEFAULT_CB : SOFT_TURN_END_DEFAULT_CLAUDE);
     const STREAM_SOFT_CAP = 18_000;
     const TOOL_DETAIL_TTL_MS = 24 * 60 * 60 * 1000;
-    /** Standalone 发送前正文检查: 内容无正文 (纯 think 标记 / 工具行) 时,
-     *  回队列等这么久。期间有新消息入队则重置; 到期且无新消息才发出。 */
-    const STANDALONE_BODY_WAIT_MS = 8_000;
-    // 判断 standalone 内容是否含有正文 (非纯 <think>…</think> / 工具行)。
-    const standaloneHasBody = (content) => {
-        // 剥掉 <think>…</think> 包裹 (含 tag header)
-        const stripped = content.replace(/<think>[\s\S]*?<\/think>/g, "")
-            // 工具行
-            .replace(/^🔧 .*/gm, "")
-            .replace(/^↳ .*/gm, "")
-            .trim();
-        return stripped.length > 0;
-    };
     const turnRegistry = new Map();
     const evictTurns = () => {
         const now = Date.now();
@@ -1523,15 +1492,18 @@ export const startMirror = (deps) => {
             clearTimeout(s.hardTimer);
             s.hardTimer = undefined;
         }
-        if (!s.dead) {
+        // 没正文不写: finish=true 是整条覆盖, 空正文只会把 "…" ack 覆盖成光秃秃的
+        // 链接头, 结束处理自己制造错发。气泡保持现有内容, 由 WeCom 6min 窗口自然
+        // 到期。dead 流同理只做本地清理。
+        if (!s.dead && s.acc.trim()) {
             const card = detailCardFor(s, a.target);
             try {
                 if (card) {
                     s.cardSent = true;
-                    await client.replyStreamWithCard(s.frame, s.streamId, withLinkedTag(a, s.acc || " ", undefined, s.turnId), true, { templateCard: card });
+                    await client.replyStreamWithCard(s.frame, s.streamId, withLinkedTag(a, s.acc, undefined, s.turnId), true, { templateCard: card });
                 }
                 else {
-                    await client.replyStream(s.frame, s.streamId, withLinkedTag(a, s.acc || " ", undefined, s.turnId), true);
+                    await client.replyStream(s.frame, s.streamId, withLinkedTag(a, s.acc, undefined, s.turnId), true);
                 }
                 log.info({ sessionId: a.sessionId, turnId: s.turnId, accLen: s.acc.length, tools: s.tools.length, withCard: !!card }, "stream finalize");
             }
@@ -1541,7 +1513,7 @@ export const startMirror = (deps) => {
             }
         }
         else {
-            log.info({ sessionId: a.sessionId, turnId: s.turnId, accLen: s.acc.length, tools: s.tools.length }, "stream finalize (dead)");
+            log.info({ sessionId: a.sessionId, turnId: s.turnId, accLen: s.acc.length, tools: s.tools.length, dead: s.dead }, "stream finalize (no body — not overwriting)");
         }
         if (s.tools.length > 0) {
             turnRegistry.set(s.turnId, {
@@ -1572,8 +1544,6 @@ export const startMirror = (deps) => {
     // Linked tag prefix: emoji+tag becomes a chat-detail link. Falls back to
     // plain withSessionTag when no turnId is available (no active turn to link).
     const linkedTagPrefix = (target, turnId) => {
-        if (thinkStyle)
-            return ""; // think-style: 全程不带详情链接, 一律退回 withSessionTag。
         if (!turnId)
             return "";
         const url = buildChatUrl(cfg.daemon.detailPublicBase, cfg.daemon.host, cfg.daemon.port, turnId, stripPrincipalPrefix(target));
@@ -1590,7 +1560,7 @@ export const startMirror = (deps) => {
     };
     const sendStandalone = (a, content) => {
         const chatId = stripPrincipalPrefix(a.target);
-        const pieces = splitChunks(content, Math.max(200, cfg.wrc.mirror.chunkChars - TAG_HEADER_BUDGET));
+        const pieces = splitChunks(content, Math.max(200, cfg.wrc.mirror.chunkBytes - TAG_HEADER_BUDGET));
         const chunks = pieces.map((p, i) => withLinkedTag(a, p, pieces.length > 1 ? `${i + 1}/${pieces.length}` : undefined));
         a.standalonePending = a.standalonePending
             .then(async () => {
@@ -1642,54 +1612,16 @@ export const startMirror = (deps) => {
             log.warn({ sessionId: a.sessionId, err: e.message }, "pane preamble capture failed");
         }
     };
-    // thinkStyle 格式化: 将 merged standalone 内容分拣为 <think> 包裹的工具行和正文。
-    // 统一在发送层处理, pushThink / handleBriefItem 等上游只需发原始文本。
-    const formatThinkStandalone = (a, merged) => {
-        const lines = merged.split("\n");
-        const thinkLines = [];
-        const bodyLines = [];
-        for (const line of lines) {
-            if (line.startsWith("🔧 ") || line.startsWith("↳ ") || line.startsWith("💭 "))
-                thinkLines.push(line);
-            else
-                bodyLines.push(line);
-        }
-        // `💭 ` 只是 pushThink 打在 standalone 路径上的传输标记 (让本函数认出 think 来源),
-        // 没有展示价值 —— 剥掉。🔧 / ↳ 是给用户的工具行标记, 保留。
-        const think = thinkLines.map((l) => l.replace(/^💭 /, "")).join("\n").trim();
-        const body = bodyLines.join("\n").trim();
-        if (think && body)
-            return `${openThink(a.target, think)}</think>\n\n${body}`;
-        if (think)
-            return `${openThink(a.target, think)}</think>`;
-        return body;
-    };
     // Debounce 聚合: 仅 standalone 路径用。窗口内 onItem 多次落入 → 合并成单条 markdown。
-    // 0 关闭时退化为透传。flushStandalone 也用于 detach 时的 drain。
-    // 正文检查: 合并内容无正文 (纯 think/工具) 时, 回队列等 STANDALONE_BODY_WAIT_MS;
-    // 期间有新消息入队 (parts 增长) 则重置; 到期且无新消息才丢弃。
-    // force=true 跳过正文检查, 用于 teardown / detach / pre-card 等强制 drain 场景。
-    const flushStandalone = (a, force = false) => {
+    // 0 关闭时退化为透传。flushStandalone 也用于 detach / teardown 时的 drain。
+    const flushStandalone = (a) => {
         const buf = a.standaloneBuf;
         if (!buf)
             return;
         const merged = buf.parts.join("\n\n");
-        if (!force && !standaloneHasBody(merged)) {
-            if (buf.bodyWaitLen !== buf.parts.length) {
-                // 无正文 & 队列有新增 → 再等一轮, 看后续 item 是否带正文。
-                buf.bodyWaitLen = buf.parts.length;
-                buf.timer = setTimeout(() => flushStandalone(a), STANDALONE_BODY_WAIT_MS);
-                return;
-            }
-            // 8s 无新 item 且仍无正文 → 丢弃 (纯 think/工具行不值得单独发一条)。
-            a.standaloneBuf = undefined;
-            return;
-        }
         a.standaloneBuf = undefined;
-        // thinkStyle: 统一格式化 — 工具行包进 <think>, 正文留外面。
-        const content = thinkStyle ? formatThinkStandalone(a, merged) : merged;
-        if (content)
-            sendStandalone(a, content);
+        if (merged)
+            sendStandalone(a, merged);
     };
     const enqueueStandalone = (a, content) => {
         const ms = cfg.wrc.mirror.standaloneDebounceMs;
@@ -1740,7 +1672,7 @@ export const startMirror = (deps) => {
         if (!a.standaloneBuf)
             return;
         clearTimeout(a.standaloneBuf.timer);
-        flushStandalone(a, true);
+        flushStandalone(a);
     };
     // Path A: a needs-approval tool_use just landed. Aggregate the buffer as one
     // standalone, send it BEFORE the approval card race, transition to AWAITING_APPR.
@@ -1793,7 +1725,10 @@ export const startMirror = (deps) => {
         flushPendingStandalone(a);
         void (async () => {
             try {
-                await client.replyStream(out.frame, out.streamId, withLinkedTag(a, bubbleMd || " "), true);
+                // 有正文才写旧 streamId (收入 stream); 空缓冲一个字都不写 —— 否则
+                // loading 气泡被 " " 覆盖, 结束处理自己凭空制造一条空消息。
+                if (bubbleMd)
+                    await client.replyStream(out.frame, out.streamId, withLinkedTag(a, bubbleMd), true);
             }
             catch (e) {
                 log.warn({ sessionId: a.sessionId, err: e.message }, "exit-deferred finalize failed; falling back to standalone");
@@ -1880,24 +1815,77 @@ export const startMirror = (deps) => {
         }
     };
     // ── Brief mode ────────────────────────────────────────────────────────
-    // 每个 turn 挂一条 loading 气泡 (起始 "…" finish=false, 不立刻关掉)。收口时:
-    //   • 无工具 → 直接把 Claude 最终文本 (或 slash 命令的 skill_output) 写进这条气泡。
-    //   • 有工具 → 气泡收成 "✴️ 详情链接", 最终文本另发一条 standalone。
+    // 每个 turn 挂一条气泡: ack 时就写进 `tag 详情链接 …` (finish=false, 不立刻关掉),
+    // 让群里从收到消息那一刻起就有详情页入口。收口时:
+    //   • 正文到位 → 以 `链接 正文` 覆盖这条气泡。
+    //   • 始终没正文 / 过 6min 窗口 → 以 ack 时那条纯 `链接` 收口。
+    //   • 气泡已收口或无气泡 turn (CLI 侧发起) → 正文另发一条 standalone。
     // 其它所有 item 只写入 turn detail store。
     // 能证明"assistant 已经在产出"的 item —— 见到它们才补开无气泡 turn。
     const BRIEF_TURN_OPENERS = new Set(["text", "tool_use", "tool_result", "skill_output"]);
+    // ── CoT 进度行 (brief 气泡) ─────────────────────────────────────────
+    // 一轮里正文要等 final text 才落地, 中间几十秒到几分钟气泡只有一个 "…"。这里把最新的
+    // thinking / 工具调用覆盖进这条还没收口的气泡, 让群里看得到进展。三条硬约束:
+    //   • 只写"还没收口的气泡" —— 结论一到 finishBubble 就用 `链接 正文` 整条替换, 进度
+    //     不会留在最终气泡里 (这是它与已下线的 thinkStyle 的分界线: 那次是把整轮 reasoning
+    //     拼进正文, 单条体积翻几倍被 md-chunk 切成多页刷屏);
+    //   • 单行定长 (COT_MAX_CHARS), 无论 thinking 多长恒定一行, 不存在刷屏可能;
+    //   • 节流 —— 气泡刷新是整条内容重发, 高频 thinking 不能 1:1 打到 stream 上。
+    const COT_MAX_CHARS = 100;
+    const COT_FLUSH_MS = 1500;
+    // 压成一行的进度片段。safeForMarkdown 必须先于截断: thinking 里一个裸反引号就能提前
+    // 闭合代码段, 让后面的正文裸奔在链接旁边。尾随的省略号 = "还在进行中"; 截断与进行中
+    // 共用同一个 …, 不叠加两个。
+    const cotLine = (s) => {
+        const flat = safeForMarkdown(s.replace(/\s+/g, " ").trim());
+        return flat ? `${flat.slice(0, COT_MAX_CHARS)}…` : "";
+    };
+    const cotToolLabel = (calls) => calls.map((c) => `${c.name} ${renderToolInputCompact(c.input, 60)}`.trim()).join(" / ");
+    const clearCot = (a) => {
+        if (a.cotTimer) {
+            clearTimeout(a.cotTimer);
+            a.cotTimer = undefined;
+        }
+        a.cotText = undefined;
+    };
+    const flushCot = async (a) => {
+        a.cotTimer = undefined;
+        const text = a.cotText;
+        a.cotText = undefined;
+        const b = a.briefBubble;
+        const turnId = a.briefTurnId;
+        // 收口后这一路全部失效: 气泡要么已 done, 要么 turn 已经换人/清空。
+        if (!text || !b || b.done || !turnId || a.briefConcluded)
+            return;
+        try {
+            await client.replyStream(b.frame, b.streamId, `${briefDetailLink(turnId, a.target)} \`${text}\``, false);
+        }
+        catch (e) {
+            log.debug({ sessionId: a.sessionId, turnId, err: e.message }, "brief: cot refresh failed");
+        }
+    };
+    /** 推进气泡里的 CoT 进度。节流窗口内到达的多条只留最后一条 —— 进度永远只展示"最新"。 */
+    const updateBriefProgress = (a, raw) => {
+        const b = a.briefBubble;
+        if (!b || b.done || a.briefConcluded)
+            return;
+        const line = cotLine(raw);
+        if (!line)
+            return;
+        a.cotText = line;
+        if (a.cotTimer)
+            return;
+        a.cotTimer = setTimeout(() => void flushCot(a), COT_FLUSH_MS);
+    };
     // 链接落到 chat 视图: 默认选中本 turn 所属的 #tag, 贴底显示整条会话。turnId 依旧
     // 是凭据 (不可枚举), 只是页面从"一个 turn"扩成"这个 chat 的全部会话"。
     // target 作为 ww_uniq 传下去, 让同 chat 的所有 turn 详情都复用一个 WeCom 窗口。
     const briefDetailLink = (turnId, target) => {
         const url = buildChatUrl(cfg.daemon.detailPublicBase, cfg.daemon.host, cfg.daemon.port, turnId, stripPrincipalPrefix(target));
         const tag = tagOfKey(target);
-        return tag
-            ? `[${labelFor(tag)} #${tag}](${url}) ← View chat details`
-            : `[🧙](${url}) ← View chat details`;
+        return tag ? `[${labelFor(tag)} #${tag}](${url})` : `[🧙](${url})`;
     };
     // 收口一条 loading 气泡: finish=true 写入最终内容, 只生效一次。发送失败退回 standalone。
-    // 排队中的 turn 也持有气泡, 所以气泡是显式入参而不是从 a 上取。
     // raw=true skips withSessionTag (used when content already contains the linked tag header).
     // WeCom 客户端收到 finish=true 后仍有打字机动画要播放, 如果紧接着就下发
     // standalone (sendMessage), 用户会看到 standalone 抢在气泡动画结束之前出现。
@@ -1909,17 +1897,10 @@ export const startMirror = (deps) => {
             return;
         b.done = true;
         clearTimeout(b.hardTimer);
-        if (b.earlyTimer) {
-            clearTimeout(b.earlyTimer);
-            b.earlyTimer = undefined;
-        }
-        // think-style: 清除待发的 flush 定时器, 避免 doStreamThink 在 done 后空跑。
-        if (a.briefBubble === b && a.thinkFlushTimer) {
-            clearTimeout(a.thinkFlushTimer);
-            a.thinkFlushTimer = undefined;
-        }
         if (a.briefBubble === b)
             a.briefBubble = undefined;
+        // 气泡要定稿了 —— 排队中的 CoT 进度必须撤掉, 否则它会把 `链接 正文` 覆盖回进度行。
+        clearCot(a);
         const p = (async () => {
             try {
                 await client.replyStream(b.frame, b.streamId, raw ? (content || " ") : withLinkedTag(a, content || " "), true);
@@ -1937,62 +1918,6 @@ export const startMirror = (deps) => {
         return p;
     };
     const finishBriefBubble = (a, content, raw = false) => finishBubble(a, a.briefBubble, content, raw);
-    // think-style tag: 紧跟在 `<think>` 之后, 不在整条消息最前面 —— `<think>🧙 …`。
-    const thinkTag = (target) => {
-        const tag = tagOfKey(target);
-        return tag ? `${labelFor(tag)} #${tag}` : "🧙";
-    };
-    const openThink = (target, think) => `<think>${thinkTag(target)} ${think}`;
-    // think-style: 把当前累积的 thinking 作为 `<think>🧙 …` 流进活着的 loading 气泡
-    // (finish=false, 气泡不关)。收口时再补 `</think>\n\n<final>` 并 finish。
-    // raw 发送: tag 已在 <think> 内, 不再经 withSessionTag 外包。
-    // streamPending → 首次调用时才真正开流 (fix: off-by-one race)。
-    // fix: 加去抖 (FLUSH_MS) + 背压 (await 上一次完成), 消除 SDK 串行队列积压。
-    const doStreamThink = async (a) => {
-        const b = a.briefBubble;
-        const think = a.briefThinking?.trim();
-        if (!b || b.done || !think)
-            return;
-        // 首条 replyStream 延迟到这里发出 (streamPending), 携带真实内容, 避免空开流竞态。
-        b.streamPending = false;
-        try {
-            await client.replyStream(b.frame, b.streamId, openThink(a.target, think), false);
-            log.debug({ sessionId: a.sessionId, streamId: b.streamId, thinkLen: think.length }, "brief: think stream ok");
-        }
-        catch (e) {
-            log.warn({ sessionId: a.sessionId, err: e.message }, "brief: think stream failed");
-        }
-    };
-    const scheduleThinkFlush = (a) => {
-        if (!a.briefBubble || a.briefBubble.done || a.thinkFlushTimer || a.thinkFlushing)
-            return;
-        a.thinkFlushTimer = setTimeout(() => {
-            a.thinkFlushTimer = undefined;
-            if (a.thinkFlushing)
-                return; // 上一次还在飞 → 下次 pushThink 再排
-            a.thinkFlushing = true;
-            void doStreamThink(a).finally(() => { a.thinkFlushing = false; });
-        }, FLUSH_MS);
-    };
-    // think-style 单一入口: 一段中间过程 (reasoning / 中途文本 / 工具调用) 进 think。
-    // 气泡还活 → 累积进 briefThinking 并排一次去抖 flush (replyStream);
-    // 气泡已收口 / 无气泡 → enqueueStandalone 即时推送 (自带 3s debounce 防抖合并)。
-    const pushThink = (a, chunk) => {
-        const c = chunk.trim();
-        if (!c)
-            return;
-        if (a.briefBubble && !a.briefBubble.done) {
-            a.briefThinking = a.briefThinking ? `${a.briefThinking}\n\n${c}` : c;
-            scheduleThinkFlush(a);
-        }
-        else if (a.briefTurnId) {
-            // 气泡已收口 / 无气泡 turn: 走 standalone, 避免长 turn 期间 chat 静默。
-            // 原始内容入队, flushStandalone 统一做 thinkStyle 格式化 (工具行→<think>, 其余→正文)。
-            // fix: thinkStyle 加 `💭 ` 前缀, formatThinkStandalone 才能识别为 think 行 (否则
-            // 纯 reasoning 被当 body 整段裸奔到 chat)。
-            enqueueStandalone(a, thinkStyle ? `💭 ${c}` : c);
-        }
-    };
     // 让一个已建好记录的 turn 成为活跃 turn。turn 级状态在这里统一归零 —— 唯一入口。
     const openBriefTurn = (a, q) => {
         a.briefTurnId = q.turnId;
@@ -2001,18 +1926,10 @@ export const startMirror = (deps) => {
         a.briefHadTool = false;
         a.briefConcluded = false;
         a.briefLastText = undefined;
-        a.briefThinking = undefined;
-        if (a.thinkFlushTimer) {
-            clearTimeout(a.thinkFlushTimer);
-            a.thinkFlushTimer = undefined;
-        }
-        a.thinkFlushing = false;
+        clearCot(a); // turn 级状态 —— 进度行跟着气泡走, 不能跨 turn 残留
         log.info({ sessionId: a.sessionId, turnId: q.turnId, isSlash: q.isSlash }, "brief: turn started");
     };
-    // WeCom 侧发起一个 turn: 立刻挂 loading 气泡当 ack, 再决定是马上激活还是排队。
-    // 上一 turn 还在跑时绝不能强关它 —— CC 那边新消息也是排队的, 当前轮的后半段还会
-    // 继续落盘, 强关会把它们改挂到新 turn 上, 旧 turn 页则提前变「已完成」。
-    // 断点是一次性的: 只归给断点后的第一轮, 之后的轮次上下文又连续了。
+    // WeCom 侧发起一个 turn。断点是一次性的: 只归给断点后的第一轮, 之后的轮次上下文又连续了。
     const consumeCut = (a) => {
         const cut = a.ctxCut;
         a.ctxCut = undefined;
@@ -2034,62 +1951,24 @@ export const startMirror = (deps) => {
         const bubble = { frame, streamId, hardTimer: undefined, done: false };
         const q = { turnId, bubble, isSlash };
         bubble.hardTimer = setTimeout(() => {
-            // 到点还在排队 = 前一个 turn 卡死或漏收 turn_end。强关它放行 —— 队列必须能自愈,
-            // 否则这条消息的产出会一直记到那个僵尸 turn 上。气泡此时已过 WeCom 更新窗口,
-            // 收成详情链接即可, 真正要紧的是让本 turn 激活。
-            if (a.briefQueue?.includes(q)) {
-                log.warn({ sessionId: a.sessionId, turnId }, "brief: queued turn timed out — force-closing the stuck one");
-                closeBriefTurn(a);
-            }
-            // think-style: WeCom ~6min stream 窗口快到, 必须 finish=true 收口。
-            // 保留当前已流进气泡的 thinking 内容作为最终快照 (用户看到的内容不变),
-            // 后续正文走 standalone。如果 turn 尚未结论, 标记 done 让 concludeBriefTurn
-            // 知道气泡已收口、走 else 分支 (sendRaw / sendStandalone)。
-            if (thinkStyle) {
-                // 活跃 turn 的 thinking 才是本气泡的内容; 排队 turn 没有 thinking, 空收即可。
-                const think = (a.briefBubble === bubble) ? a.briefThinking?.trim() : undefined;
-                const content = think ? openThink(a.target, think) : withSessionTag(a.target, " ");
-                // 气泡带走了已累积的 thinking; 清空 briefThinking, 后续 pushThink 走 standalone。
-                if (a.briefBubble === bubble)
-                    a.briefThinking = undefined;
-                void finishBubble(a, bubble, content, true);
-            }
-            else {
-                void finishBubble(a, bubble, briefDetailLink(turnId, a.target), true);
-            }
+            // WeCom ~6min stream 窗口快到, 必须 finish=true 收口。
+            void finishBubble(a, bubble, briefDetailLink(turnId, a.target), true);
         }, HARD_TIMEOUT_MS);
-        // earlyTimer: 3s 无 CLI 产出 → 先把 loading 气泡收成详情链接, 用户可即时点入。
-        // 首条 item 到达时清除 (handleBriefItem 路径)。用显式 bubble ref 而非 a.briefBubble,
-        // 因为排队中的 turn 还没成为活跃 turn, a.briefBubble 指向的是前一个。
-        // think-style: 不设 earlyTimer —— 不发链接, 气泡留着等 thinking / 答复流进来。
-        // codebuddy: jsonl 按完整消息落盘 (status:"completed"), 不像 Claude Code 增量写,
-        // 首条 item 常在 3s 之后才到达 → earlyTimer 提前收口气泡 → 结论被迫走 standalone。
-        // 跳过 earlyTimer, 让气泡等到真正的内容写入 (hardTimer 兜底 6min 窗口)。
-        const skipEarly = thinkStyle || backendForPath(a.jsonlPath).name === "codebuddy";
-        if (!skipEarly)
-            bubble.earlyTimer = setTimeout(() => {
-                if (bubble.done)
-                    return;
-                void finishBubble(a, bubble, briefDetailLink(turnId, a.target), true);
-            }, EARLY_LINK_MS);
-        if (a.briefTurnId) {
-            (a.briefQueue ??= []).push(q);
-            log.info({ sessionId: a.sessionId, turnId, queued: a.briefQueue.length }, "brief: turn queued (previous still running)");
-        }
-        else {
-            openBriefTurn(a, q);
-        }
+        // 新消息 = 对话边界: 立刻收掉上一 turn, 新 turn 直接激活、不排队。收口语义见
+        // closeBriefTurn: 有正文收入旧气泡, 没正文不写一个字 (绝不因边界结束凭空新发/
+        // 覆盖消息)。旧 turn 在 CLI 侧的剩余产出自然流入新气泡 —— "新回复走最新气泡"
+        // 正是这个语义。代价是旧 turn 页提前标完、尾部 item 记到新 turn 名下, 但远小于
+        // 排队的代价: 排队 turn 的 frame 在前一个长 turn 期间 (可达数分钟) 过期, 激活后
+        // replyStream 全被 WeCom 拒收 (#stream 事故的静默根因)。
+        if (a.briefTurnId)
+            closeBriefTurn(a);
+        openBriefTurn(a, q);
+        // ack 即详情链接。URL 的三个入参 (turnId / target / host) 在收消息这一刻全部已知 ——
+        // turnId 是本地生成的, 详情页记录也已在 recordTurnStart 建好, 所以不必等 CLI 产出,
+        // 也不必猜后端: codebuddy 那种几十秒后才落盘的轮, 入口从第一秒就在。
+        // 尾随 `…` 表示"正文还没到", 正文到位时整条内容被 `链接 正文` 覆盖。
         try {
-            // think-style: 延迟首条 replyStream 到首个内容到达 (streamPending=true),
-            // 避免空 `<think>` 与紧随的 pushThink 产生两次快速 replyStream 触发 WeCom
-            // 服务端合并/丢弃 (off-by-one)。flushStreamPending 在 pushThink/doStreamThink 首次
-            // 调用时开流, 保证只有一次 replyStream 携带真实内容。
-            if (thinkStyle) {
-                bubble.streamPending = true;
-            }
-            else {
-                await client.replyStream(frame, streamId, withSessionTag(a.target, "…"), false); // 挂住 loading 气泡, 不关闭
-            }
+            await client.replyStream(frame, streamId, `${briefDetailLink(turnId, a.target)} …`, false);
         }
         catch (e) {
             log.warn({ sessionId: a.sessionId, turnId, err: e.message }, "brief: turn ack failed");
@@ -2112,101 +1991,44 @@ export const startMirror = (deps) => {
         a.briefHadTool = false;
         a.briefConcluded = false;
         a.briefLastText = undefined;
-        a.briefThinking = undefined;
-        // think-style: 不推详情链接 (CLI 侧发起的无气泡 turn 无处可流, 保持静默; 最终答复走 standalone)。
-        if (!thinkStyle)
-            sendRaw(a, briefDetailLink(turnId, a.target));
+        clearCot(a);
+        sendRaw(a, briefDetailLink(turnId, a.target));
         log.info({ sessionId: a.sessionId, turnId }, "brief: turn started (CLI-side, no bubble)");
     };
-    // 本轮一旦出现工具调用 / tool_result / 非 final 文本, 就说明这不是"一句话答完"的
-    // 简单 turn —— 立刻把 loading 气泡收成详情链接, 用户马上能点进去看实时刷新的时间线,
-    // 不必等 turn 收口 (旧逻辑 URL 只在 closeBriefTurn 才写, 刷新太慢)。收链接即视作
-    // briefHadTool, 最终结论照常另发 standalone; closeBriefTurn 见气泡已 done 会跳过。
-    const earlyLinkBubble = (a) => {
-        if (!a.briefTurnId || !a.briefBubble || a.briefBubble.done)
-            return;
-        // think-style: 不收气泡、不发链接 —— 气泡留着继续流 thinking / 最终答复。
-        if (thinkStyle) {
-            a.briefHadTool = true;
+    // 本轮出现过工具调用 / tool_result / 非 final 文本 —— 只记状态: 详情链接从 ack 起
+    // 就挂在气泡里, 无需再推一次。气泡仍然不关, 等正文到来后以 `链接 正文` 覆盖收口。
+    const markBriefTool = (a) => {
+        if (!a.briefTurnId)
             return;
-        }
         a.briefHadTool = true;
-        void finishBriefBubble(a, briefDetailLink(a.briefTurnId, a.target), true);
     };
     // 本轮结论落地, 只生效一次:
-    //   • 无工具 → 结论 + 详情链接一并写进 loading 气泡 (仍是一条消息);
-    //   • 有工具 / 无气泡 turn → 气泡留给 closeBriefTurn 收详情链接, 结论另发 standalone。
-    // 每个 turn 都必须留一个可回溯入口, 单句回答也要带链接。
+    //   • 气泡仍开 (ack 时的 `链接 …` 还在) → 以 `链接 正文` 覆盖收口;
+    //   • 气泡已收 (过 6min 窗口 / 已收口) 或无气泡 turn (CLI 侧发起) → body 走 standalone,
+    //     那条 standalone 自带 `链接` 头 (withLinkedTag / ensureBriefTurn 已发过详情链接)。
     const concludeBriefTurn = (a, body) => {
         const turnId = a.briefTurnId;
         if (!turnId || a.briefConcluded || !body.trim())
             return;
         a.briefConcluded = true;
-        if (thinkStyle) {
-            // think-style: thinking 段以 `<think>🧙 …</think>` 收口 (tag 在 <think> 内),
-            // 再接正文; 无 thinking 时退回普通 tag 头正文。
-            // 软后端 (softTurnEnd) 的最终正文 final===undefined, 上游按"非 final 中途文本"
-            // 也 pushThink 进过 briefThinking —— 收口再拿它当正文 = think 与正文各一份重复。
-            // 收口前把 briefThinking 尾部等于 body 的那段剥掉, 保证正文只出现在 <think> 之后。
-            const think = stripTrailingBody(a.briefThinking?.trim(), body.trim());
-            if (a.briefBubble && !a.briefBubble.done) {
-                // 气泡还活: 整段 `<think>🧙 …</think>\n\n正文` 收进这一条 (raw, tag 已在 <think> 内)。
-                const out = think ? `${openThink(a.target, think)}</think>\n\n${body}` : withSessionTag(a.target, body);
-                void finishBriefBubble(a, out, true);
-            }
-            else {
-                // 无气泡 turn / 气泡已收口: briefThinking 此时只含气泡期间累积的残余
-                // (气泡收口后 pushThink 直接走 standalone, 不再累积)。有残余则拼成
-                // think+body 一条; 无残余则只发 body。
-                if (think) {
-                    sendRaw(a, `${openThink(a.target, think)}</think>\n\n${body}`);
-                }
-                else {
-                    sendStandalone(a, body);
-                }
-            }
-        }
-        else if (a.briefHadTool || !a.briefBubble) {
-            sendStandalone(a, body);
+        if (a.briefBubble && !a.briefBubble.done) {
+            void finishBriefBubble(a, `${briefDetailLink(turnId, a.target)} ${body}`, true);
         }
         else {
-            void finishBriefBubble(a, `${body}\n\n${briefDetailLink(turnId, a.target)}`);
+            sendStandalone(a, body);
         }
-        // 排队中的 turn 已经建了记录但还没跑, 不能被这把扫帚扫成「已完成」。
-        const keep = [turnId, ...(a.briefQueue ?? []).map((q) => q.turnId)];
-        recordCloseOpenTurns({ target: a.target, sessionId: a.sessionId, exceptIds: keep });
+        // 只保留当前 turn: 其余仍开着的 turn 记录是漏收的 close, 一并扫掉。
+        recordCloseOpenTurns({ target: a.target, sessionId: a.sessionId, exceptIds: [turnId] });
     };
-    /** soft=true: 收口信号来自静默期确认 (后端无终句标记), 拿本轮最后一句 text 当结论。
-     *  硬信号路径上结论早已由 final text 落地, briefConcluded 会挡住重复推送。 */
-    const closeBriefTurn = (a, soft = false) => {
+    /** 收口一个 turn (软/硬/对话边界统一语义):
+     *  有正文 (briefLastText) → 收入本 turn 自己的气泡 (`链接 正文`) 收口, 不另发消息;
+     *  气泡已收/不在 → 正文走 standalone (有内容才有资格发)。
+     *  没有正文 → 一个字都不写: finish=true 是整条覆盖, 空收口只会把 `链接 …`/CoT
+     *  进度行覆盖成光秃秃的链接。气泡保持现有内容, 由 WeCom 6min 窗口自然到期。 */
+    const closeBriefTurn = (a) => {
         if (!a.briefTurnId)
             return;
-        if (soft)
-            concludeBriefTurn(a, a.briefLastText ?? "");
-        // 气泡还开着 (有工具的 turn: 结论只发了 standalone, 气泡留到这里收链接; 或空 turn
-        // 没有结论) —— 收口: 统一写详情链接, 保证每个 turn 都有可点入口。
-        if (a.briefBubble && !a.briefBubble.done) {
-            if (thinkStyle) {
-                // 已结论 → 气泡已在 concludeBriefTurn 的 else 分支通过 sendRaw 发出
-                //   think+body 整条消息，这里只需收掉气泡（避免重复下发）。
-                // 未结论 → doStreamThink 可能已把半成品 thinking 流进气泡 (无 </think> 闭合),
-                //   用闭合的 thinking 快照收口, 避免 WeCom 渲染标签未闭合的乱排版。
-                //   如果连 thinking 都没有 (streamPending 还在), 空收。
-                if (a.briefConcluded) {
-                    void finishBriefBubble(a, withSessionTag(a.target, " "), true);
-                }
-                else {
-                    const think = a.briefThinking?.trim();
-                    const content = think
-                        ? `${openThink(a.target, think)}</think>`
-                        : withSessionTag(a.target, " ");
-                    void finishBriefBubble(a, content, true);
-                }
-            }
-            else {
-                void finishBriefBubble(a, briefDetailLink(a.briefTurnId, a.target), true);
-            }
-        }
+        concludeBriefTurn(a, a.briefLastText ?? "");
         recordTurnClose(a.briefTurnId);
         log.info({ sessionId: a.sessionId, turnId: a.briefTurnId }, "brief: turn closed");
         a.briefTurnId = undefined;
@@ -2215,16 +2037,7 @@ export const startMirror = (deps) => {
         a.briefIsSlash = false;
         a.briefConcluded = false;
         a.briefLastText = undefined;
-        a.briefThinking = undefined;
-        if (a.thinkFlushTimer) {
-            clearTimeout(a.thinkFlushTimer);
-            a.thinkFlushTimer = undefined;
-        }
-        a.thinkFlushing = false;
-        // 放行下一个排队的 turn —— 它的气泡早在 ack 时就挂出去了, 这里只是激活。
-        const next = a.briefQueue?.shift();
-        if (next)
-            openBriefTurn(a, next);
+        clearCot(a);
     };
     // 强制收口一个 attachment 的全部出站通道, 并返回收掉的气泡/流条数。
     //
@@ -2235,19 +2048,11 @@ export const startMirror = (deps) => {
     // 状态的清算, Esc 之类要碰 pane 的动作留给调用方在这之后自己尽力去做。
     const teardownOutbound = (a, note) => {
         let closed = 0;
-        // 排队中的 turn 先清空再动当前 turn —— 反序会让 closeBriefTurn 顺手 shift
-        // 一个僵尸 turn 上来当活跃 turn, 白收一遍。
-        for (const q of a.briefQueue ?? []) {
-            closed++;
-            // think-style: 不发链接, 排队气泡收为"已取消"提示 (避免空白气泡闪过)。
-            void finishBubble(a, q.bubble, thinkStyle ? withSessionTag(a.target, "⏳ (queued, cancelled)") : briefDetailLink(q.turnId, a.target), thinkStyle);
-            recordTurnClose(q.turnId);
-        }
-        a.briefQueue = [];
         if (a.briefTurnId) {
             closed++;
             closeBriefTurn(a);
         }
+        clearCot(a); // 无 turn 也要撤: 它可能正挂在一个已被 finish 掉的气泡上
         if (a.softEnd) {
             clearTimeout(a.softEnd);
             a.softEnd = undefined;
@@ -2259,7 +2064,7 @@ export const startMirror = (deps) => {
         }
         if (a.standaloneBuf) {
             clearTimeout(a.standaloneBuf.timer);
-            flushStandalone(a, true);
+            flushStandalone(a);
         }
         if (a.liveStream && !a.liveStream.closed) {
             closed++;
@@ -2304,15 +2109,10 @@ export const startMirror = (deps) => {
         const turnId = a.briefTurnId;
         if (!turnId)
             return;
-        // 首条 item 到达 → 清除 earlyTimer (CLI 已有响应, 不需要超时收链接了)。
-        if (a.briefBubble?.earlyTimer) {
-            clearTimeout(a.briefBubble.earlyTimer);
-            a.briefBubble.earlyTimer = undefined;
-        }
         const now = Date.now();
         if (item.kind === "tool_use") {
-            a.briefHadTool = true; // 有工具 → 气泡收口写详情链接, 结论另发 standalone
-            earlyLinkBubble(a); // 立刻推详情链接, 不等 turn 收口 (think-style 下保持气泡开放)
+            markBriefTool(a);
+            updateBriefProgress(a, cotToolLabel(item.calls));
             for (const c of item.calls) {
                 // 也走单卡 detail record — turn 页里 tool_use 段可点开链到独立详情 (以后有需要时)。
                 if (c.toolUseId) {
@@ -2332,67 +2132,28 @@ export const startMirror = (deps) => {
                     ts: now,
                 });
             }
-            // think-style: 工具调用也算中间过程, 以 `🔧 [Name compact](url)` 摘要进 think,
-            // 复用 tool call detail url, 让 think 内容里的工具调用也可点开独立详情。
-            if (thinkStyle) {
-                const lines = item.calls
-                    .map((c) => {
-                    const compact = safeForMarkdown(renderToolInputCompact(c.input, cfg.wrc.mirror.toolUseInlineMaxChars));
-                    const url = detailUrlFor(c.toolUseId, a.target);
-                    return url ? `🔧 [${c.name} ${compact}](${url})` : `🔧 ${c.name} ${compact}`;
-                })
-                    .join("\n");
-                pushThink(a, lines);
-            }
             return;
         }
         if (item.kind === "tool_result") {
-            earlyLinkBubble(a);
+            markBriefTool(a);
             recordTurnItem(turnId, { t: "tool_result", toolUseId: item.toolUseId, body: item.full, ts: now });
-            // think-style: 工具结果 (中间输出) 也进 think, 单行截断免刷屏。
-            if (thinkStyle)
-                pushThink(a, `↳ ${oneLineSummary(item.full, cfg.wrc.mirror.toolUseInlineMaxChars)}`);
-            return;
-        }
-        if (item.kind === "thinking") {
-            recordTurnItem(turnId, { t: "text", body: item.body, ts: now });
-            // thinking items only emitted by parser when thinkStyle=true (line 736 gate).
-            pushThink(a, item.body); // reasoning 进 think 流
             return;
         }
         if (item.kind === "text") {
             recordTurnItem(turnId, { t: "text", body: item.body, ts: now, final: item.final === true });
-            // think-style: 确知的中途输出 (final===false) 只进 think 流, 不算结论;
-            // 软后端的不确定态 (final===undefined) 两可 — 见下方分支里的分流说明。
-            if (thinkStyle && item.final === false) {
-                pushThink(a, item.body);
-                return;
-            }
-            if (thinkStyle && item.final === undefined) {
-                // 软后端说不清这句是不是终句, 两可:
-                // 气泡还活 → 进 think 累积 (收口时 stripTrailingBody 会剥掉重复), 同时记
-                //   briefLastText 当正文候选; 终句身份留给 closeBriefTurn(soft) 定夺。
-                // 气泡已死 → 没有收口阶段可纠偏, 只能按正文发 —— 它很可能就是终句,
-                //   走 pushThink 会给它打 💭 前缀, 把答复整个塞进 <think>。
-                if (a.briefBubble && !a.briefBubble.done) {
-                    a.briefLastText = item.body;
-                    pushThink(a, item.body);
-                }
-                else {
-                    enqueueStandalone(a, item.body);
-                }
-                return;
-            }
-            a.briefLastText = item.body; // 软收口时拿它当结论 (那条路径上没有 final 标记)
-            // final===false 才是"确知的中途输出"; undefined 是后端说不清, 不能据此提前收气泡。
+            a.briefLastText = item.body;
             if (item.final === false)
-                earlyLinkBubble(a);
+                markBriefTool(a);
             if (item.final === true)
                 concludeBriefTurn(a, item.body);
+            // 非终句文本 (中途叙述, 软后端含最终答案本身) 也是 CoT —— 推进进度行。
+            // 终句走 conclude 直接定稿气泡, clearCot 会撤掉可能挂着的进度刷新。
+            else
+                updateBriefProgress(a, item.body);
             return;
         }
         if (item.kind === "turn_end") {
-            closeBriefTurn(a, item.soft === true);
+            closeBriefTurn(a);
             return;
         }
         if (item.kind === "turn_usage") {
@@ -2431,10 +2192,10 @@ export const startMirror = (deps) => {
             void finishBriefBubble(a, banner);
         else
             enqueueStandalone(a, banner);
-        // 连同排队中的 turn 一起收掉: goal 期间所有 item 走 handleGoalItem, 排队的 turn
-        // 永远等不到自己的产出。closeBriefTurn 会逐个放行再关闭, 每个都留下详情链接。
-        while (a.briefTurnId)
-            closeBriefTurn(a); // bubble now done → closeBriefTurn skips re-finalizing
+        // 活跃 brief turn 也收掉: goal 期间所有 item 走 handleGoalItem, 它永远等不到
+        // 自己的 turn_end。气泡已 done → closeBriefTurn 不会重复收口。
+        if (a.briefTurnId)
+            closeBriefTurn(a);
         a.goalActive = true;
         log.info({ sessionId: a.sessionId, target: a.target, condition }, "goal: entered progress mode");
     };
@@ -2465,7 +2226,7 @@ export const startMirror = (deps) => {
             return;
         }
         if (cfg.wrc.mirror.brief && a.briefTurnId) {
-            closeBriefTurn(a, true);
+            closeBriefTurn(a);
             return;
         }
         if (a.liveStream && !a.liveStream.closed)
@@ -2519,6 +2280,14 @@ export const startMirror = (deps) => {
             clearTimeout(a.softEnd);
             a.softEnd = undefined;
         }
+        // thinking 唯一的出口是 brief 气泡的 CoT 进度行。必须在这里就吃掉 —— 漏到下面任何
+        // 一条通道 (deferred buf → renderBuf / standalone / stream append) 都会把它写进正文,
+        // 那就变回已下线的 thinkStyle 了。
+        if (item.kind === "thinking") {
+            if (cfg.wrc.mirror.brief && a.briefTurnId)
+                updateBriefProgress(a, item.body);
+            return;
+        }
         if (item.kind === "turn_end" && item.soft === true) {
             a.softEnd = setTimeout(() => fireSoftTurnEnd(a), softTurnEndMsFor(a));
             return;
@@ -2765,13 +2534,13 @@ export const startMirror = (deps) => {
             clearTimeout(a.softEnd);
             a.softEnd = undefined;
         }
-        while (a.briefTurnId)
-            closeBriefTurn(a); // 活跃 + 排队中的 turn 全部收掉
+        if (a.briefTurnId)
+            closeBriefTurn(a); // 活跃 turn 收掉 (队列已随对话边界策略移除)
         if (a.liveStream && !a.liveStream.closed)
             void finalizeStream(a, a.liveStream);
         if (a.standaloneBuf) {
             clearTimeout(a.standaloneBuf.timer);
-            flushStandalone(a, true);
+            flushStandalone(a);
         }
         a.tail.stop();
         bySessionId.delete(a.sessionId);
@@ -2836,7 +2605,6 @@ export const startMirror = (deps) => {
             log: log.child({ sub: "tail", sessionId }),
             includeUser: cfg.wrc.mirror.includeUser,
             includeTools: cfg.wrc.mirror.includeTools,
-            thinkStyle,
             includeToolResults: cfg.wrc.mirror.includeToolResults,
             toolResultMaxChars: cfg.wrc.mirror.toolResultMaxChars,
             toolUseInlineMaxChars: cfg.wrc.mirror.toolUseInlineMaxChars,
@@ -3048,7 +2816,7 @@ export const startMirror = (deps) => {
         log.info("mirror: no persisted attachments and no pinned sessionId — waiting for /new or /mirror/attach");
     }
     // Render full tool details for a finalized turn into one-or-more markdown
-    // chunks (split at chunkChars boundaries).
+    // chunks (split at chunkBytes boundaries).
     const renderToolDetails = (tools) => {
         const parts = [];
         let i = 0;
@@ -3068,7 +2836,7 @@ export const startMirror = (deps) => {
             parts.push(`### ${i}. 🔧 ${t.name}\n\n**input**\n\`\`\`json\n${truncate(inputJson, 4000)}\n\`\`\`\n\n**result**\n\`\`\`\n${truncate(result, 4000)}\n\`\`\``);
         }
         const merged = parts.join("\n\n---\n\n");
-        return splitChunks(merged, Math.max(200, cfg.wrc.mirror.chunkChars - TAG_HEADER_BUDGET));
+        return splitChunks(merged, Math.max(200, cfg.wrc.mirror.chunkBytes - TAG_HEADER_BUDGET));
     };
     const resolveToolDetail = (turnId) => {
         evictTurns();
@@ -3218,7 +2986,6 @@ export const startMirror = (deps) => {
             log: log.child({ sub: "tail", sessionId: newSessionId }),
             includeUser: cfg.wrc.mirror.includeUser,
             includeTools: cfg.wrc.mirror.includeTools,
-            thinkStyle,
             includeToolResults: cfg.wrc.mirror.includeToolResults,
             toolResultMaxChars: cfg.wrc.mirror.toolResultMaxChars,
             toolUseInlineMaxChars: cfg.wrc.mirror.toolUseInlineMaxChars,
@@ -4258,7 +4025,7 @@ export const startMirror = (deps) => {
             // 3) standalone 防抖里 (3s 默认) 还压着的合并文案 — 强制立刻发。
             if (a.standaloneBuf) {
                 clearTimeout(a.standaloneBuf.timer);
-                flushStandalone(a, true);
+                flushStandalone(a);
             }
             // 4) liveStream 半成品: 当前 acc 里有内容但还没 flush 出去 — 同步刷一刀,
             //    保留 stream 不 finalize (后续 tool_result 还要继续 append 同一气泡)。
@@ -4594,22 +4361,31 @@ export const startMirror = (deps) => {
             // 否则这次清空在 chat 详情里毫无痕迹, 前后两轮看着还是连续的。
             if (armMigration)
                 a.ctxCut = "clear";
-            // Drop any prior turn's outbound deferral state — a new dispatch always
-            // supersedes whatever was buffered/awaiting. The old frame is dead by our
-            // own choice (we won't write to it anymore); the user might still later
-            // click an old approval card, but terminateLiveStream will find no
-            // matching outbound slot and no-op gracefully.
+            // 新消息 = 对话边界: 上一 turn 的出站状态在此清算。softEnd 是旧 turn 的
+            // 静默期收口判决, 残留到新 turn 会在中途开火、提前收掉新气泡/新流;
+            // deferred 缓冲里是已从 tail 消费但还没下发的 item, 收入旧 streamId 收口
+            // (exitDeferredAsFinalStream): 正文进流关掉 loading 气泡, 只有 trailing 终句
+            // 才走 standalone, 空缓冲一个字都不写 —— 不再整体另发 standalone。旧 frame
+            // 就此作废; 用户之后点旧审批卡, terminateLiveStream 找不到 outbound 槽位会
+            // 优雅 no-op。
+            if (a.softEnd) {
+                clearTimeout(a.softEnd);
+                a.softEnd = undefined;
+            }
             if (a.outbound) {
-                if (a.outbound.kind === "deferred")
-                    clearTimeout(a.outbound.timer);
-                a.outbound = undefined;
+                if (a.outbound.kind === "deferred") {
+                    exitDeferredAsFinalStream(a);
+                }
+                else {
+                    a.outbound = undefined;
+                }
             }
             // Drain any pending standalone debounce so a prior turn's tail tail
             // doesn't get sandwiched into this turn's pre-card flush (Path A) or
             // race against the new stream's first content (Path B).
             if (a.standaloneBuf) {
                 clearTimeout(a.standaloneBuf.timer);
-                flushStandalone(a, true);
+                flushStandalone(a);
             }
             // /clear produces no assistant output; opening a stream would leave a
             // stale "…" + quoted-user bubble in WeCom. Skip the stream entirely on
@@ -4634,7 +4410,8 @@ export const startMirror = (deps) => {
                 }
             }
             if (brief) {
-                // 挂 loading 气泡并起新 turn (上一 turn 还在跑则排队, 由它收口时放行)。
+                // 挂 loading 气泡并起新 turn —— 上一 turn 若还在跑, startBriefTurn 内部
+                // 会立刻把它收掉 (对话边界策略), 本轮直接成为活跃 turn。
                 // 后续 onItem 走 handleBriefItem, 不再走 stream / defer 路径。
                 await startBriefTurn(a, frame, streamId, isSlash, text);
             }