wezard 1.3.3 → 1.3.7

package/dist/daemon/mirror-bridge.js

@@ -20,12 +20,13 @@ import { activeBackends, backendForPath, projectDirFor, projectDirsFor, } from "
 import { isModalPane, isAskqSubmitPage, parseModalOptions, pickModalAnswer } from "../shared/modal-pane.js";
 import { hasMirrorAskq, runMirrorAskqFlow, hasMirrorPlan, mootMirrorPlan, runMirrorPlanFlow } from "./approval.js";
 import { runTmux as runTmuxCmd, spawnTmuxClaude } from "./spawn-tmux.js";
+import { startSubagentWatch } from "./subagent-tail.js";
 import { recordTool, recordToolResult, recordTurnStart, recordTurnItem, recordTurnUsage, recordTurnClose, recordCloseOpenTurns, buildDetailUrl, buildChatUrl } from "./detail.js";
-import { labelFor, tagOfKey, baseOfKey, keyOf, withTagHeader } from "../shared/session-label.js";
+import { labelFor, tagOfKey, baseOfKey, keyOf, withTagHeader, parseTagHeader } 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";
+import { stripAnsi, compactPane, paneIsBusy, paneIsStalled, transcriptStalled, limitResetAt, 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).
 const NODE_BIN_DIR = dirname(process.execPath);
@@ -465,11 +466,17 @@ const renderLine = (raw, deps) => {
             const goal = goalStartOf(c);
             if (goal)
                 return [goal];
-            if (!deps.includeUser)
-                return [];
             const text = cleanUserText(c);
             if (!text)
                 return []; // pure slash-command meta / stdout — drop
+            // Keepalive ping user line: judged by CONTENT, before every other gate
+            // (includeUser / isOwnInject's 60s TTL) — the ping never echoes, and
+            // the reply turn is swallowed by content in onItem. Timer windows can't
+            // cover reloads or replays; the user message itself always can.
+            if (deps.isKeepalivePing?.(text))
+                return [{ kind: "keepalive_start", body: text }];
+            if (!deps.includeUser)
+                return [];
             if (deps.isOwnInject(text))
                 return []; // dedupe WeCom→CLI echo
             const quoted = text.split("\n").map((l) => `> ${l}`).join("\n");
@@ -770,6 +777,7 @@ export const startMirrorTail = (deps) => {
             clearInterval(poll);
         },
         drain,
+        livePath: resolveLive,
     };
 };
 // Run a tmux subcommand, capturing stdout/stderr. Delegates to spawn-tmux's
@@ -1414,6 +1422,19 @@ export const startMirror = (deps) => {
         recentAssistantSends.splice(i, 1); // one-shot: a genuine later re-say still streams
         return true;
     };
+    // Keepalive ping detector for the tail's user-line judgment — the SAME
+    // normalized-prefix signature set keepaliveTick feeds keepaliveStamps
+    // (every configured form + the bare "ping" legacy streak form), so
+    // renderLine, the tick and the transcript parser all agree on what counts
+    // as a ping. Content is the source of truth for the swallow: timers and
+    // echo-TTLs lose it across reloads/replays.
+    const keepalivePingSigs = [cfg.wrc.mirror.keepalive.ping, cfg.wrc.mirror.keepalive.resumePing]
+        .map((p) => normAssistant(p).slice(0, 40))
+        .filter((s) => s.length > 0);
+    const isKeepalivePing = (text) => {
+        const n = normAssistant(text);
+        return n.toLowerCase() === "ping" || keepalivePingSigs.some((sig) => n.includes(sig));
+    };
     // ── Typewriter stream lifecycle ────────────────────────────────────
     // WeCom spec: server polls us for stream refreshes for up to 6 min from the
     // original inbound. SDK queues replyStream calls per req_id, sends serially
@@ -1480,6 +1501,9 @@ export const startMirror = (deps) => {
         if (s.closed)
             return;
         s.closed = true;
+        // 非 brief 路径的父 turn 收口 — subagent turns 一并关 (brief 路径在
+        // closeBriefTurn 关, 双关幂等)。
+        closeSubagentTurns(a);
         if (s.flushTimer) {
             clearTimeout(s.flushTimer);
             s.flushTimer = undefined;
@@ -1558,7 +1582,14 @@ export const startMirror = (deps) => {
         }
         return withSessionTag(a.target, content, seq);
     };
+    // 空正文一票否决 (近源拦截): 剥掉可能存在的路由头 (`🦊 #tag` / `[🧙](url)`)
+    // 后没有可见内容就不发。中央 chat-gate (last-response 的 SDK 包装) 是最后一道
+    // 防线; 这里拦在源头 —— 空内容不进 standalonePending FIFO、不占防抖 buf、
+    // 不重置计时器, 免得"空 part 入队 → flush 时 join 出空串"的死角。
+    const hasVisibleBody = (content) => parseTagHeader(content).body.length > 0;
     const sendStandalone = (a, content) => {
+        if (!hasVisibleBody(content))
+            return;
         const chatId = stripPrincipalPrefix(a.target);
         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));
