wezard 1.2.19 → 1.2.22

package/dist/daemon/mirror-bridge.js

@@ -21,9 +21,10 @@ import { isModalPane, parseModalOptions, pickModalAnswer } from "../shared/modal
 import { hasMirrorAskq, runMirrorAskqFlow, hasMirrorPlan, mootMirrorPlan, runMirrorPlanFlow } from "./approval.js";
 import { runTmux as runTmuxCmd, spawnTmuxClaude } from "./spawn-tmux.js";
 import { recordTool, recordToolResult, recordTurnStart, recordTurnItem, recordTurnUsage, recordTurnClose, recordCloseOpenTurns, buildDetailUrl, buildChatUrl } from "./detail.js";
-import { labelFor, tagOfKey, baseOfKey, withTagHeader } from "../shared/session-label.js";
+import { labelFor, tagOfKey, baseOfKey, keyOf, withTagHeader } from "../shared/session-label.js";
 import { splitMarkdown } from "../shared/md-chunk.js";
 import { randomTip } from "./tips.js";
+import { chatBaseOf, chatNameOf, listChatNames, normChatName, parsePeerRef, peerAddress } from "./chat-name.js";
 import { stripAnsi, compactPane, paneIsBusy, paneIsStalled, transcriptStalled, summarizeTail, lastAssistantText, lastContextTokens, keepaliveStamps, tailTurns, renderDialog } from "./peers.js";
 // Same PATH augmentation logic as cc-bridge: launchd / systemd start the daemon
 // with a stripped PATH that often lacks nvm / homebrew, breaking spawn(claudeBin).
@@ -353,6 +354,20 @@ 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
@@ -563,7 +578,14 @@ const renderLine = (raw, deps) => {
                     flushPending();
                 pending.push({ toolUseId, name, input: b.input });
             }
-            // thinking blocks intentionally skipped
+            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 });
+            }
+            // thinking blocks otherwise intentionally skipped (只进详情页)
         }
         flushPending();
         // Emit per-line usage snapshot BEFORE turn_end so brief store gets the last
@@ -1262,6 +1284,8 @@ 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).
@@ -1462,6 +1486,8 @@ 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));
@@ -1768,6 +1794,63 @@ export const startMirror = (deps) => {
         }
     };
     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 外包。