@@ -1577,6 +1608,8 @@ export const startMirror = (deps) => {
     };
     // Like sendStandalone but skips withSessionTag — content already contains the tag header (e.g. as a link).
     const sendRaw = (a, content) => {
+        if (!hasVisibleBody(content))
+            return;
         const chatId = stripPrincipalPrefix(a.target);
         a.standalonePending = a.standalonePending
             .then(async () => {
@@ -1614,16 +1647,20 @@ export const startMirror = (deps) => {
     };
     // Debounce 聚合: 仅 standalone 路径用。窗口内 onItem 多次落入 → 合并成单条 markdown。
     // 0 关闭时退化为透传。flushStandalone 也用于 detach / teardown 时的 drain。
+    // parts 在 enqueue 时已过 hasVisibleBody, flush 端再过滤一遍是纵深防御 ——
+    // 防的是绕过 enqueue 直写 buf 的未来代码路径。
     const flushStandalone = (a) => {
         const buf = a.standaloneBuf;
         if (!buf)
             return;
-        const merged = buf.parts.join("\n\n");
         a.standaloneBuf = undefined;
+        const merged = buf.parts.filter((p) => hasVisibleBody(p)).join("\n\n");
         if (merged)
             sendStandalone(a, merged);
     };
     const enqueueStandalone = (a, content) => {
+        if (!hasVisibleBody(content))
+            return;
         const ms = cfg.wrc.mirror.standaloneDebounceMs;
         if (ms <= 0) {
             sendStandalone(a, content);
@@ -1818,7 +1855,7 @@ export const startMirror = (deps) => {
     // 每个 turn 挂一条气泡: ack 时就写进 `tag 详情链接 …` (finish=false, 不立刻关掉),
     // 让群里从收到消息那一刻起就有详情页入口。收口时:
     //   • 正文到位 → 以 `链接 正文` 覆盖这条气泡。
-    //   • 始终没正文 / 过 6min 窗口 → 以 ack 时那条纯 `链接` 收口。
+    //   • 始终没正文 / 过 6min 窗口 → 以最新 CoT 进度行 (没有则纯 `链接`) 收口。
     //   • 气泡已收口或无气泡 turn (CLI 侧发起) → 正文另发一条 standalone。
     // 其它所有 item 只写入 turn detail store。
     // 能证明"assistant 已经在产出"的 item —— 见到它们才补开无气泡 turn。
@@ -1857,6 +1894,7 @@ export const startMirror = (deps) => {
         // 收口后这一路全部失效: 气泡要么已 done, 要么 turn 已经换人/清空。
         if (!text || !b || b.done || !turnId || a.briefConcluded)
             return;
+        a.cotLastSent = text;
         try {
             await client.replyStream(b.frame, b.streamId, `${briefDetailLink(turnId, a.target)} \`${text}\``, false);
         }
@@ -1951,8 +1989,11 @@ export const startMirror = (deps) => {
         const bubble = { frame, streamId, hardTimer: undefined, done: false };
         const q = { turnId, bubble, isSlash };
         bubble.hardTimer = setTimeout(() => {
-            // WeCom ~6min stream 窗口快到, 必须 finish=true 收口。
-            void finishBubble(a, bubble, briefDetailLink(turnId, a.target), true);
+            // WeCom ~6min stream 窗口快到, 必须 finish=true 收口。没正文时不能拿光链接
+            // 覆盖 —— finish 是整条替换, 会把屏幕上的 CoT 进度行抹成光秃秃的链接; 改用
+            // 最新进度行定格 (a 上的 CoT 只在气泡仍是本轮活跃气泡时才可信, 换轮后归新轮)。
+            const cot = a.briefBubble === bubble && !a.briefConcluded ? a.cotText ?? a.cotLastSent : undefined;
+            void finishBubble(a, bubble, `${briefDetailLink(turnId, a.target)}${cot ? ` \`${cot}\`` : ""}`, true);
         }, HARD_TIMEOUT_MS);
         // 新消息 = 对话边界: 立刻收掉上一 turn, 新 turn 直接激活、不排队。收口语义见
         // closeBriefTurn: 有正文收入旧气泡, 没正文不写一个字 (绝不因边界结束凭空新发/
@@ -1992,7 +2033,9 @@ export const startMirror = (deps) => {
         a.briefConcluded = false;
         a.briefLastText = undefined;
         clearCot(a);
-        sendRaw(a, briefDetailLink(turnId, a.target));
+        // 链接暂存, 不再单独发 — 让首条 standalone body 取走拼到前缀, 一条消息解决。
+        // turn 始终会通过 concludeBriefTurn / closeBriefTurn 收口, header 不会泄漏。
+        a.pendingBriefHeader = briefDetailLink(turnId, a.target);
         log.info({ sessionId: a.sessionId, turnId }, "brief: turn started (CLI-side, no bubble)");
     };
     // 本轮出现过工具调用 / tool_result / 非 final 文本 —— 只记状态: 详情链接从 ack 起
@@ -2003,19 +2046,28 @@ export const startMirror = (deps) => {
         a.briefHadTool = true;
     };
     // 本轮结论落地, 只生效一次:
-    //   • 气泡仍开 (ack 时的 `链接 …` 还在) → 以 `链接 正文` 覆盖收口;
-    //   • 气泡已收 (过 6min 窗口 / 已收口) 或无气泡 turn (CLI 侧发起) → body 走 standalone,
-    //     那条 standalone 自带 `链接` 头 (withLinkedTag / ensureBriefTurn 已发过详情链接)。
+    //   • 气泡仍开 (ack 时的 `链接 …` 还在) → 以 `链接 正文` 覆盖收口; ensureBriefTurn
+    //     暂存的 header 跟着 bubble 收口一并丢 (气泡内已自带链接)。
+    //   • 气泡已收 (过 6min 窗口 / 已收口) 或无气泡 turn (CLI 侧发起) → 把暂存 header
+    //     拼到 body 前缀一并 standalone, 一条消息含详情入口 + 正文。
+    //   • body 为空 → 一个字不发, 顺手清掉 header, 不留"只有链接"的空消息。
     const concludeBriefTurn = (a, body) => {
         const turnId = a.briefTurnId;
-        if (!turnId || a.briefConcluded || !body.trim())
+        if (!turnId || a.briefConcluded)
+            return;
+        if (!body.trim()) {
+            a.pendingBriefHeader = undefined;
             return;
+        }
         a.briefConcluded = true;
         if (a.briefBubble && !a.briefBubble.done) {
             void finishBriefBubble(a, `${briefDetailLink(turnId, a.target)} ${body}`, true);
+            a.pendingBriefHeader = undefined;
         }
         else {
-            sendStandalone(a, body);
+            const header = a.pendingBriefHeader;
+            a.pendingBriefHeader = undefined;
+            sendStandalone(a, header ? `${header} ${body}` : body);
         }
         // 只保留当前 turn: 其余仍开着的 turn 记录是漏收的 close, 一并扫掉。
         recordCloseOpenTurns({ target: a.target, sessionId: a.sessionId, exceptIds: [turnId] });
@@ -2037,8 +2089,123 @@ export const startMirror = (deps) => {
         a.briefIsSlash = false;
         a.briefConcluded = false;
         a.briefLastText = undefined;
+        a.pendingBriefHeader = undefined;
+        closeSubagentTurns(a); // 父 turn 收口 = 它派出的 subagent 都已结束
         clearCot(a);
     };
+    // ── Subagent turns ─────────────────────────────────────────────────
+    // Task/Agent 工具派出的子 agent 在自己的转录文件里跑 (主 jsonl 只有派发与最终
+    // 总结)。subagent-tail 把过程流式吐到这里: 记成带 agent 标记的 turn (chat
+    // detail 时间轴内联展示), 并在 brief 气泡里以 `🤖 label · 最新活动` 驱动 CoT
+    // 进度行 —— 父 agent 阻塞在 Agent 调用上时, 子 agent 就是唯一的进度来源,
+    // last-writer-wins 让"最后的消息是 agent 调用"期间气泡展示的正是 agent 内状态。
+    // agent 类型归属: claude 的 meta.json 优先; codebuddy 没有 meta — 用父侧捕获的
+    // Task/Agent 入参按 prompt 原文对上 (子文件首行 user 内容 == input.prompt,
+    // codebuddy 实测逐字一致), 对不上再退到最近一次调用。
+    // 返回值同喂两条消费方: detail 记录的 agent.type/description 与 brief 进度行的
+    // label —— 二者必须同源, 否则"支持 codebuddy"时页面上叫 `🤖 subagent`、气泡里却
+    // 叫解析出的类型, 自相矛盾。undefined = 无从归属 (老文件无 meta 且父侧无调用)。
+    const resolveSubagentMeta = (a, task, meta) => {
+        if (meta.type || meta.description)
+            return { ...meta, label: meta.type ?? meta.description.slice(0, 24) };
+        const calls = a.agentCalls ?? [];
+        const hit = calls.find((c) => c.prompt && (c.prompt === task || task.startsWith(c.prompt) || c.prompt.startsWith(task)));
+        const m = hit ?? [...calls].reverse().find((c) => Date.now() - c.at < 10 * 60_000);
+        if (!m)
+            return undefined;
+        const { type, description } = m;
+        return { type, description, label: type ?? description?.slice(0, 24) ?? "subagent" };
+    };
+    const closeSubagentRun = (a, agentId) => {
+        const run = a.subagents?.get(agentId);
+        if (!run || run.closed)
+            return;
+        run.closed = true;
+        recordTurnClose(run.turnId);
+    };
+    // 关掉该 attachment 所有开着的 subagent turn。父 turn 收口 (closeBriefTurn /
+    // finalizeStream / detach / migrate) 时调用 — subagent 必然先于父 turn 结束,
+    // 父都收了, 子的开着只会让页面永远「运行中」。
+    const closeSubagentTurns = (a) => {
+        for (const id of a.subagents?.keys() ?? [])
+            closeSubagentRun(a, id);
+    };
+    const handleSubagentItem = (a, agentId, item) => {
+        if (!a.subagents)
+            a.subagents = new Map();
+        let run = a.subagents.get(agentId);
+        const now = Date.now();
+        // 首个 item 懒建 turn — task 行建在开头 (userQuery=任务原文), EOF 起步的存量
+        // agent 任何 item 都能建 (userQuery 缺省), 不丢过程。
+        if (!run && item.kind !== "end") {
+            const task = item.kind === "task" ? item.body : undefined;
+            const meta = item.kind === "task" ? item.meta : {};
+            const resolved = resolveSubagentMeta(a, task ?? "", meta);
+            const turnId = newTurnId();
+            run = { turnId, label: resolved?.label ?? "subagent", closed: false };
+            a.subagents.set(agentId, run);
+            recordTurnStart({
+                id: turnId,
+                target: a.target,
+                sessionId: a.sessionId,
+                cwd: a.runningCwd || undefined,
+                userQuery: task,
+                agent: { id: agentId, type: resolved?.type, description: resolved?.description },
+            });
+            log.info({ agentId, turnId, label: run.label }, "subagent: turn started");
+            if (item.kind === "task")
+                return;
+        }
+        if (!run || run.closed)
+            return;
+        switch (item.kind) {
+            case "task":
+                return; // 已在建 turn 时消费
+            case "text":
+                recordTurnItem(run.turnId, { t: "text", body: item.body, ts: now, final: item.final });
+                break;
+            case "tool_use":
+                for (const c of item.calls) {
+                    recordTurnItem(run.turnId, { t: "tool_use", toolUseId: c.toolUseId, toolName: c.name, toolInput: c.input, ts: now });
+                }
+                break;
+            case "tool_result":
+                recordTurnItem(run.turnId, { t: "tool_result", toolUseId: item.toolUseId, body: item.full, ts: now });
+                break;
+            case "usage":
+                recordTurnUsage(run.turnId, { model: item.model, messageId: item.messageId, usage: item.usage });
+                break;
+            case "end":
+                closeSubagentRun(a, agentId);
+                return;
+        }
+        // brief 气泡的实时进度: 静默窗 (keepalive 吞没 / 新 pane 未注入) 不推;
+        // updateBriefProgress 自身会检查气泡是否仍开。final text 之后的 end 会很快
+        // 收口气泡, 进度行不会残留。
+        if (a.muteUntilInject || a.keepaliveQuiet || a.keepaliveByContent)
+            return;
+        const activity = item.kind === "tool_use"
+            ? cotToolLabel(item.calls)
+            : item.kind === "thinking" || item.kind === "text"
+                ? item.body
+                : "";
+        if (activity)
+            updateBriefProgress(a, `🤖 ${run.label} · ${activity}`);
+    };
+    // (重新) 挂上 subagent watch — attach 与 migrateAttachment 共用; 会话轮换后
+    // sessionId 变了, 旧 watch 的目录定位随之作废, 必须重建。
+    const startSubagentsFor = (a) => {
+        a.subagentWatch?.stop();
+        closeSubagentTurns(a);
+        a.subagents = new Map();
+        a.subagentWatch = startSubagentWatch({
+            log: log.child({ sub: "subagents", sessionId: a.sessionId }),
+            sessionId: a.sessionId,
+            liveJsonlPath: () => a.tail.livePath(),
+            normalizeLine: backendForPath(a.jsonlPath).normalizeTranscriptLine,
+            onAgentItem: (agentId, item) => handleSubagentItem(a, agentId, item),
+        });
+    };
     // 强制收口一个 attachment 的全部出站通道, 并返回收掉的气泡/流条数。
     //
     // 关键约束: **一个 tmux 调用都不许有**。它的两个调用方 (`/stop` 和 inject
@@ -2057,6 +2224,7 @@ export const startMirror = (deps) => {
             clearTimeout(a.softEnd);
             a.softEnd = undefined;
         }
+        closeSubagentTurns(a); // brief/liveStream 都不在的收口路径也把 subagent 关掉
         if (a.outbound) {
             if (a.outbound.kind === "deferred")
                 clearTimeout(a.outbound.timer);
@@ -2169,9 +2337,14 @@ export const startMirror = (deps) => {
             // loading 气泡。非 slash 场景的 skill_output 是用户可见的中间反馈, 走 standalone。
             if (a.briefIsSlash && !a.briefHadTool && a.briefBubble && !a.briefBubble.done) {
                 void finishBriefBubble(a, item.body);
+                a.pendingBriefHeader = undefined;
             }
             else {
-                sendStandalone(a, item.body);
+                // CLI-driven turn: 把 ensureBriefTurn 暂存的详情链接拼到 body 前缀, 避免
+                // "只发了一条 link 渲染成空文本" 的前置消息。
+                const header = a.pendingBriefHeader;
+                a.pendingBriefHeader = undefined;
+                sendStandalone(a, header ? `${header} ${item.body}` : item.body);
             }
             return;
         }
@@ -2232,13 +2405,41 @@ export const startMirror = (deps) => {
         if (a.liveStream && !a.liveStream.closed)
             void finalizeStream(a, a.liveStream);
     };
-    // Close the keepalive quiet window — the ping turn is over (or the fail-safe
-    // fired), so subsequent real items flow through onItem normally again.
-    const endKeepaliveQuiet = (a) => {
-        if (!a.keepaliveQuiet)
-            return;
-        clearTimeout(a.keepaliveQuiet);
-        a.keepaliveQuiet = undefined;
+    // End the keepalive swallow — the ping turn is over (turn_end / genuine
+    // user line / inject failure), so real items flow through onItem again.
+    // Clears BOTH the timer window and the content flag.
+    const endKeepaliveSwallow = (a) => {
+        if (a.keepaliveQuiet) {
+            clearTimeout(a.keepaliveQuiet);
+            a.keepaliveQuiet = undefined;
+        }
+        if (a.keepaliveContentTimer) {
+            clearTimeout(a.keepaliveContentTimer);
+            a.keepaliveContentTimer = undefined;
+        }
+        a.keepaliveByContent = undefined;
+    };
+    // Content-based swallow entry: the tailed user line IS a configured ping.
+    // Belt to the inject-time timer window — this one keys on the user message
+    // itself, so it holds across daemon reloads, tail replays and replies
+    // slower than the 60s fail-safe. Reuses the detail turn the timer flow may
+    // have opened (fireKeepalive skips opening when this got there first).
+    const KEEPALIVE_CONTENT_FAILSAFE_MS = 5 * 60_000;
+    const beginKeepaliveByContent = (a, text) => {
+        a.keepaliveByContent = true;
+        if (a.keepaliveContentTimer)
+            clearTimeout(a.keepaliveContentTimer);
+        // Fail-safe: a ping turn whose reply never emits turn_end (crash/hang)
+        // must not mute a later real turn forever.
+        a.keepaliveContentTimer = setTimeout(() => {
+            a.keepaliveContentTimer = undefined;
+            a.keepaliveByContent = undefined;
+        }, KEEPALIVE_CONTENT_FAILSAFE_MS);
+        if (!a.keepaliveTurnId) {
+            const turnId = newTurnId();
+            a.keepaliveTurnId = turnId;
+            recordTurnStart({ id: turnId, target: a.target, sessionId: a.sessionId, userQuery: text });
+        }
     };
     // A keepalive ping turn is swallowed wholesale — the reply content doesn't
     // matter (model may add extra commentary beyond "pong", that's fine).
@@ -2246,12 +2447,24 @@ export const startMirror = (deps) => {
         // 新 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, 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) {
+        // Keepalive ping turns are cache-warmers: swallow every item from every
+        // WeCom path so the ping/pong never reaches chat. Two triggers, either
+        // suffices — the timer window opened at inject (keepaliveQuiet) OR the
+        // user line itself matching a configured ping (keepaliveByContent; the
+        // reload/replay/slow-reply-proof one). The REAL exchange is recorded
+        // into its chat-detail turn — the actual assistant reply, the tool calls
+        // if any, and the usage — so the detail page shows the genuine heartbeat.
+        if (item.kind === "keepalive_start") {
+            beginKeepaliveByContent(a, item.body);
+            return;
+        }
+        // A genuine user line (not our inject, not a ping) is a hard turn
+        // boundary — any keepalive swallow still holding never got its turn_end
+        // (crashed reply). Release BEFORE the swallow gate so this real line (and
+        // its reply) mirror normally instead of being eaten by the stale swallow.
+        if (item.kind === "user_text")
+            endKeepaliveSwallow(a);
+        if (a.keepaliveQuiet || a.keepaliveByContent) {
             const id = a.keepaliveTurnId;
             if (id) {
                 const now = Date.now();
@@ -2270,7 +2483,7 @@ export const startMirror = (deps) => {
                 }
             }
             if (item.kind === "turn_end") {
-                endKeepaliveQuiet(a);
+                endKeepaliveSwallow(a);
             }
             return;
         }
@@ -2310,6 +2523,17 @@ export const startMirror = (deps) => {
                         break;
                     a.recentToolSigs.delete(oldest);
                 }
+                // Task/Agent 派发入参留档 — subagent 文件本身不带类型信息 (codebuddy),
+                // subagentLabel 拿它按 prompt 匹配出 agent 类型。
+                if (c.name === "Task" || c.name === "Agent") {
+                    const inp = c.input;
+                    a.agentCalls = [...(a.agentCalls ?? []).slice(-8), {
+                            prompt: typeof inp?.prompt === "string" ? inp.prompt : "",
+                            type: typeof inp?.subagent_type === "string" && inp.subagent_type ? inp.subagent_type : undefined,
+                            description: typeof inp?.description === "string" && inp.description ? inp.description : undefined,
+                            at: Date.now(),
+                        }];
+                }
                 // codebuddy 的 ExitPlanMode 完全不过 PreToolUse hook (实测: 由
                 // interruption-service 本地对话框裁决, HookExecutor 零调用)。mirror 从
                 // jsonl 看到 function_call → 发计划审批卡; 点选后 send-keys 裁决本地
@@ -2542,6 +2766,9 @@ export const startMirror = (deps) => {
             clearTimeout(a.standaloneBuf.timer);
             flushStandalone(a);
         }
+        a.subagentWatch?.stop();
+        a.subagentWatch = undefined;
+        closeSubagentTurns(a);
         a.tail.stop();
         bySessionId.delete(a.sessionId);
         if (byTarget.get(a.target) === a)
@@ -2596,7 +2823,7 @@ export const startMirror = (deps) => {
             // collapsing to cfg.wrc.cwd (which would mislabel /pwd, /clear, /new).
             runningCwd: expandHome(((cwd ?? "").trim()) || readCwdFromJsonl(jsonlPath) || cfg.wrc.cwd),
             pendingCwd: carryPending,
-            tail: { stop: () => undefined, drain: () => undefined }, // placeholder; replaced below
+            tail: { stop: () => undefined, drain: () => undefined, livePath: () => undefined }, // placeholder; replaced below
             standalonePending: Promise.resolve(),
             recentToolSigs: new Map(),
         };
@@ -2610,6 +2837,7 @@ export const startMirror = (deps) => {
             toolUseInlineMaxChars: cfg.wrc.mirror.toolUseInlineMaxChars,
             isOwnInject,
             isOwnAssistantSend,
+            isKeepalivePing,
             onItem: (item) => onItem(a, item),
             detailUrlFor,
             sessionId,
@@ -2618,6 +2846,7 @@ export const startMirror = (deps) => {
             // what lets a claude session and a codebuddy session be mirrored at once.
             normalizeLine: backendForPath(jsonlPath).normalizeTranscriptLine,
         });
+        startSubagentsFor(a);
         bySessionId.set(sessionId, a);
         byTarget.set(target, a);
         // Preserve a persisted `/stop` pause across the re-attach: restore rebuilds the
@@ -2991,6 +3220,7 @@ export const startMirror = (deps) => {
             toolUseInlineMaxChars: cfg.wrc.mirror.toolUseInlineMaxChars,
             isOwnInject,
             isOwnAssistantSend,
+            isKeepalivePing,
             onItem: (item) => onItem(a, item),
             detailUrlFor,
             sessionId: newSessionId,
@@ -3000,6 +3230,8 @@ export const startMirror = (deps) => {
             // path, not by CLI) — re-derive the dialect from the destination.
             normalizeLine: backendForPath(newJsonlPath).normalizeTranscriptLine,
         });
+        // 会话轮换 = 新 <sid>/subagents/ 目录; 旧 run 的 turn 一并收口。
+        startSubagentsFor(a);
         deps.store.set(a.target, {
             sessionId: newSessionId,
             jsonlPath: newJsonlPath,
@@ -3289,33 +3521,13 @@ export const startMirror = (deps) => {
     // from the running cwd). Decoupling means /pwd can show truth even after
     // the AI sets a new path but the user hasn't /new'd yet.
     const expandedDefaultCwd = expandHome(cfg.wrc.cwd);
-    // Long absolute paths wrap in the WeCom bubble — show only the trailing
-    // three segments, which is enough to identify the project.
-    const shortCwd = (p) => p.split("/").filter(Boolean).slice(-3).join("/");
-    const renderProjectInfo = (target) => {
-        const a = byTarget.get(target);
-        const rec = a ? undefined : deps.store.get(target);
-        const running = (a?.runningCwd?.trim()) || rec?.cwd?.trim() || expandedDefaultCwd;
-        // pendingCwd is chat-scoped — the queued switch applies to every session
-        // in this chat, so read it from the shared base slot rather than the
-        // caller's own (now-empty) attachment record.
-        const pending = chatCwdFallback(target).pending;
-        const lines = [`📂 cwd: \`${shortCwd(running)}\``];
-        if (pending && pending !== running) {
-            lines.push(`下次切换: \`${shortCwd(pending)}\` (使用 /new 或 /clear 生效)`);
-        }
-        // Session-boundary footer — `/new` and `/clear` are the only two callers,
-        // so the tip lands exactly once per fresh context, never mid-conversation.
-        lines.push(randomTip());
-        return lines.join("\n");
-    };
     // `header` folds the caller's ack ("created") into this same bubble — /new
     // must land as exactly ONE WeCom message, not card + separate reply.
-    // slashAckFirstLine: 会话边界回执只保留首行 ack, 📂 项目信息与 💡 tip 省去。
+    // 会话边界回执一律不携带 cwd 信息 (📂 项目行 / 下次切换), 需要时 `/pwd` 可查。
+    // slashAckFirstLine 进一步省去 💡 tip, 只剩首行 ack。
     const pushProjectInfo = (target, header) => {
         const concise = cfg.wrc.mirror.slashAckFirstLine && !!header;
-        const info = concise ? "" : renderProjectInfo(target);
-        const md = header ? (info ? `${header}\n\n${info}` : header) : info;
+        const md = header ? (concise ? header : `${header}\n\n${randomTip()}`) : randomTip();
         const a = byTarget.get(target);
         if (a) {
             sendStandalone(a, md);
@@ -3332,7 +3544,7 @@ export const startMirror = (deps) => {
     // (default + any `#tag` siblings) share one cwd/pendingCwd, tracked on the
     // BASE principal's byTarget/store record. Tagged sessions still have their
     // own `runningCwd` (the tmux pane's actual working dir at spawn time), but
-    // cwd fallbacks and `cd` pendingCwd writes always resolve against the base.
+    // cwd fallbacks and `set_workspace` pendingCwd writes always resolve against the base.
     const chatCwdFallback = (target) => {
         const base = basePrincipalOf(target);
         const baseA = byTarget.get(base);
@@ -3351,7 +3563,7 @@ export const startMirror = (deps) => {
         //   base.pending > caller.pending > target.running > base.running > default
         // A fresh tagged session inherits the chat's current cwd; re-`/new`ing a
         // live tagged session keeps its pane cwd unless the base session queued a
-        // `cd`. This keeps siblings aligned by default without forcibly clobbering
+        // cwd switch. This keeps siblings aligned by default without forcibly clobbering
         // an already-spawned tagged pane on every base-cwd change.
         const chat = chatCwdFallback(target);
         const rec = !prev ? deps.store.get(target) : undefined;
@@ -3449,9 +3661,9 @@ export const startMirror = (deps) => {
         return { ok: true, sessionId: r.sessionId, cwd: r.cwd };
     };
     const getCwd = (target) => {
-        // pendingCwd is chat-scoped — a `cd` from any sibling session queues the
-        // switch for the whole chat. runningCwd stays per-session (each pane has
-        // its own spawn dir).
+        // pendingCwd is chat-scoped — a `set_workspace` from any sibling session
+        // queues the switch for the whole chat. runningCwd stays per-session (each
+        // pane has its own spawn dir).
         const chat = chatCwdFallback(target);
         const pending = chat.pending;
         const a = byTarget.get(target);
@@ -3463,9 +3675,9 @@ export const startMirror = (deps) => {
         return { runningCwd: chat.running || expandedDefaultCwd, pendingCwd: pending, defaultCwd: expandedDefaultCwd };
     };
     // Write `pendingCwd` to the BASE principal so the switch applies chat-wide —
-    // the next /new in any tagged/untagged session picks it up. `cd` from a
-    // tagged session still writes to the shared slot, not the tagged session's
-    // own record, matching "sessions share the chat's cwd".
+    // the next /new in any tagged/untagged session picks it up. `set_workspace`
+    // from a tagged session still writes to the shared slot, not the tagged
+    // session's own record, matching "sessions share the chat's cwd".
     const setPendingCwd = (target, cwd) => {
         const trimmed = (cwd ?? "").trim();
         if (!trimmed)
@@ -3627,6 +3839,34 @@ export const startMirror = (deps) => {
         const p = jsonlOf(target);
         return p ? lastAssistantText(p) : "";
     };
+    // ── 未收口气泡的引用判定 ────────────────────────────────────────────
+    // tag 会话的 last stream 未收口时, 群里最新那条气泡是瞬态的: 详情链接 URL +
+    // 最新一条实时 CoT/工具行 (brief) 或累积中的 acc (非 brief)。引用它要的是路由,
+    // 不是把这些中间态贴回 prompt —— 判定命中 ⇒ 调用方只保留 tag, 正文丢弃。
+    // URL 必须先于 canon 剥掉: canonForCompare 只剩字母数字, host/path 的字符会
+    // 永远卡住比对。两侧同剥, 才在同一层级上比。
+    const OPEN_QUOTE_URL_RE = /https?:\/\/\S+/g;
+    const quoteCanon = (s) => s.replace(OPEN_QUOTE_URL_RE, " ").replace(/[^\p{L}\p{N}]/gu, "");
+    const openBubbleBodies = (a) => {
+        if (a.briefBubble && !a.briefBubble.done && !a.briefConcluded) {
+            return [a.cotLastSent, a.cotText].filter((s) => !!s);
+        }
+        const s = a.liveStream;
+        return s && !s.closed && !s.dead ? [s.acc, s.lastSent] : [];
+    };
+    const isOpenBubbleQuote = (target, quoted) => {
+        const a = byTarget.get(target);
+        if (!a)
+            return false;
+        const bodies = openBubbleBodies(a);
+        if (bodies.length === 0)
+            return false;
+        const qc = quoteCanon(quoted);
+        // 剥掉 URL 后什么都不剩 ⇒ 引用的只是链接头 + "…" 这类纯 chrome, 直接命中。
+        if (!qc)
+            return true;
+        return bodies.some((b) => quoteCanon(b).includes(qc));
+    };
     // 一个 target 的完整画像。本 chat 的兄弟和外 chat 的 peer 走同一条,只有
     // `self` / `address` 因观察者而异 —— 地址本来就是相对调用方说的话。
     const peerInfoOf = async (t, self) => {
@@ -3756,7 +3996,7 @@ export const startMirror = (deps) => {
             sessionId: a.sessionId, jsonlPath: a.jsonlPath, tmuxTarget: a.tmuxPane,
         });
         if (!r.ok) {
-            endKeepaliveQuiet(a);
+            endKeepaliveSwallow(a);
             if (a.keepalive)
                 a.keepalive.pinging = false; // roll back so the next tick can retry
             log.warn({ target: a.target, reason: r.reason }, "keepalive: inject failed");
@@ -3769,9 +4009,13 @@ export const startMirror = (deps) => {
         // actual ping we injected; the assistant reply (expected: just "pong"), any
         // tool calls, and usage are grafted on from the swallowed items in onItem;
         // closed on the ping's turn_end (or the fail-safe). Kept out of chat.
-        const turnId = newTurnId();
-        a.keepaliveTurnId = turnId;
-        recordTurnStart({ id: turnId, target: a.target, sessionId: a.sessionId, userQuery: text });
+        // The tail's keepalive_start (content match on the user line) may have
+        // opened this turn already — only open when it hasn't.
+        if (!a.keepaliveTurnId) {
+            const turnId = newTurnId();
+            a.keepaliveTurnId = turnId;
+            recordTurnStart({ id: turnId, target: a.target, sessionId: a.sessionId, userQuery: text });
+        }
     };
     let keepaliveTicking = false;
     const keepaliveTick = async () => {
@@ -3865,8 +4109,10 @@ export const startMirror = (deps) => {
                 // Stall recovery, decided by RULE only (no model self-judgment): the last
                 // transcript turn is a synthetic API-error/limit line, or the idle pane
                 // still shows an error banner ⇒ a turn died mid-work. Send the resume
-                // instruction instead of the plain warmer.
-                const stalled = kc.resumeOnStall && (transcriptStalled(a.jsonlPath) || paneIsStalled(paneTail));
+                // instruction instead of the plain warmer. A limit-parked episode is
+                // excluded: retrying before resetsAt only buys another 429 line —
+                // limitResumeTick owns that recovery, anchored on the reset moment.
+                const stalled = kc.resumeOnStall && !a.limitResume && (transcriptStalled(a.jsonlPath) || paneIsStalled(paneTail));
                 k.pinging = true;
                 k.pingMtime = k.lastMs; // settles when a newer turn (the ping's own) appears
                 await fireKeepalive(a, stalled);
@@ -3880,6 +4126,83 @@ export const startMirror = (deps) => {
         }
     };
     const keepaliveTimer = setInterval(() => void keepaliveTick(), 15_000);
+    // ── Rate-limit auto-resume ────────────────────────────────────────────
+    // Detection is poll-derived from the transcript tail every tick (limitResetAt:
+    // "last message turn IS a 429 line"), so there is nothing to persist — a
+    // daemon reload, a human retry in the TTY, or our own inject all converge
+    // naturally: any newer turn makes detection stop firing and drops the state.
+    const fmtClock = (ms) => {
+        const d = new Date(ms);
+        return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
+    };
+    let limitResumeTicking = false;
+    const limitResumeTick = async () => {
+        const lr = cfg.wrc.mirror.limitResume;
+        if (!lr.enabled || limitResumeTicking)
+            return;
+        limitResumeTicking = true;
+        try {
+            const now = Date.now();
+            for (const a of byTarget.values()) {
+                const resetsAt = limitResetAt(a.jsonlPath, now);
+                if (!resetsAt) {
+                    a.limitResume = undefined;
+                    continue;
+                }
+                if (a.migrationWatcher)
+                    continue; // session rotating — judge after it settles
+                if (a.keepaliveOff)
+                    continue; // /stop = deliberately quieted; honor it
+                if (a.limitResume?.resetsAt !== resetsAt)
+                    a.limitResume = { resetsAt, notified: false, retried: false };
+                const st = a.limitResume;
+                const dueAt = resetsAt + lr.delaySec * 1000;
+                if (!st.notified) {
+                    st.notified = true;
+                    log.info({ target: a.target, resetsAt, dueAt }, "limit-resume: parked, retry scheduled");
+                    sendStandalone(a, `[mirror] ⏳ 已触限额 (reset ${fmtClock(resetsAt)}) — ${fmtClock(dueAt)} 自动注入 \`${lr.text}\` 续跑`);
+                }
+                if (st.retried || now < dueAt)
+                    continue;
+                if (a.liveStream && !a.liveStream.closed)
+                    continue; // mid typewriter — don't inject
+                if (a.tmuxPane) {
+                    // Pane mode: a dead pane means the human closed shop — auto-respawning
+                    // a TUI at 3am would be a surprise, not a service. Busy means someone
+                    // (human, or another turn) is already driving; detection clears itself
+                    // once their turn lands. Spawn-mode has no pane and no such hazards —
+                    // inject's `claude --resume -p` fallback IS its normal operation.
+                    if (!(await tmuxPaneAlive(a.tmuxPane)))
+                        continue;
+                    if (paneIsBusy(await capturePaneTail(a.tmuxPane, 16)))
+                        continue;
+                }
+                st.retried = true;
+                // Unlike keepalive there is no swallow: the resumed work is real work —
+                // the tail mirrors its output to chat normally. rememberInject only
+                // suppresses the echo of the injected user line itself.
+                rememberInject(lr.text);
+                const r = await inject({
+                    text: lr.text, images: [], cfg,
+                    log: log.child({ target: a.target, sessionId: a.sessionId, sub: "limit-resume" }),
+                    sessionId: a.sessionId, jsonlPath: a.jsonlPath, tmuxTarget: a.tmuxPane,
+                });
+                if (!r.ok) {
+                    st.retried = false; // roll back so the next tick retries the inject
+                    log.warn({ target: a.target, reason: r.reason }, "limit-resume: inject failed");
+                    continue;
+                }
+                log.info({ target: a.target, resetsAt }, "limit-resume: resume injected");
+            }
+        }
+        catch (e) {
+            log.warn({ err: e.message }, "limit-resume tick failed");
+        }
+        finally {
+            limitResumeTicking = false;
+        }
+    };
+    const limitResumeTimer = setInterval(() => void limitResumeTick(), 30_000);
     return {
         attach,
         chatTargets,
@@ -3891,6 +4214,7 @@ export const startMirror = (deps) => {
         peekTurns,
         isBusy,
         lastText,
+        isOpenBubbleQuote,
         status: () => {
             const list = Array.from(bySessionId.values()).map((a) => ({
                 sessionId: a.sessionId,
@@ -3917,7 +4241,7 @@ export const startMirror = (deps) => {
         },
         targetForSession: (sessionId) => {
             // Live attach is the fast path. Fall back to scanning persisted store:
-            // an MCP tool (e.g. `cd`) called from a claude that isn't mirror-attached
+            // an MCP tool (e.g. `set_workspace`) called from a claude that isn't mirror-attached
             // would otherwise miss here and silently retarget to defaultChat — that
             // bug stranded pendingCwd on the wrong principal. Store keeps each
             // target's sessionId in sync via migrate/attach/setPendingCwd writes.
@@ -4269,6 +4593,7 @@ export const startMirror = (deps) => {
         shutdown: () => {
             clearInterval(paneDriftTimer);
             clearInterval(keepaliveTimer);
+            clearInterval(limitResumeTimer);
             for (const a of bySessionId.values()) {
                 if (a.outbound?.kind === "deferred")
                     clearTimeout(a.outbound.timer);
@@ -4572,10 +4897,10 @@ export const startMirror = (deps) => {
                 // and surface a standalone "cleared" so the user gets explicit
                 // feedback (the skip-stream path otherwise leaves WeCom silent).
                 if (armMigration) {
-                    // slashAckFirstLine: 只回首行 ack, 项目信息/tip 省去 (与 /new 一致)。
+                    // cwd 不随回执下发 (/pwd 可查); slashAckFirstLine 连 tip 也省去 (与 /new 一致)。
                     sendStandalone(a, cfg.wrc.mirror.slashAckFirstLine
                         ? "cleared"
-                        : `cleared\n\n${renderProjectInfo(a.target)}`);
+                        : `cleared\n\n${randomTip()}`);
                     a.clearRebind = { baseline: preClearBaseline };
                     startMigrationWatcher(a, preClearBaseline, jsonlIsPostClearChild, 0, true);
                 }