+    const streamThink = (a) => {
+        const b = a.briefBubble;
+        const think = a.briefThinking?.trim();
+        if (!b || b.done || !think)
+            return;
+        client
+            .replyStream(b.frame, b.streamId, openThink(a.target, think), false)
+            .catch((e) => log.warn({ sessionId: a.sessionId, err: e.message }, "brief: think stream failed"));
+    };
+    // think-style 且气泡已过窗口 (b.done / 无气泡): 攒 think 增量, 10s 防抖后整段补发
+    // 一条 `<think>🧙 …</think>` standalone —— 窗口外没法再刷气泡, 拉长防抖免刷屏。
+    const THINK_STANDALONE_DEBOUNCE_MS = 10_000;
+    const flushThinkStandalone = (a) => {
+        const p = a.briefThinkPending;
+        if (!p)
+            return;
+        a.briefThinkPending = undefined;
+        const chunk = p.parts.join("\n\n").trim();
+        if (chunk)
+            sendRaw(a, `${openThink(a.target, chunk)}</think>`);
+    };
+    const enqueueThinkStandalone = (a, chunk) => {
+        if (a.briefThinkPending) {
+            clearTimeout(a.briefThinkPending.timer);
+            a.briefThinkPending.parts.push(chunk);
+            a.briefThinkPending.timer = setTimeout(() => flushThinkStandalone(a), THINK_STANDALONE_DEBOUNCE_MS);
+            return;
+        }
+        a.briefThinkPending = { parts: [chunk], timer: setTimeout(() => flushThinkStandalone(a), THINK_STANDALONE_DEBOUNCE_MS) };
+    };
+    const clearThinkPending = (a) => {
+        if (a.briefThinkPending) {
+            clearTimeout(a.briefThinkPending.timer);
+            a.briefThinkPending = undefined;
+        }
+    };
+    // think-style 单一入口: 一段中间过程 (reasoning / 中途文本 / 工具调用) 进 think。
+    // 气泡还活 → 累积进 briefThinking 并全量刷进气泡; 已过窗口 → 走 10s 防抖 standalone。
+    const pushThink = (a, chunk) => {
+        const c = chunk.trim();
+        if (!c)
+            return;
+        a.briefThinking = a.briefThinking ? `${a.briefThinking}\n\n${c}` : c;
+        if (a.briefBubble && !a.briefBubble.done)
+            streamThink(a);
+        else
+            enqueueThinkStandalone(a, c);
+    };
     // 让一个已建好记录的 turn 成为活跃 turn。turn 级状态在这里统一归零 —— 唯一入口。
     const openBriefTurn = (a, q) => {
         a.briefTurnId = q.turnId;
@@ -1776,6 +1859,8 @@ export const startMirror = (deps) => {
         a.briefHadTool = false;
         a.briefConcluded = false;
         a.briefLastText = undefined;
+        a.briefThinking = undefined;
+        clearThinkPending(a);
         log.info({ sessionId: a.sessionId, turnId: q.turnId, isSlash: q.isSlash }, "brief: turn started");
     };
     // WeCom 侧发起一个 turn: 立刻挂 loading 气泡当 ack, 再决定是马上激活还是排队。
@@ -1810,16 +1895,25 @@ export const startMirror = (deps) => {
                 log.warn({ sessionId: a.sessionId, turnId }, "brief: queued turn timed out — force-closing the stuck one");
                 closeBriefTurn(a);
             }
-            void finishBubble(a, bubble, briefDetailLink(turnId, a.target), true);
+            // think-style: 到点也不发链接, 有累积 thinking 就收进气泡 (tag 在 <think> 内), 否则空收。
+            if (thinkStyle) {
+                const think = a.briefThinking?.trim();
+                void finishBubble(a, bubble, think ? `${openThink(a.target, think)}</think>` : withSessionTag(a.target, " "), true);
+            }
+            else {
+                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 指向的是前一个。
-        bubble.earlyTimer = setTimeout(() => {
-            if (bubble.done)
-                return;
-            void finishBubble(a, bubble, briefDetailLink(turnId, a.target), true);
-        }, EARLY_LINK_MS);
+        // think-style: 不设 earlyTimer —— 不发链接, 气泡留着等 thinking / 答复流进来。
+        if (!thinkStyle)
+            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)");
@@ -1828,7 +1922,14 @@ export const startMirror = (deps) => {
             openBriefTurn(a, q);
         }
         try {
-            await client.replyStream(frame, streamId, withSessionTag(a.target, "…"), false); // 挂住 loading 气泡, 不关闭
+            // think-style: 用户一发消息立刻回 `<think>🧙 ` 开头 (tag 在 <think> 内), 不再先占位 `…`。
+            // 后续 thinking / 中途文本经 streamThink 全量替换续写, 收口时补 `</think>\n\n<final>`。
+            if (thinkStyle) {
+                await client.replyStream(frame, streamId, openThink(a.target, ""), false);
+            }
+            else {
+                await client.replyStream(frame, streamId, withSessionTag(a.target, "…"), false); // 挂住 loading 气泡, 不关闭
+            }
         }
         catch (e) {
             log.warn({ sessionId: a.sessionId, turnId, err: e.message }, "brief: turn ack failed");
@@ -1851,7 +1952,11 @@ export const startMirror = (deps) => {
         a.briefHadTool = false;
         a.briefConcluded = false;
         a.briefLastText = undefined;
-        sendRaw(a, briefDetailLink(turnId, a.target));
+        a.briefThinking = undefined;
+        clearThinkPending(a);
+        // think-style: 不推详情链接 (CLI 侧发起的无气泡 turn 无处可流, 保持静默; 最终答复走 standalone)。
+        if (!thinkStyle)
+            sendRaw(a, briefDetailLink(turnId, a.target));
         log.info({ sessionId: a.sessionId, turnId }, "brief: turn started (CLI-side, no bubble)");
     };
     // 本轮一旦出现工具调用 / tool_result / 非 final 文本, 就说明这不是"一句话答完"的
@@ -1861,6 +1966,11 @@ export const startMirror = (deps) => {
     const earlyLinkBubble = (a) => {
         if (!a.briefTurnId || !a.briefBubble || a.briefBubble.done)
             return;
+        // think-style: 不收气泡、不发链接 —— 气泡留着继续流 thinking / 最终答复。
+        if (thinkStyle) {
+            a.briefHadTool = true;
+            return;
+        }
         a.briefHadTool = true;
         void finishBriefBubble(a, briefDetailLink(a.briefTurnId, a.target), true);
     };
@@ -1873,10 +1983,41 @@ export const startMirror = (deps) => {
         if (!turnId || a.briefConcluded || !body.trim())
             return;
         a.briefConcluded = true;
-        if (a.briefHadTool || !a.briefBubble)
+        // 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 (thinkStyle) {
+            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 {
+                // 已过窗口: think 已随 10s 防抖 standalone 陆续发出, 这里先把残余 think 冲干净,
+                // 正文单独发一条 (带 tag), 不再重复整段 think。软后端最终正文可能落在残余
+                // 增量尾部 —— flush 前先把等于 body 的尾段摘掉, 免得 think standalone 再重一遍。
+                const p = a.briefThinkPending;
+                if (p) {
+                    clearTimeout(p.timer);
+                    while (p.parts.length && p.parts[p.parts.length - 1].trim() === body.trim())
+                        p.parts.pop();
+                    if (p.parts.length)
+                        flushThinkStandalone(a);
+                    else
+                        a.briefThinkPending = undefined;
+                }
+                sendStandalone(a, body);
+            }
+        }
+        else if (a.briefHadTool || !a.briefBubble) {
             sendStandalone(a, body);
-        else
+        }
+        else {
             void finishBriefBubble(a, `${body}\n\n${briefDetailLink(turnId, a.target)}`);
+        }
         // 排队中的 turn 已经建了记录但还没跑, 不能被这把扫帚扫成「已完成」。
         const keep = [turnId, ...(a.briefQueue ?? []).map((q) => q.turnId)];
         recordCloseOpenTurns({ target: a.target, sessionId: a.sessionId, exceptIds: keep });
@@ -1891,16 +2032,29 @@ export const startMirror = (deps) => {
         // 气泡还开着 (有工具的 turn: 结论只发了 standalone, 气泡留到这里收链接; 或空 turn
         // 没有结论) —— 收口: 统一写详情链接, 保证每个 turn 都有可点入口。
         if (a.briefBubble && !a.briefBubble.done) {
-            void finishBriefBubble(a, briefDetailLink(a.briefTurnId, a.target), true);
+            if (thinkStyle) {
+                // think-style: 不发链接。有累积 thinking 就收进气泡 (tag 在 <think> 内), 否则空收。
+                const think = a.briefThinking?.trim();
+                void finishBriefBubble(a, think ? `${openThink(a.target, think)}</think>` : withSessionTag(a.target, " "), true);
+            }
+            else {
+                void finishBriefBubble(a, briefDetailLink(a.briefTurnId, a.target), true);
+            }
         }
         recordTurnClose(a.briefTurnId);
         log.info({ sessionId: a.sessionId, turnId: a.briefTurnId }, "brief: turn closed");
+        // 残余 think 增量 (窗口外攒着还没到 10s) 收口时冲干净, 免得漏掉本轮最后一段思考。
+        if (a.briefThinkPending) {
+            clearTimeout(a.briefThinkPending.timer);
+            flushThinkStandalone(a);
+        }
         a.briefTurnId = undefined;
         a.briefBubble = undefined;
         a.briefHadTool = false;
         a.briefIsSlash = false;
         a.briefConcluded = false;
         a.briefLastText = undefined;
+        a.briefThinking = undefined;
         // 放行下一个排队的 turn —— 它的气泡早在 ack 时就挂出去了, 这里只是激活。
         const next = a.briefQueue?.shift();
         if (next)
@@ -1919,7 +2073,8 @@ export const startMirror = (deps) => {
         // 一个僵尸 turn 上来当活跃 turn, 白收一遍。
         for (const q of a.briefQueue ?? []) {
             closed++;
-            void finishBubble(a, q.bubble, briefDetailLink(q.turnId, a.target));
+            // think-style: 不发链接, 排队气泡直接空收。
+            void finishBubble(a, q.bubble, thinkStyle ? " " : briefDetailLink(q.turnId, a.target), thinkStyle);
             recordTurnClose(q.turnId);
         }
         a.briefQueue = [];
@@ -1991,7 +2146,7 @@ export const startMirror = (deps) => {
         const now = Date.now();
         if (item.kind === "tool_use") {
             a.briefHadTool = true; // 有工具 → 气泡收口写详情链接, 结论另发 standalone
-            earlyLinkBubble(a); // 立刻推详情链接, 不等 turn 收口
+            earlyLinkBubble(a); // 立刻推详情链接, 不等 turn 收口 (think-style 下为 no-op)
             for (const c of item.calls) {
                 // 也走单卡 detail record — turn 页里 tool_use 段可点开链到独立详情 (以后有需要时)。
                 if (c.toolUseId) {
@@ -2011,16 +2166,40 @@ export const startMirror = (deps) => {
                     ts: now,
                 });
             }
+            // think-style: 工具调用也算中间过程, 以 `🔧 Name compact` 摘要进 think。
+            if (thinkStyle) {
+                const lines = item.calls
+                    .map((c) => `🔧 ${c.name} ${renderToolInputCompact(c.input, cfg.wrc.mirror.toolUseInlineMaxChars)}`.trim())
+                    .join("\n");
+                pushThink(a, lines);
+            }
             return;
         }
         if (item.kind === "tool_result") {
             earlyLinkBubble(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 });
+            if (thinkStyle)
+                pushThink(a, item.body); // reasoning 进 think 流
+            else
+                a.briefThinking = a.briefThinking ? `${a.briefThinking}\n\n${item.body}` : item.body;
             return;
         }
         if (item.kind === "text") {
             recordTurnItem(turnId, { t: "text", body: item.body, ts: now, final: item.final === true });
             a.briefLastText = item.body; // 软收口时拿它当结论 (那条路径上没有 final 标记)
+            // think-style: 非 final 文本 (中途叙述) 也进 think 流, 与 reasoning / 工具一视同仁 ——
+            // 只有 final 文本结束思考、成为正文。
+            if (thinkStyle && item.final !== true) {
+                pushThink(a, item.body);
+                return;
+            }
             // final===false 才是"确知的中途输出"; undefined 是后端说不清, 不能据此提前收气泡。
             if (item.final === false)
                 earlyLinkBubble(a);
@@ -2116,73 +2295,39 @@ export const startMirror = (deps) => {
         clearTimeout(a.keepaliveQuiet);
         a.keepaliveQuiet = undefined;
     };
-    // A reply is still a heartbeat while its letters remain a prefix of "pong"
-    // (covers streamed partials "p"/"po"/"pon" and trailing punctuation). Anything
-    // else means the model ignored the ping and resumed real work.
-    const pongPrefix = (s) => "pong".startsWith(s.replace(/[^a-zA-Z]/g, "").toLowerCase());
-    // Stop swallowing the in-flight ping turn: close its heartbeat detail turn,
-    // lift the quiet window, and re-anchor the clocks to "real activity now" so the
-    // resumed work resets the round budget. The caller then falls through to the
-    // normal onItem path, letting this and the rest of the turn reach chat.
-    const releaseKeepalive = (a) => {
-        if (a.keepaliveTurnId) {
-            recordTurnClose(a.keepaliveTurnId);
-            a.keepaliveTurnId = undefined;
-        }
-        endKeepaliveQuiet(a);
-        a.keepalivePongBuf = undefined;
-        if (a.keepalive) {
-            a.keepalive.round = 0;
-            a.keepalive.pinging = false;
-            a.keepalive.settledAt = 0;
-            a.keepalive.lastRealMs = Date.now();
-        }
-        log.info({ target: a.target, sessionId: a.sessionId }, "keepalive: reply diverged from pong — un-swallowing resumed turn");
-    };
+    // A keepalive ping turn is swallowed wholesale — the reply content doesn't
+    // matter (model may add extra commentary beyond "pong", that's fine).
     const onItem = (a, item) => {
         // 新 spawn 的 pane 在首次 inject 落地前吞掉所有初始输出 (greeting/system)。
         if (a.muteUntilInject)
             return;
         // Keepalive ping turns are cache-warmers: swallow every item from the WeCom
         // paths so the ping/pong never reaches chat. But record the REAL exchange
-        // into its chat-detail turn — the actual assistant reply (expected: just
-        // "pong"), the tool calls if any, and the usage (proof it was a cheap
-        // cache-read) — so the detail page shows the genuine heartbeat, not a
-        // synthetic summary. Closed on the terminal signal (hard or soft turn_end).
+        // into its chat-detail turn — the actual assistant reply, the tool calls if
+        // any, and the usage (proof it was a cheap cache-read) — so the detail page
+        // shows the genuine heartbeat, not a synthetic summary.
         if (a.keepaliveQuiet) {
-            // Swallow only while the reply is consistent with a bare "pong". A text
-            // whose accumulated letters leave the "pong" prefix, or ANY tool_use (a
-            // heartbeat never calls tools), means the model resumed real work → release
-            // and fall through so the turn reaches chat instead of being hidden.
-            const nextBuf = item.kind === "text" ? (a.keepalivePongBuf ?? "") + item.body : (a.keepalivePongBuf ?? "");
-            const divergent = item.kind === "tool_use" || (item.kind === "text" && !pongPrefix(nextBuf));
-            if (!divergent) {
-                if (item.kind === "text")
-                    a.keepalivePongBuf = nextBuf;
-                const id = a.keepaliveTurnId;
-                if (id) {
-                    const now = Date.now();
-                    if (item.kind === "text") {
-                        recordTurnItem(id, { t: "text", body: item.body, ts: now, final: item.final === true });
-                    }
-                    else if (item.kind === "tool_result") {
-                        recordTurnItem(id, { t: "tool_result", toolUseId: item.toolUseId, body: item.full, ts: now });
-                    }
-                    else if (item.kind === "turn_usage") {
-                        recordTurnUsage(id, { model: item.model, messageId: item.messageId, usage: item.usage });
-                    }
-                    else if (item.kind === "turn_end") {
-                        recordTurnClose(id);
-                        a.keepaliveTurnId = undefined;
-                    }
+            const id = a.keepaliveTurnId;
+            if (id) {
+                const now = Date.now();
+                if (item.kind === "text") {
+                    recordTurnItem(id, { t: "text", body: item.body, ts: now, final: item.final === true });
                 }
-                if (item.kind === "turn_end") {
-                    endKeepaliveQuiet(a);
-                    a.keepalivePongBuf = undefined;
+                else if (item.kind === "tool_result") {
+                    recordTurnItem(id, { t: "tool_result", toolUseId: item.toolUseId, body: item.full, ts: now });
                 }
-                return;
+                else if (item.kind === "turn_usage") {
+                    recordTurnUsage(id, { model: item.model, messageId: item.messageId, usage: item.usage });
+                }
+                else if (item.kind === "turn_end") {
+                    recordTurnClose(id);
+                    a.keepaliveTurnId = undefined;
+                }
+            }
+            if (item.kind === "turn_end") {
+                endKeepaliveQuiet(a);
             }
-            releaseKeepalive(a); // fall through to normal handling for this item
+            return;
         }
         // 任何新 item 到达 = 上一条"消息写完了"并不代表这一轮结束 → 撤销待确认的软收口。
         // 硬信号 (end_turn / turn_duration) 的后端永远不会走到这里。
@@ -2501,6 +2646,7 @@ export const startMirror = (deps) => {
             log: log.child({ sub: "tail", sessionId }),
             includeUser: cfg.wrc.mirror.includeUser,
             includeTools: cfg.wrc.mirror.includeTools,
+            thinkStyle: cfg.wrc.mirror.thinkStyle && cfg.wrc.mirror.brief,
             includeToolResults: cfg.wrc.mirror.includeToolResults,
             toolResultMaxChars: cfg.wrc.mirror.toolResultMaxChars,
             toolUseInlineMaxChars: cfg.wrc.mirror.toolUseInlineMaxChars,
@@ -2882,6 +3028,7 @@ export const startMirror = (deps) => {
             log: log.child({ sub: "tail", sessionId: newSessionId }),
             includeUser: cfg.wrc.mirror.includeUser,
             includeTools: cfg.wrc.mirror.includeTools,
+            thinkStyle: cfg.wrc.mirror.thinkStyle && cfg.wrc.mirror.brief,
             includeToolResults: cfg.wrc.mirror.includeToolResults,
             toolResultMaxChars: cfg.wrc.mirror.toolResultMaxChars,
             toolUseInlineMaxChars: cfg.wrc.mirror.toolUseInlineMaxChars,
@@ -3420,10 +3567,95 @@ export const startMirror = (deps) => {
     // untagged default plus every `#tag`. Live attachments are the truth; the
     // persisted store fills in cold bindings so a peer nobody has talked to since
     // the last reload is still discoverable (and revivable) rather than invisible.
+    const allTargets = () => {
+        const keys = new Set([...byTarget.keys(), ...Object.keys(deps.store.all())]);
+        return Array.from(keys).sort();
+    };
     const chatTargets = (target) => {
         const base = basePrincipalOf(target);
-        const keys = new Set([...byTarget.keys(), ...Object.keys(deps.store.all())]);
-        return Array.from(keys).filter((k) => basePrincipalOf(k) === base).sort();
+        return allTargets().filter((k) => basePrincipalOf(k) === base);
+    };
+    // 名字解析:`daily` / `chat:wrxxx` → base principal。认不出就把已知名字一并回给
+    // 调用方 —— 跨 chat 出错时"我该写什么"比"你写错了"有用得多。
+    const resolveChatRef = (ref) => {
+        const base = chatBaseOf(cfg, ref);
+        if (base)
+            return { ok: true, base };
+        const known = listChatNames(cfg).map((c) => c.name);
+        return {
+            ok: false,
+            reason: `unknown chat '${ref}' — give that chat a name first (\`/name ${normChatName(ref) || "<name>"}\` inside it)`,
+            candidates: known,
+        };
+    };
+    // peer 寻址。地址是两级的(见 chat-name.ts):
+    //   ""            本 chat 的 default —— 自身语义不变;
+    //   `fix`         本 chat 优先,本 chat 没有再全局兜底(全 host 唯一才认)——
+    //                 命名之前唯一的跨 chat 路子,老调用方不能因为引入命名而断掉;
+    //   `daily#fix`   daily 这个 chat 里的 `#fix`,精确到点,不问 tag 全不全局唯一;
+    //   `daily#`      daily 的 default 会话;
+    //   `chat:wr…#fix` 全量 key 同理(list_peers 吐的就是它)。
+    // 裸 tag 的 0 命中 / ≥2 命中依旧拒绝,但出路从"回去改 tag 名"变成"用带 chat 名
+    // 的全称地址"——后者不需要动别人的会话。
+    const resolvePeerTag = (self, ref) => {
+        const { chat, tag } = parsePeerRef(ref ?? "");
+        const t = tag.trim();
+        if (chat) {
+            const c = resolveChatRef(chat);
+            if (!c.ok)
+                return c;
+            const target = keyOf(c.base, t);
+            if (allTargets().includes(target)) {
+                return { ok: true, target, foreign: c.base !== basePrincipalOf(self) };
+            }
+            return {
+                ok: false,
+                reason: `chat '${chat}' has no ${t ? `'#${t}'` : "default"} session — create it with new_claude_session({ chat: '${chat}'${t ? `, tag: '${t}'` : ""}, cwd })`,
+                candidates: allTargets().filter((k) => basePrincipalOf(k) === c.base),
+            };
+        }
+        const local = keyOf(basePrincipalOf(self), t);
+        if (!t)
+            return { ok: true, target: local, foreign: false };
+        const all = allTargets();
+        if (all.includes(local))
+            return { ok: true, target: local, foreign: false };
+        const foreignMatches = all.filter((k) => tagOfKey(k) === t && basePrincipalOf(k) !== basePrincipalOf(self));
+        if (foreignMatches.length === 1)
+            return { ok: true, target: foreignMatches[0], foreign: true };
+        if (foreignMatches.length === 0) {
+            // 裸 token 正好是个 chat 名字 —— 用户/agent 想说的是"那个群",不是"那个 tag"。
+            // 直接给出它的会话地址,比让人再查一次 list_chats 快。
+            const asChat = chatBaseOf(cfg, t);
+            if (asChat) {
+                return {
+                    ok: false,
+                    reason: `'${t}' is a CHAT, not a tag — address one of its sessions, e.g. '${t}#' for its default`,
+                    candidates: allTargets().filter((k) => basePrincipalOf(k) === asChat).map((k) => peerAddress(cfg, self, k)),
+                };
+            }
+            return { ok: false, reason: `no peer with tag '#${t}' — create one with new_claude_session, or address it in full as 'chatName#${t}' (list_chats shows the names)` };
+        }
+        return {
+            ok: false,
+            reason: `tag '#${t}' exists in ${foreignMatches.length} chats — address it in full as 'chatName#${t}' (list_chats shows the names)`,
+            candidates: foreignMatches.map((k) => peerAddress(cfg, self, k)),
+        };
+    };
+    /** 已知的每个 chat:命名的 + 有会话在跑的。`name` 为空即"还没起名",那就是
+     *  它暂时只能靠全局唯一 tag 被找到的原因。 */
+    const chatRoster = (self) => {
+        const bases = new Set([
+            ...listChatNames(cfg).map((c) => c.base),
+            ...allTargets().map(basePrincipalOf),
+            basePrincipalOf(self),
+        ]);
+        return [...bases].filter(Boolean).sort().map((base) => ({
+            base,
+            name: chatNameOf(cfg, base),
+            self: base === basePrincipalOf(self),
+            targets: allTargets().filter((k) => basePrincipalOf(k) === base),
+        }));
     };
     const paneOf = (target) => byTarget.get(target)?.tmuxPane || deps.store.get(target)?.tmuxPane || "";
     const jsonlOf = (target) => expandHome(byTarget.get(target)?.jsonlPath || deps.store.get(target)?.jsonlPath || "");
@@ -3436,38 +3668,52 @@ export const startMirror = (deps) => {
         const p = jsonlOf(target);
         return p ? lastAssistantText(p) : "";
     };
-    const peers = async (target) => {
-        const list = await Promise.all(chatTargets(target).map(async (t) => {
-            const a = byTarget.get(t);
-            const rec = deps.store.get(t);
-            const jsonlPath = jsonlOf(t);
-            const pane = paneOf(t);
-            const paneAlive = pane ? await tmuxPaneAlive(pane) : false;
-            const tag = tagOfTarget(t);
-            let lastActivity = 0;
-            try {
-                if (jsonlPath)
-                    lastActivity = statSync(jsonlPath).mtimeMs;
-            }
-            catch { /* not written yet */ }
-            return {
-                target: t,
-                tag,
-                label: tag ? labelFor(tag) : "🧙",
-                sessionId: a?.sessionId || rec?.sessionId || "",
-                jsonlPath,
-                cwd: a?.runningCwd || rec?.cwd || expandedDefaultCwd,
-                cli: jsonlPath ? backendForPath(jsonlPath).name : (activeBackends()[0]?.name ?? "claude"),
-                tmuxPane: pane,
-                attached: !!a,
-                paneAlive,
-                busy: paneAlive ? paneIsBusy(await capturePaneTail(pane, 12)) : false,
-                lastActivity,
-                summary: jsonlPath ? summarizeTail(jsonlPath) : "(未绑定会话)",
-                self: t === target,
-            };
-        }));
-        return list.sort((x, y) => y.lastActivity - x.lastActivity);
+    // 一个 target 的完整画像。本 chat 的兄弟和外 chat 的 peer 走同一条,只有
+    // `self` / `address` 因观察者而异 —— 地址本来就是相对调用方说的话。
+    const peerInfoOf = async (t, self) => {
+        const a = byTarget.get(t);
+        const rec = deps.store.get(t);
+        const jsonlPath = jsonlOf(t);
+        const pane = paneOf(t);
+        const paneAlive = pane ? await tmuxPaneAlive(pane) : false;
+        const tag = tagOfTarget(t);
+        let lastActivity = 0;
+        try {
+            if (jsonlPath)
+                lastActivity = statSync(jsonlPath).mtimeMs;
+        }
+        catch { /* not written yet */ }
+        return {
+            target: t,
+            tag,
+            chat: chatNameOf(cfg, t),
+            address: peerAddress(cfg, self, t),
+            label: tag ? labelFor(tag) : "🧙",
+            sessionId: a?.sessionId || rec?.sessionId || "",
+            jsonlPath,
+            cwd: a?.runningCwd || rec?.cwd || expandedDefaultCwd,
+            cli: jsonlPath ? backendForPath(jsonlPath).name : (activeBackends()[0]?.name ?? "claude"),
+            tmuxPane: pane,
+            attached: !!a,
+            paneAlive,
+            busy: paneAlive ? paneIsBusy(await capturePaneTail(pane, 12)) : false,
+            lastActivity,
+            summary: jsonlPath ? summarizeTail(jsonlPath) : "(未绑定会话)",
+            self: t === self,
+        };
+    };
+    const byRecent = (x, y) => y.lastActivity - x.lastActivity;
+    const peers = async (target) => (await Promise.all(chatTargets(target).map((t) => peerInfoOf(t, target)))).sort(byRecent);
+    // list_peers 的跨 chat 补充:其他 chat 里**当前调用方叫得动**的 session。两条
+    // 入选路径 —— tag 全局唯一(裸 tag 就能命中),或者它所在的 chat 有名字(全称
+    // `daily#fix` 命中)。后者是命名带来的新增量:同名 tag 不再互相遮蔽,想被找到
+    // 只要给群起个名,不必回去改别人的 tag。
+    const foreignPeers = async (self) => {
+        const selfBase = basePrincipalOf(self);
+        const foreign = allTargets().filter((k) => tagOfKey(k) && basePrincipalOf(k) !== selfBase);
+        const tagCount = foreign.reduce((acc, k) => acc.set(tagOfKey(k), (acc.get(tagOfKey(k)) ?? 0) + 1), new Map());
+        const reachable = foreign.filter((k) => tagCount.get(tagOfKey(k)) === 1 || chatNameOf(cfg, k));
+        return (await Promise.all(reachable.map((t) => peerInfoOf(t, self)))).sort(byRecent);
     };
     // Capture a few extra rows then compact away the TUI's blank padding, so
     // `rows` counts lines the user actually cares about.
@@ -3533,7 +3779,6 @@ export const startMirror = (deps) => {
         // buys a deterministic reply. keepaliveStamps matches every form, so none
         // reads as real activity. (round is incremented below, after the inject lands.)
         const text = stalled ? kc.resumePing : kc.ping;
-        a.keepalivePongBuf = ""; // fresh reply accumulator for the swallow/release gate
         // Suppress the pane→WeCom echo of the ping user line, then swallow the whole
         // ping turn (reply included). The 60s fail-safe clears the quiet window if
         // the turn somehow never emits turn_end, so a later real turn is never muted;
@@ -3678,7 +3923,11 @@ export const startMirror = (deps) => {
     const keepaliveTimer = setInterval(() => void keepaliveTick(), 15_000);
     return {
         attach,
+        chatTargets,
         peers,
+        foreignPeers,
+        resolvePeerTag,
+        chatRoster,
         peekPane,
         peekTurns,
         isBusy,