wezard 0.3.3

package/dist/daemon/mirror-bridge.js

@@ -0,0 +1,3512 @@
+// Mirror-mode bridge.
+//
+// Strategy: a running interactive `claude` exposes no local IPC. Its only
+// shared surface is the append-only transcript at
+//   ~/.claude/projects/<encoded(cwd)>/<session-id>.jsonl
+// So:
+//   • Inbound (WeCom → claude): spawn `claude --resume <sid> -p <text>` —
+//     writes a new user/assistant turn into the SAME jsonl. Serialized per
+//     session to avoid concurrent writers stomping each other.
+//   • Outbound (claude → WeCom): tail that jsonl from the current EOF; every
+//     new `assistant` line gets pushed to a configured WeCom chat.
+//
+// Caveat: the user shouldn't be hammering the same session in their local TTY
+// while a `--resume` injection is in flight; Claude Code locks aren't strict.
+import { spawn } from "node:child_process";
+import { existsSync, readdirSync, statSync, watch, openSync, readSync, closeSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { expandHome, sanitizeId } from "../shared/paths.js";
+import { activeBackends, backendForPath, projectDirFor, projectDirsFor, } from "../shared/cli-backends.js";
+import { 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 { splitMarkdown } from "../shared/md-chunk.js";
+import { randomTip } from "./tips.js";
+import { stripAnsi, compactPane, paneIsBusy, summarizeTail, lastAssistantText } 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);
+const augmentedPath = (orig) => {
+    const extras = [
+        NODE_BIN_DIR,
+        "/opt/homebrew/bin",
+        "/usr/local/bin",
+        `${process.env.HOME ?? ""}/.local/bin`,
+    ].filter(Boolean);
+    const seen = new Set();
+    return [orig ?? "", ...extras]
+        .flatMap((p) => p.split(":"))
+        .filter((p) => {
+        if (!p || seen.has(p))
+            return false;
+        seen.add(p);
+        return true;
+    })
+        .join(":");
+};
+// Backend resolution is per-transcript, not global: `backendForPath` recovers
+// which CLI wrote a jsonl from its projects root, so claude / claude-internal /
+// codebuddy sessions can be mirrored side by side. `projectDirFor` re-encodes a
+// cwd under that same backend's dialect (Claude: leading `-`, CodeBuddy: none)
+// so pane-drift comparisons stay apples-to-apples.
+// Pull the bound session's actual project cwd from its transcript head. Each
+// jsonl line carries a `cwd` field; the encoded directory name is lossy (both
+// `/` and `.` collapse to `-`) so it can't be reversed — reading the file is
+// the only faithful path. Used as the middle tier in attach()'s cwd resolution
+// so /wrc-attached sessions reflect their real project in /pwd, /clear, /new,
+// instead of falling back to the global cfg.wrc.cwd.
+const readCwdFromJsonl = (path) => {
+    try {
+        if (!existsSync(path))
+            return "";
+        const size = statSync(path).size;
+        if (size === 0)
+            return "";
+        const fd = openSync(path, "r");
+        const cap = Math.min(size, 64 * 1024);
+        const buf = Buffer.alloc(cap);
+        readSync(fd, buf, 0, cap, 0);
+        closeSync(fd);
+        for (const line of buf.toString("utf8").split("\n")) {
+            if (!line.trim())
+                continue;
+            try {
+                const j = JSON.parse(line);
+                if (typeof j.cwd === "string" && j.cwd.trim())
+                    return j.cwd.trim();
+            }
+            catch { /* partial / non-JSON line — skip */ }
+        }
+    }
+    catch { /* unreadable — fall through */ }
+    return "";
+};
+// Every *.jsonl under `cwd`'s project dir, ranked newest-mtime first. A cwd can
+// hold transcripts from more than one CLI (same project opened in claude and in
+// codebuddy), so the default is the union across all active backends — that is
+// what lets a fresh session be discovered regardless of which binary wrote it.
+//
+// `only` narrows to a single backend. Every path that RE-BINDS an existing
+// attachment must pass it: healing a claude chat onto the codebuddy transcript
+// that merely happens to be newer in the same directory would hand the chat to
+// a session it can neither resume (`claude --resume` wouldn't find the sid) nor
+// parse (wrong jsonl dialect). Only genuine discovery searches the union.
+const rankedJsonlsForCwd = (cwd, only) => projectDirsFor(expandHome(cwd))
+    .filter(({ backend }) => !only || backend.name === only.name)
+    .flatMap(({ dir }) => {
+    let names;
+    try {
+        names = readdirSync(dir).filter((n) => n.endsWith(".jsonl"));
+    }
+    catch {
+        return [];
+    }
+    return names.flatMap((n) => {
+        const p = join(dir, n);
+        try {
+            return [{ sessionId: n.replace(/\.jsonl$/, ""), jsonlPath: p, mtime: statSync(p).mtimeMs }];
+        }
+        catch {
+            return [];
+        }
+    });
+})
+    .sort((a, b) => b.mtime - a.mtime);
+// Newest-mtime *.jsonl in the project dir(s) for `cwd`. A `/clear` (or a native
+// `/new`) rotation always leaves a fresh jsonl here, so this is how the mirror
+// re-finds the live session after a rotation it didn't itself record — used by
+// resolveSession's auto-pick and by restoreFromStore's heal path.
+const latestJsonlForCwd = (cwd, only) => {
+    const top = rankedJsonlsForCwd(cwd, only)[0];
+    return top ? { sessionId: top.sessionId, jsonlPath: top.jsonlPath } : undefined;
+};
+// Locate a transcript by sessionId across every sibling project dir of every
+// active backend. Claude Code's EnterWorktree/ExitWorktree relocate the SAME-sid
+// jsonl between <cwd> and <cwd>/.claude/worktrees/<name> — each cwd encodes to
+// its own project dir, so the path moves but the sid doesn't. It's a rename
+// (byte prefix preserved), so a tail can follow it with a continuous offset.
+// Newest-mtime wins if a stale sibling lingers.
+const findJsonlBySid = (sid, only) => {
+    const sidFile = `${sid}.jsonl`;
+    return (only ? [only] : activeBackends())
+        .flatMap((b) => {
+        const root = expandHome(b.projectsDir);
+        try {
+            return readdirSync(root).map((d) => join(root, d, sidFile));
+        }
+        catch {
+            return [];
+        }
+    })
+        .flatMap((p) => { try {
+        return [{ p, m: statSync(p).mtimeMs }];
+    }
+    catch {
+        return [];
+    } })
+        .sort((a, b) => b.m - a.m)[0]?.p;
+};
+// Backend-agnostic line adapter for the raw-jsonl predicates below. They were
+// written against Claude's schema (type:"user", isMeta, string content) —
+// codebuddy persists message/function_call records instead, so route every
+// parsed line through the owning backend's adapter first (identity for claude).
+const normalizeForPath = (path, raw) => backendForPath(path).normalizeTranscriptLine(raw);
+// Local-command noise on user lines: Claude marks the caveat / command-stdout
+// records isMeta; codebuddy persists them as PLAIN user messages (no isMeta
+// field at all). Predicates looking for the first REAL user line must skip
+// both forms explicitly.
+const isLocalCommandNoise = (content) => typeof content === "string" &&
+    (content.includes('data-role="command-caveat"') || content.includes("<local-command-stdout>"));
+// True if `path` holds at least one real (non-meta, non-sidechain) user line —
+// i.e. it's a live session, not an empty just-touched jsonl. Bounded head read.
+const jsonlHasUserLine = (path) => {
+    try {
+        const size = statSync(path).size;
+        const cap = Math.min(size, 256 * 1024);
+        const fd = openSync(path, "r");
+        const buf = Buffer.alloc(cap);
+        readSync(fd, buf, 0, cap, 0);
+        closeSync(fd);
+        for (const line of buf.toString("utf8").split("\n")) {
+            if (!line.trim())
+                continue;
+            try {
+                const j = normalizeForPath(path, JSON.parse(line));
+                if (j?.type === "user" && !j.isMeta && !j.isSidechain)
+                    return true;
+            }
+            catch { /* partial line */ }
+        }
+    }
+    catch { /* unreadable */ }
+    return false;
+};
+// Search a jsonl's tail for a just-injected message fingerprint; return the
+// byte offset of the START of the line containing it, or undefined. Used to
+// rebind onto a same-dir fork that swallowed our inject (see armSilentForkRebind)
+// — matching the exact text is what makes cross-session rebind safe when many
+// sessions share one project dir. Bounded tail read (the inject is near EOF).
+const findInjectOffset = (path, fp) => {
+    try {
+        const size = statSync(path).size;
+        const readLen = Math.min(size, 256 * 1024);
+        const start = size - readLen;
+        const fd = openSync(path, "r");
+        const buf = Buffer.alloc(readLen);
+        try {
+            readSync(fd, buf, 0, readLen, start);
+        }
+        finally {
+            closeSync(fd);
+        }
+        const chunk = buf.toString("utf8");
+        const idx = chunk.lastIndexOf(fp);
+        if (idx === -1)
+            return undefined;
+        const lineStart = chunk.lastIndexOf("\n", idx) + 1; // -1 → 0 (chunk head)
+        return start + Buffer.byteLength(chunk.slice(0, lineStart), "utf8");
+    }
+    catch {
+        return undefined;
+    }
+};
+// Newest-mtime *.jsonl WITH user content in cwd's project dir(s), across all
+// active backends. The content gate skips an empty just-touched file so we bind
+// the real session. Reliable for worktree dirs (one session lives there);
+// restore + the drift follower only consult it on cross-dir moves, where that
+// assumption holds.
+const liveSessionForCwd = (cwd, only) => {
+    for (const c of rankedJsonlsForCwd(cwd, only)) {
+        if (jsonlHasUserLine(c.jsonlPath))
+            return { sessionId: c.sessionId, jsonlPath: c.jsonlPath };
+    }
+    return undefined;
+};
+const resolveSession = (cfg, log) => {
+    const cwd = expandHome(cfg.wrc.cwd);
+    const dirs = projectDirsFor(cwd).map(({ dir }) => dir).filter((d) => existsSync(d));
+    if (dirs.length === 0) {
+        log.error({ probed: projectDirsFor(cwd).map(({ dir }) => dir) }, "mirror: project dir not found (no CLI session ever ran in cwd?)");
+        return undefined;
+    }
+    const pinned = cfg.wrc.mirror.sessionId.trim();
+    if (pinned) {
+        const p = dirs.map((d) => join(d, `${pinned}.jsonl`)).find((x) => existsSync(x));
+        if (!p) {
+            log.error({ pinned, dirs }, "mirror: pinned sessionId jsonl missing");
+            return undefined;
+        }
+        return { sessionId: pinned, jsonlPath: p };
+    }
+    const top = latestJsonlForCwd(cwd);
+    if (!top) {
+        log.error({ dirs }, "mirror: no .jsonl in project dir");
+        return undefined;
+    }
+    return top;
+};
+// Target keys are `user:xxx[#tag]` / `chat:xxx[#tag]`. Strip the principal
+// prefix AND the `#tag` suffix so WeCom's sendMessage receives just the bare
+// chatid/userid. Tag survives only inside the daemon's byTarget/store keys.
+const stripPrincipalPrefix = (s) => {
+    const i = s.indexOf(":");
+    const rest = i >= 0 ? s.slice(i + 1) : s;
+    const h = rest.indexOf("#");
+    return h >= 0 ? rest.slice(0, h) : rest;
+};
+// Extract the `#tag` suffix from a target key, "" if untagged.
+const tagOfTarget = tagOfKey;
+// Drop the `#tag` suffix — collapses tagged session keys to the chat-scoped
+// base principal. Shared with the peer/graph layer via session-label.
+const basePrincipalOf = baseOfKey;
+// Prefix outbound content with `<emoji> #tag` header (blank line separator)
+// when the target carries a `#tag` suffix. Untagged targets pass through
+// unchanged — default session keeps its plain-bubble UX.
+const withSessionTag = withTagHeader;
+// Claude Code wraps slash-command invocations into the user message as
+//   <command-message>name</command-message>
+//   <command-name>/name</command-name>
+//   <command-args>...</command-args>
+// plus assorted <local-command-stdout>, <local-command-caveat>,
+// <system-reminder> blocks. Rendering those raw to WeCom is pure noise.
+//
+// Strategy: extract /cmd + args into a single styled line; strip the rest.
+// Returns "" when the message is purely meta — caller filters.
+// Opening tag tolerates attributes: codebuddy emits e.g.
+// `<system-reminder data-role="command-caveat">` (verified 100+ on disk) —
+// a bare `<tag>` match lets the whole caveat leak into the WeCom bubble.
+const SLASH_TAG_RE = /<command-name>([\s\S]*?)<\/command-name>/;
+const SLASH_ARGS_RE = /<command-args>([\s\S]*?)<\/command-args>/;
+const META_TAG_RE = /<(command-message|command-name|command-args|local-command-stdout|local-command-caveat|system-reminder|task-notification)(\s[^>]*)?>[\s\S]*?<\/\1>/g;
+const TASK_NOTIF_RE = /<task-notification>([\s\S]*?)<\/task-notification>/;
+// Claude Code's `/goal` installs a session-scoped Stop hook and injects this
+// marker (type:"user", plain string content) telling the model to self-drive
+// toward the condition. Crucially the model then NEVER emits a terminal
+// stop_reason — every assistant line stays stop_reason:"tool_use" until the goal
+// auto-clears — so `turn_end` (and thus brief-mode's closeBriefTurn / any
+// per-turn flush) never fires, and the entire run goes silent on WeCom. Detect
+// the marker on a stable English substring so the mirror can enter a
+// progress-streaming mode for the goal's duration.
+const GOAL_START_RE = /session-scoped Stop hook is now active with condition:\s*"?([^"\n]*)"?/;
+// Pure: goal marker → goal_start item. The marker line ships as `type:"user",
+// isMeta:true, content:string` (verified against real /goal transcripts), so
+// detection MUST run before renderLine's isMeta gate — behind it the signal is
+// dropped and the whole goal adaptation never engages.
+const goalStartOf = (c) => {
+    if (typeof c !== "string")
+        return undefined;
+    const m = c.match(GOAL_START_RE);
+    return m ? { kind: "goal_start", condition: (m[1] ?? "").trim() } : undefined;
+};
+// Background task completion notification (Claude Code emits these into the
+// user channel when a backgrounded Bash/Agent task finishes). Render the
+// summary + status as a single styled line; drop the noisy tool-use-id /
+// output-file fields.
+const renderTaskNotification = (block) => {
+    const summary = block.match(/<summary>([\s\S]*?)<\/summary>/)?.[1]?.trim() ?? "";
+    const status = block.match(/<status>([\s\S]*?)<\/status>/)?.[1]?.trim() ?? "";
+    const icon = status === "completed" ? "✅" : status === "failed" || status === "error" ? "❌" : "🏁";
+    return `${icon} ${summary || `后台任务 ${status || "完成"}`}`;
+};
+const cleanUserText = (raw) => {
+    const nameMatch = raw.match(SLASH_TAG_RE);
+    const slashCmd = nameMatch?.[1]?.trim() ?? "";
+    const argsMatch = raw.match(SLASH_ARGS_RE);
+    const slashArgs = argsMatch?.[1]?.trim() ?? "";
+    const stripped = raw.replace(META_TAG_RE, "").trim();
+    if (slashCmd) {
+        const head = `\`${slashCmd}${slashArgs ? ` ${slashArgs}` : ""}\``;
+        return stripped ? `${head}\n${stripped}` : head;
+    }
+    return stripped;
+};
+const truncate = (s, max) => s.length <= max ? s : `${s.slice(0, max)}…(+${s.length - max})`;
+const renderToolInput = (input) => {
+    try {
+        const json = JSON.stringify(input ?? {}, null, 0);
+        return truncate(json, 600);
+    }
+    catch {
+        return "{}";
+    }
+};
+const extractToolResultText = (block) => {
+    const c = block.content;
+    if (typeof c === "string")
+        return c;
+    if (!Array.isArray(c))
+        return "";
+    return c
+        .map((b) => (typeof b?.text === "string" ? b.text : b?.tool_name ? `→ ${b.tool_name}` : ""))
+        .filter(Boolean)
+        .join("\n");
+};
+// detail 页用的存储上限 — 远大于聊天气泡的 toolResultMaxChars(默认 400),
+// 确保点开"详情"能看到工具调用的完整 result, 不再受气泡截断的影响。
+const DETAIL_RESULT_MAX = 64 * 1024;
+const oneLineSummary = (s, max = 40) => {
+    const flat = s.replace(/\s+/g, " ").trim();
+    return truncate(flat, max);
+};
+// 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
+// backtick, eating subsequent items. A literal backtick inside `compact` also
+// closes the surrounding inline-code prematurely; `[`/`]` break the
+// enclosing `[text](url)` link by re-anchoring the text span.
+// Replace with full-width / similar glyphs: visually close, harmless to the
+// renderer. Applied to the user-controlled part only — surrounding markdown
+// structure (the wrapping ``…``, `[…](…)` and `> ↩ ` prefix) stays literal.
+const safeForMarkdown = (s) => s
+    .replace(/`/g, "ʼ")
+    .replace(/</g, "＜")
+    .replace(/>/g, "＞")
+    .replace(/\[/g, "［")
+    .replace(/\]/g, "］")
+    // \( \) is LaTeX inline-math in WeCom desktop renderer → contents render
+    // italic and the link span breaks. Keep the backslash for fidelity, swap
+    // to full-width parens so the math tokenizer no longer recognizes it.
+    // (\[ \] is already neutralized above by the [/] replacement.)
+    .replace(/\\\(/g, "\\（")
+    .replace(/\\\)/g, "\\）");
+const renderToolInputCompact = (input, max) => {
+    // Heuristic: prefer command/file_path/pattern-like keys for the inline summary.
+    if (input && typeof input === "object") {
+        const o = input;
+        const pick = o.command ?? o.file_path ?? o.path ?? o.pattern ?? o.url ?? o.query ?? o.prompt;
+        if (typeof pick === "string")
+            return oneLineSummary(pick, max);
+    }
+    return oneLineSummary(renderToolInput(input), max);
+};
+// 渲染一组同名 tool_use:
+//   • 单次  → `🔧 [Name compact](url)`            (与原行为一致)
+//   • 多次  → 聚合为一个 markdown 块:
+//       🔧 Name × N
+//       [• compact1](url1)
+//       [• compact2](url2)
+// 多次的每条仍是独立 link, 各自指向自己的 detail URL。
+const renderToolUseGroupBody = (calls, deps) => {
+    const renderOne = (c) => ({
+        compact: safeForMarkdown(renderToolInputCompact(c.input, deps.toolUseInlineMaxChars)),
+        url: deps.detailUrlFor(c.toolUseId),
+    });
+    if (calls.length === 1) {
+        const c = calls[0];
+        const { compact, url } = renderOne(c);
+        return url ? `🔧 [${c.name} ${compact}](${url})` : `🔧 ${c.name} ${compact}`;
+    }
+    const header = `🔧 ${calls[0].name} × ${calls.length}`;
+    const lines = calls.map((c) => {
+        const { compact, url } = renderOne(c);
+        return url ? `[• ${compact}](${url})` : `• ${compact}`;
+    });
+    return [header, ...lines].join("\n");
+};
+// Render one transcript line into tagged items. Caller decides batching.
+const renderLine = (raw, deps) => {
+    let line;
+    try {
+        line = JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+    // Phase 3: normalize backend-specific jsonl (codebuddy splits tool_use /
+    // tool_result into independent top-level records; Claude is identity). Done
+    // AFTER JSON.parse so the adapter works on structured data, BEFORE the
+    // isMeta/isSidechain gates so backend-mapped fields flow through.
+    if (deps.normalizeLine) {
+        const normalized = deps.normalizeLine(line);
+        if (!normalized)
+            return [];
+        line = normalized;
+    }
+    if (line.isSidechain)
+        return [];
+    if (line.isMeta) {
+        // isMeta 行整体丢弃, 唯一例外是 /goal 的激活 marker (isMeta:true 的 user
+        // 行) — 它是 goal 模式的进入信号, 吞掉它 = 整个 goal run 在 WeCom 静默。
+        const goal = line.type === "user" ? goalStartOf(line.message?.content) : undefined;
+        return goal ? [goal] : [];
+    }
+    const out = [];
+    if (line.type === "user") {
+        const c = line.message?.content;
+        if (typeof c === "string") {
+            // Skill/system feedback (e.g. `/model`'s "Set model to …", background
+            // task completions) is emitted REGARDLESS of includeUser — it's system
+            // output, not the user's own chatter, so the includeUser=false default
+            // (which suppresses echoing user lines) must not swallow it.
+            // Match against raw content BEFORE cleanUserText strips the tag.
+            const stdoutMatch = c.match(/<local-command-stdout>([\s\S]*?)<\/local-command-stdout>/);
+            if (stdoutMatch && stdoutMatch[1]) {
+                const skillOutput = stdoutMatch[1].replace(/\[[0-9;]*m/g, "").trim();
+                if (skillOutput) {
+                    out.push({ kind: "skill_output", body: `⚙️ ${skillOutput}` });
+                }
+                return out;
+            }
+            // Background task completion — strip the raw tag soup and render
+            // a single styled line.
+            const taskMatch = c.match(TASK_NOTIF_RE);
+            if (taskMatch && taskMatch[1]) {
+                out.push({ kind: "skill_output", body: renderTaskNotification(taskMatch[1]) });
+                return out;
+            }
+            // /goal activation — non-isMeta 形态兜底 (marker 格式漂移防御), emit
+            // REGARDLESS of includeUser; isMeta 形态已在上方 isMeta 门截获。
+            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
+            if (deps.isOwnInject(text))
+                return []; // dedupe WeCom→CLI echo
+            const quoted = text.split("\n").map((l) => `> ${l}`).join("\n");
+            out.push({ kind: "user_text", body: quoted });
+        }
+        else if (Array.isArray(c)) {
+            for (const b of c) {
+                if (b?.type !== "tool_result")
+                    continue;
+                const raw = extractToolResultText(b);
+                if (!raw)
+                    continue;
+                const toolUseId = b.tool_use_id ?? "";
+                const full = truncate(raw, DETAIL_RESULT_MAX);
+                // 始终把完整 result 落 detail 库 + 作为 tool_result item 发出 — 与
+                // includeToolResults(气泡推送开关)彻底解耦: 关掉气泡时 detail 页与 brief
+                // turn 页(handleBriefItem 消费本 item 写 turn store)都仍要看到 result。
+                // 气泡推送的 gate 挪到非-brief 消费端 (onItem), 见下方 includeToolResults 判断。
+                if (toolUseId)
+                    recordToolResult(toolUseId, full);
+                const compact = safeForMarkdown(oneLineSummary(full, 40));
+                const url = deps.detailUrlFor(toolUseId);
+                out.push({
+                    kind: "tool_result",
+                    toolUseId,
+                    full,
+                    body: url ? `[↩ ${compact}](${url})` : `↩ ${compact}`,
+                });
+            }
+        }
+        return out;
+    }
+    if (line.type === "assistant") {
+        const blocks = line.message?.content;
+        if (!Array.isArray(blocks))
+            return [];
+        // Mark text items emitted from a terminal-stop_reason line as `final`.
+        // Per Anthropic protocol, an `end_turn` line contains only text blocks
+        // (tool_use → stop_reason="tool_use"),
+        // so these texts ARE the agent's final answer for the turn. Downstream uses
+        // `final` to decide bubble splits — mid-turn text appends; only final text
+        // after tools peels out into its own standalone (preview = real answer).
+        // 只认 end_turn。另两个终态在 CC 落盘语义里都不是"这一轮说完了":
+        //   • stop_sequence —— 实测 152 次里 ~150 次是 CC 合成的错误/限额行
+        //     ("API Error: …" / "You've hit your session limit" / "No response
+        //     requested."), 其中可重试的那种 (stalled mid-stream / ECONNRESET) CC 会
+        //     自动续跑同一轮, 在它上面收口 = turn 中途断掉。真正终止的那些后面必跟
+        //     system/turn_duration, 由下方权威信号兜住, 不会漏收。
+        //   • max_tokens —— 语义是"消息被截断", CC 继续同一轮; 全量 transcript 0 命中。
+        const sr = line.message?.stop_reason;
+        const isFinal = sr === "end_turn";
+        // final 是三态: true=终句, false=已知的中途输出, undefined=后端说不清 (软收口)。
+        // 软后端不能填 false —— 那会让每句叙述都触发 earlyLinkBubble, 把 loading 气泡
+        // 提前收成详情链接, 一句话答完的 turn 也要拆成两条消息。
+        const textFinal = isFinal ? true : line.softTurnEnd ? undefined : false;
+        let pending = [];
+        const flushPending = () => {
+            if (pending.length === 0)
+                return;
+            const calls = pending;
+            pending = [];
+            // 每个 tool_use 都要单独 recordTool, 这样点击-查看-详情可以按 id 命中。
+            for (const c of calls) {
+                if (c.toolUseId) {
+                    recordTool({
+                        id: c.toolUseId,
+                        toolName: c.name,
+                        toolInput: c.input,
+                        sessionId: deps.sessionId,
+                        target: deps.target,
+                    });
+                }
+            }
+            out.push({
+                kind: "tool_use",
+                calls,
+                body: renderToolUseGroupBody(calls, deps),
+            });
+        };
+        for (const b of blocks) {
+            if (b?.type === "text" && typeof b.text === "string") {
+                flushPending();
+                const t = b.text.trim();
+                if (t && !deps.isOwnAssistantSend?.(t))
+                    out.push({ kind: "text", body: t, final: textFinal });
+            }
+            else if (b?.type === "tool_use" && deps.includeTools) {
+                const name = b.name ?? "tool";
+                const toolUseId = b.id ?? "";
+                // 同名扩展当前 group; 不同名先 flush 再起新组。
+                if (pending.length > 0 && pending[0].name !== name)
+                    flushPending();
+                pending.push({ toolUseId, name, input: b.input });
+            }
+            // thinking blocks intentionally skipped
+        }
+        flushPending();
+        // Emit per-line usage snapshot BEFORE turn_end so brief store gets the last
+        // increment before the turn closes. Non-brief onItem drops it silently.
+        const u = line.message?.usage;
+        if (u) {
+            const model = typeof line.message?.model === "string" ? line.message.model : undefined;
+            const messageId = typeof line.message?.id === "string" ? line.message.id : undefined;
+            const rawIn = u.input_tokens ?? 0;
+            const cr = u.cache_read_input_tokens ?? 0;
+            const cw = u.cache_creation_input_tokens ?? 0;
+            // CodeBuddy (claude-internal) 网关把 input_tokens 报成 cr+cw+fresh 的总和,
+            // 而 Anthropic 官方 input_tokens 只含 fresh (与 cache_creation/cache_read disjoint)。
+            // 按模型命名风格判定源头: CodeBuddy 是 "claude-4.7-opus" (点号版本),
+            // Anthropic 官方是 "claude-opus-4-7" (纯连字符)。只对 CodeBuddy 风格反推,
+            // 普通 Anthropic-native 会话保持原样, 不影响其 usage 计算。
+            const isGatewayTotalized = typeof model === "string" && /\d\.\d/.test(model);
+            const input = isGatewayTotalized && rawIn >= cr + cw ? rawIn - cr - cw : rawIn;
+            out.push({
+                kind: "turn_usage",
+                model,
+                messageId,
+                usage: {
+                    input,
+                    output: u.output_tokens ?? 0,
+                    cacheRead: cr,
+                    cacheWrite: cw,
+                    serviceTier: u.service_tier,
+                    calls: 1,
+                },
+            });
+        }
+        // Terminal stop_reason → emit turn_end so onItem closes the live bubble.
+        // `tool_use` is intentionally excluded — more turns will follow once the
+        // tool result lands; finalizing now would split a single logical reply.
+        //
+        // 但 stop_reason 是 **消息级** 字段, 而 CC 把同一个 message.id 拆成多行落盘
+        // (thinking / text / tool_use 各占一行), 每行都原样带着这个 stop_reason ——
+        // 终态消息的 thinking 行先落盘, 就已经是 end_turn 了。在它上面收口 = turn 提前
+        // 结束: 紧随其后的真正答案(text 行)落在已关闭的 turn 之外, 只能走 standalone,
+        // 且此后整轮的 tool/text 全部退化成散装气泡。终态消息里必然有 text 块 (含
+        // tool_use 的消息 stop_reason 恒为 "tool_use"), 且实测终态消息从不拆出第二个
+        // text 行 —— 所以"本行带 text 块"精确等价于"本消息的最后一行"。
+        if (isFinal && blocks.some((b) => b?.type === "text"))
+            out.push({ kind: "turn_end" });
+        // 软收口 (codebuddy): 这条消息写完了, 但说不出后面还有没有 function_call。
+        else if (line.softTurnEnd)
+            out.push({ kind: "turn_end", soft: true });
+        return out;
+    }
+    // CC (≥2.1.198) 在一轮真正跑完后写一行 `system/turn_duration` —— 权威收口信号。
+    // 补上 stop_reason 路径覆盖不到的场景: 被 esc 打断的 turn 只剩 thinking 行, 永远
+    // 没有终态 text 行, 否则 brief turn 会一直挂到 hardTimer。与 stop_reason 收口重复
+    // 时无害 —— closeBriefTurn / finalizeStream 都是幂等的。goal 模式下 Stop hook 拦住
+    // 了收尾, CC 不写这一行, 所以不会把自主执行提前踢出 goal 模式。
+    if (line.type === "system" && line.subtype === "turn_duration")
+        return [{ kind: "turn_end" }];
+    // Slash-command records for TUI-only commands land here as `type:"system"`,
+    // `subtype:"local_command"` — the invocation itself and, if present, a
+    // sibling `<local-command-stdout>` line carrying the rendered panel.
+    //   • /context (2.1.139+): dumps the full panel as ANSI-decorated text.
+    //   • /model on Claude Code 2.1.139 still lands under `type:"user"`, so this
+    //     branch is currently /context-focused; other future TUI-only commands
+    //     that follow the same shape will fall through the same anchoring.
+    if (line.type === "system" && line.subtype === "local_command" && typeof line.content === "string") {
+        const stdout = line.content.match(/<local-command-stdout>([\s\S]*?)<\/local-command-stdout>/)?.[1] ?? "";
+        if (!stdout.trim())
+            return []; // pure invocation record or empty stdout
+        const cleaned = stripAnsi(stdout);
+        const anchored = anchorSkillOutput(cleaned);
+        if (!anchored)
+            return [];
+        // Fenced code block so WeCom renders the aligned /context panel monospaced
+        // (the bar-chart columns only line up in a fixed-width bubble).
+        return [{ kind: "skill_output", body: "⚙️\n```\n" + anchored + "\n```" }];
+    }
+    return [];
+};
+// 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;
+export const startMirrorTail = (deps) => {
+    const { log } = deps;
+    // A single logical tail follows ONE sessionId whose transcript file may move
+    // between sibling project dirs — Claude Code's EnterWorktree/ExitWorktree
+    // rename <sid>.jsonl into/out of <cwd>/.claude/worktrees/<name>, each cwd
+    // encoding to its own project dir. We keep a candidate path list (seeded with
+    // the attach-time path, grown lazily by sid on first miss) and ONE shared
+    // offset. Because the move is a rename (byte prefix preserved), the offset
+    // stays continuous across enter→work→exit: no re-dump, no missed lines, and
+    // switching back to the original path just resumes on the same offset.
+    // The sid search is scoped to the backend owning this transcript — a sid from
+    // another CLI is never ours, however recently it was written.
+    const candidates = [deps.jsonlPath];
+    // Newest-mtime candidate that currently exists (the move can briefly leave a
+    // stale sibling behind under copy-then-delete semantics; the destination wins).
+    const existing = () => candidates
+        .flatMap((p) => { try {
+        return [{ p, m: statSync(p).mtimeMs }];
+    }
+    catch {
+        return [];
+    } })
+        .sort((a, b) => b.m - a.m)[0]?.p;
+    // Live path: a known candidate if one exists; else the file relocated — find
+    // it by sid and cache so subsequent round-trips are a pure stat pick (no rescan).
+    const resolveLive = () => {
+        const known = existing();
+        if (known)
+            return known;
+        const found = findJsonlBySid(deps.sessionId, backendForPath(deps.jsonlPath));
+        if (found && !candidates.includes(found))
+            candidates.push(found);
+        return existing();
+    };
+    // Start at EOF — don't re-emit history. File may not exist yet (auto-spawn
+    // path: claude doesn't create the jsonl until it processes the first input);
+    // start at 0 in that case so we capture everything once it appears.
+    // Caller-provided startOffset wins (used by /clear migration to replay the
+    // already-written user line + any early assistant lines from offset 0).
+    let offset = deps.startOffset !== undefined
+        ? deps.startOffset
+        : (() => { const p = resolveLive(); return p ? statSync(p).size : 0; })();
+    let buffer = "";
+    let stopped = false;
+    // fs.watch binds one path; re-arm it on the live path whenever the file
+    // relocates. The 1s poll is the correctness floor either way.
+    let watcher;
+    let watchedPath = "";
+    const armWatch = (path) => {
+        if (path === watchedPath)
+            return;
+        watcher?.close();
+        watchedPath = path;
+        try {
+            watcher = watch(path, { persistent: false }, () => drain());
+        }
+        catch (e) {
+            watcher = undefined;
+            log.warn({ err: e.message }, "fs.watch failed; relying on poll");
+        }
+    };
+    const drain = () => {
+        if (stopped)
+            return;
+        const jsonlPath = resolveLive();
+        if (!jsonlPath)
+            return;
+        armWatch(jsonlPath);
+        let size;
+        try {
+            size = statSync(jsonlPath).size;
+        }
+        catch {
+            return;
+        }
+        if (size < offset) {
+            // file truncated/rotated — reset to new EOF
+            offset = size;
+            buffer = "";
+            return;
+        }
+        if (size === offset)
+            return;
+        const fd = openSync(jsonlPath, "r");
+        try {
+            const len = size - offset;
+            const buf = Buffer.alloc(len);
+            readSync(fd, buf, 0, len, offset);
+            offset = size;
+            buffer += buf.toString("utf8");
+        }
+        finally {
+            closeSync(fd);
+        }
+        let nl;
+        while ((nl = buffer.indexOf("\n")) !== -1) {
+            const line = buffer.slice(0, nl);
+            buffer = buffer.slice(nl + 1);
+            if (!line.trim())
+                continue;
+            for (const item of renderLine(line, deps))
+                deps.onItem(item);
+        }
+    };
+    const live0 = resolveLive();
+    if (live0)
+        armWatch(live0);
+    const poll = setInterval(drain, 1000);
+    log.info({ jsonlPath: deps.jsonlPath, startOffset: offset }, "mirror tail started");
+    return {
+        stop: () => {
+            stopped = true;
+            watcher?.close();
+            clearInterval(poll);
+        },
+        drain,
+    };
+};
+// Run a tmux subcommand, capturing stdout/stderr. Local helper to avoid
+// pulling spawn-tmux's runTmux into the bridge module graph.
+const tmuxRun = (args) => new Promise((resolve) => {
+    const p = spawn("tmux", args, { stdio: ["ignore", "pipe", "pipe"] });
+    let out = "", err = "";
+    p.stdout?.on("data", (c) => (out += c.toString("utf8")));
+    p.stderr?.on("data", (c) => (err += c.toString("utf8")));
+    p.on("error", (e) => resolve({ ok: false, stdout: "", stderr: e.message }));
+    p.on("close", (code) => resolve({ ok: code === 0, stdout: out, stderr: err }));
+});
+const sleepMs = (ms) => new Promise((r) => setTimeout(r, ms));
+// Stable JSON: sort object keys recursively. Used to fingerprint a tool_use's
+// `input` so the hook-side and the jsonl-side compute the same signature even
+// when the model emits keys in arbitrary order.
+const stableStringify = (v) => {
+    if (v === null || v === undefined)
+        return JSON.stringify(v);
+    if (typeof v !== "object")
+        return JSON.stringify(v);
+    if (Array.isArray(v))
+        return `[${v.map(stableStringify).join(",")}]`;
+    const obj = v;
+    const keys = Object.keys(obj).sort();
+    return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`).join(",")}}`;
+};
+const toolUseSig = (name, input) => `${name}|${stableStringify(input)}`;
+const RECENT_SIGS_MAX = 64;
+// macOS clipboard image inject. Claude Code's TUI handles Ctrl+V by reading the
+// system clipboard for image data and attaching it as an image content block in
+// the next user turn — no Read tool call, no permission prompt. To trigger that
+// path we (a) put image bytes onto the clipboard with the right AppleScript
+// pasteboard class, (b) send a literal C-v keystroke to the live tmux pane.
+//
+// Pasteboard class per source format:
+//   .png         → «class PNGf»
+//   .jpg/.jpeg   → JPEG picture
+//   .gif         → «class GIFf»
+//   .tiff/.tif   → «class TIFF»
+// Anything else (webp/heic/...) we transcode to PNG via `sips` first; sips ships
+// with macOS so no extra dep. Files are cached next to the original; cleanup is
+// left to the inbox dir's regular eviction.
+//
+// 注入策略 —— JXA 主路径 + AppleScript 兜底：
+//   codebuddy v2.72.0 的 release note 明确说"macOS 图片粘贴新增 JXA NSPasteboard
+//   后备方案，兼容企业微信等第三方截图工具"——说明 codebuddy 的 TUI 在主路径
+//   (AppleScript «class PNGf») 读不到图时，会走 JXA `$.NSPasteboard.generalPasteboard`
+//   后备。我们显式用 JXA 写一份 `NSPasteboardTypePNG` flavor，保证 codebuddy 的
+//   后备路径一定能读到；同时 `NSPasteboardTypePNG` 和 `«class PNGf»` 在系统层是
+//   同一个 UTI (public.png)，Claude Code 的主路径读 JXA 写入的 flavor 也没问题。
+//   JXA 失败（极少见，比如 AppKit 框架加载失败）才回退到纯 AppleScript。
+const PB_CLASS_BY_EXT = {
+    png: "«class PNGf»",
+    jpg: "JPEG picture",
+    jpeg: "JPEG picture",
+    gif: "«class GIFf»",
+    tif: "«class TIFF»",
+    tiff: "«class TIFF»",
+};
+const runProc = (cmd, args) => new Promise((resolve) => {
+    const p = spawn(cmd, args, { stdio: ["ignore", "ignore", "pipe"] });
+    let err = "";
+    p.stderr?.on("data", (c) => (err += c.toString("utf8")));
+    p.on("error", (e) => resolve({ ok: false, stderr: e.message }));
+    p.on("close", (code) => resolve({ ok: code === 0, stderr: err }));
+});
+const setMacClipboardImage = async (imgPath) => {
+    const ext = (imgPath.split(".").pop() ?? "").toLowerCase();
+    let pbClass = PB_CLASS_BY_EXT[ext];
+    let pathToUse = imgPath;
+    if (!pbClass) {
+        // Transcode to PNG so AppleScript can pull it onto the pasteboard.
+        const tmp = `${imgPath}.cb.png`;
+        const r = await runProc("sips", ["-s", "format", "png", imgPath, "--out", tmp]);
+        if (!r.ok)
+            return { ok: false, reason: `sips ${ext}→png failed: ${r.stderr.slice(-200)}` };
+        pathToUse = tmp;
+        pbClass = "«class PNGf»";
+    }
+    // POSIX path quoting: backslash-escape `\` and `"` for both AppleScript and
+    // JXA string literals (二者转义规则一致)。
+    const escaped = pathToUse.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+    // 主路径：JXA 直接写 NSPasteboardTypePNG。clearContents 后单 flavor 写入，
+    // 同时覆盖 codebuddy v2.72.0 JXA 后备读路径和 Claude Code 主路径。
+    // (public.png UTI 与 «class PNGf» 同一，Claude Code 读这份不会回归。)
+    const jxa = [
+        "ObjC.import('AppKit');",
+        "const pb = $.NSPasteboard.generalPasteboard;",
+        "pb.clearContents();",
+        `const data = $.NSData.dataWithContentsOfFile("${escaped}");`,
+        "if (data.isNil()) $.abort('read failed');",
+        "pb.setData(data, forType: $.NSPasteboardTypePNG);",
+    ].join(" ");
+    const rJxa = await runProc("osascript", ["-l", "JavaScript", "-e", jxa]);
+    if (rJxa.ok)
+        return { ok: true };
+    // 兜底：JXA 失败才回退纯 AppleScript（用原 pbClass，可能是 JPEG/GIF/TIFF，
+    // 不强转 PNG —— 这条路径本来就是 Claude Code 历史验证过的）。
+    const script = `set the clipboard to (read POSIX file "${escaped}" as ${pbClass})`;
+    const rApple = await runProc("osascript", ["-e", script]);
+    if (!rApple.ok) {
+        return {
+            ok: false,
+            reason: `clipboard set failed: jxa=${rJxa.stderr.slice(-120)}; applescript=${rApple.stderr.slice(-120)}`,
+        };
+    }
+    return { ok: true };
+};
+// Pane fingerprint for verifying paste/submit. `rows` controls how far back
+// from the bottom to capture: a wide window (12) for paste-landed (lenient,
+// catches wrapped content / hint lines), a narrow window (5) for input-box-
+// cleared. The narrow window matters after `/clear`: the buffer is almost
+// empty, so claude's echo of the just-submitted message sits directly above
+// the input box and would otherwise re-trigger the fingerprint, falsely
+// flagging "Enter not honored".
+const capturePaneTail = async (target, rows = 12) => {
+    const r = await tmuxRun(["capture-pane", "-t", target, "-p", "-S", `-${rows}`]);
+    return r.ok ? r.stdout : "";
+};
+// Trim slash-command stdout to the useful section. TUI panels prepend a run
+// of leading whitespace / bar-chart glyph rows before the human-readable
+// title; we anchor at the first title line and drop everything above. The
+// anchors here are the known /context titles — extend when new commands
+// route through this branch.
+const SKILL_ANCHORS = ["Context Usage"];
+const anchorSkillOutput = (raw) => {
+    const lines = raw.split("\n");
+    const idx = lines.findIndex((l) => SKILL_ANCHORS.some((a) => l.includes(a)));
+    const sliced = idx >= 0 ? lines.slice(idx) : lines;
+    return sliced.join("\n").replace(/^\s+|\s+$/g, "");
+};
+// How far back to capture when recovering a pre-card preamble. Preambles before
+// AskUserQuestion/ExitPlanMode are short; 40 rows covers wrap + the pending
+// tool/picker below it without dragging in the previous turn.
+const PANE_PREAMBLE_ROWS = 40;
+const BULLET = "⏺"; // ⏺ — Claude Code's assistant/tool bullet
+// Indented lines that are tool-execution summaries, not prose wrap. Filtered out
+// when they sandwich between prose and the pending tool.
+const TOOL_SUMMARY_RE = /^(⎿|… ?\+?\d|Ran |Read |Wrote |Edited |Listed |Searched |Found |Fetched |Called |Committed |Pushed |Pulled |Rebased |Staged |Updated )/u;
+// After `⏺ `: a tool call (`Bash(…`) or a collapsed summary → not prose.
+const isToolBullet = (afterBullet) => /^[A-Za-z_][\w.-]*\(/u.test(afterBullet) || TOOL_SUMMARY_RE.test(afterBullet);
+// Pull the most recent assistant PROSE block out of a Claude Code TUI capture —
+// the "why" that precedes a pending approval tool. CC renders prose as
+// `⏺ <text>` + 2-space-indented wrapped lines; tool calls as `⏺ Name(…)` and
+// summaries as indented `Ran…/Read…/⎿…`. Walk up from the bottom past the
+// pending tool region to the last prose bullet, then collect its block.
+// Best-effort: returns "" when nothing confident is found (caller sends the
+// card alone — status-quo, no regression).
+const extractPaneAssistantTail = (pane) => {
+    const lines = pane.replace(/[\s]+$/u, "").split("\n");
+    let start = -1;
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const ln = lines[i];
+        if (/^❯\s+\S/u.test(ln))
+            return ""; // a user-message echo above → no preamble between it and here
+        // note: the empty input-box prompt (`❯ ` + NBSP, nothing after) is NOT a boundary — skip it
+        if (ln.startsWith(BULLET + " ")) {
+            if (!isToolBullet(ln.slice(2).trimStart())) {
+                start = i;
+                break;
+            }
+            // tool bullet (the gating tool) — keep scanning up for the prose above it
+        }
+    }
+    if (start === -1)
+        return "";
+    const out = [lines[start].slice(2).trimStart()];
+    for (let i = start + 1; i < lines.length; i++) {
+        const ln = lines[i];
+        if (ln.trim() === "") {
+            out.push("");
+            continue;
+        }
+        if (ln.startsWith(BULLET))
+            break; // next block starts
+        if (!/^\s{2}\S/u.test(ln))
+            break; // not a 2-space continuation
+        if (/[│┌┐└┘├┤┬┴┼◯○●☐☑▪▸▹]/u.test(ln))
+            break; // picker/table chrome
+        const body = ln.trimStart();
+        if (TOOL_SUMMARY_RE.test(body))
+            continue; // sandwiched tool summary
+        out.push(body);
+    }
+    while (out.length && out[out.length - 1] === "")
+        out.pop();
+    const text = out.join("\n").trim();
+    return text.length >= 12 ? text : "";
+};
+// Two fingerprints, derived from different ends of `text`:
+//   headFp — first 8 non-ws chars; used for "did paste land" against a wide
+//     window because long pastes wrap and the head sits near the top of the
+//     input box, possibly outside a tight tail capture.
+//   tailFp — last 8 non-ws chars; sits right above the cursor (bottom of the
+//     input box). Used for "did input box clear" against a narrow window:
+//     after Enter, claude echoes the user message ABOVE the input box, so a
+//     wide capture stays "dirty" forever; a tight 5-row capture sees only
+//     the input box itself, which DOES clear.
+const fingerprints = (text) => {
+    const stripped = text.replace(/\s+/gu, "").trim();
+    return { headFp: stripped.slice(0, 8), tailFp: stripped.slice(-8) };
+};
+// Self-verifying inject. The cold-spawn race we guard against: paste lands
+// but the trailing Enter is eaten while the TUI is still initializing, so
+// the prompt sits typed-but-unsent. Strategy:
+//   1. paste; wide-window poll for headFp → paste reached the input box.
+//   2. settle; send Enter.
+//   3. narrow-window poll (last 5 rows = just the input box, NOT the echo
+//      above) for tailFp absence → submit was honored.
+//   4. on stuck-after-Enter, retry Enter once with extra settle.
+const injectViaTmux = async (target, text, images, log, freshSpawn, backendName) => {
+    log.info({ target, len: text.length, images: images.length, freshSpawn, backendName }, "mirror inject (tmux)");
+    // 图片注入策略按后端分流：
+    //   claude / claude-internal —— 走 macOS 剪贴板 + Ctrl+V，TUI 收到 \x16 后
+    //     直接读系统剪贴板的 PNGf flavor，附加为 image content block。
+    //   codebuddy —— 它的 TUI 在 TMUX 环境下收到 C-v 后会先调
+    //     syncTmuxToSystemClipboard()（执行 `tmux save-buffer - | pbcopy`），
+    //     这会用 tmux buffer 的文本内容覆盖系统剪贴板，把 daemon 刚写入的
+    //     PNGf flavor 冲掉（pbcopy 只写 public.utf8-plain-text，NSImage 读不到）。
+    //     所以 codebuddy 走 C-v 必然失败 —— 改走 @<path> 文本提及，让 LLM
+    //     调 Read 工具读图（Read 支持图片，见 codebuddy tools-reference.md）。
+    //     v2.52.4 之后 @<path> 不自动转 image block，但 LLM 看到路径会 Read。
+    if (backendName === "codebuddy") {
+        const refs = images.map((p) => `@${p}`);
+        const textWithRefs = refs.length ? (text ? `${refs.join("\n")}\n${text}` : refs.join("\n")) : text;
+        return injectViaTmuxText(target, textWithRefs, log, freshSpawn);
+    }
+    // Pump images first via clipboard+C-v so each one is attached as a separate
+    // image content block. Each C-v needs a brief settle for Claude Code's TUI
+    // to read the clipboard before the next overwrite. Fresh spawn extends.
+    const IMG_SETTLE_MS = freshSpawn ? 700 : 350;
+    for (const imgPath of images) {
+        const cb = await setMacClipboardImage(imgPath);
+        if (!cb.ok) {
+            log.warn({ imgPath, reason: cb.reason }, "mirror inject: clipboard set failed, skipping image");
+            continue;
+        }
+        const cv = await tmuxRun(["send-keys", "-t", target, "C-v"]);
+        if (!cv.ok)
+            return { ok: false, reason: `tmux send-keys C-v failed: ${cv.stderr.slice(-200)}` };
+        await sleepMs(IMG_SETTLE_MS);
+    }
+    // Image-only message: TUI input box now holds the attached images; press
+    // Enter and we're done. No fingerprint to verify (the input itself is binary
+    // image refs, not text).
+    if (!text) {
+        if (images.length === 0)
+            return { ok: true };
+        const e = await tmuxRun(["send-keys", "-t", target, "Enter"]);
+        return e.ok ? { ok: true } : { ok: false, reason: `tmux send-keys Enter failed: ${e.stderr.slice(-200)}` };
+    }
+    return injectViaTmuxText(target, text, log, freshSpawn);
+};
+// 文本 paste + Enter 提交 + 自校验。从 injectViaTmux 抽出来，让 codebuddy
+// 后端的 @<path> 回退路径也能复用同样的 paste-verify 逻辑。
+const injectViaTmuxText = async (target, text, log, freshSpawn) => {
+    // Warm pane: tight timings, low latency. Fresh spawn (claude --resume just
+    // started, transcript still loading): extended timings — bracketed-paste
+    // end can take 4-7s to be honored on a cold TUI. Only the fresh-spawn path
+    // pays the latency cost.
+    const PASTE_VERIFY_MS = freshSpawn ? 6000 : 2500;
+    const POST_PASTE_SETTLE_MS = freshSpawn ? 1500 : 400;
+    const POST_PASTE_SETTLE_FALLBACK_MS = freshSpawn ? 2500 : 700;
+    const CLEARED_TIMEOUT_MS = freshSpawn ? 4000 : 1500;
+    const RETRY_SETTLE_MS = freshSpawn ? 1500 : 800;
+    const loadAndPaste = async () => {
+        const loaded = await new Promise((resolve) => {
+            const loader = spawn("tmux", ["load-buffer", "-"], { stdio: ["pipe", "ignore", "pipe"] });
+            let lerr = "";
+            loader.stderr?.on("data", (c) => (lerr += c.toString("utf8")));
+            loader.on("error", (e) => resolve({ ok: false, reason: `tmux not found: ${e.message}` }));
+            loader.on("close", (code) => {
+                if (code !== 0)
+                    resolve({ ok: false, reason: `tmux load-buffer exit ${code}: ${lerr.slice(-200)}` });
+                else
+                    resolve({ ok: true });
+            });
+            loader.stdin?.end(text);
+        });
+        if (!loaded.ok)
+            return loaded;
+        const pasted = await tmuxRun(["paste-buffer", "-p", "-d", "-t", target]);
+        if (!pasted.ok)
+            return { ok: false, reason: `tmux paste-buffer failed: ${pasted.stderr.slice(-200)}` };
+        return { ok: true };
+    };
+    let r = await loadAndPaste();
+    if (!r.ok)
+        return r;
+    const { headFp, tailFp } = fingerprints(text);
+    const POLL_MS = 100;
+    const stripWs = (s) => s.replace(/\s+/gu, "");
+    // Wide window catches a wrapped paste's head whether it's row -3 or row -10.
+    const sawHead = async (timeoutMs) => {
+        const t0 = Date.now();
+        while (Date.now() - t0 < timeoutMs) {
+            const pane = await capturePaneTail(target, 12);
+            if (headFp && stripWs(pane).includes(headFp))
+                return true;
+            await sleepMs(POLL_MS);
+        }
+        return false;
+    };
+    // Narrow window = just the input box. tailFp is the chars next to the
+    // cursor, so it's always inside this window pre-submit and gone post-submit.
+    const inputBoxStillHasTail = async () => {
+        const pane = await capturePaneTail(target, 5);
+        return Boolean(tailFp) && stripWs(pane).includes(tailFp);
+    };
+    let pasteSeen = await sawHead(PASTE_VERIFY_MS);
+    if (!pasteSeen) {
+        // Paste fired before the TUI was reading — re-paste once after a back-off.
+        log.warn({ target, headFp }, "mirror inject: paste headFp not seen, re-pasting");
+        await sleepMs(RETRY_SETTLE_MS);
+        r = await loadAndPaste();
+        if (!r.ok)
+            return r;
+        pasteSeen = await sawHead(PASTE_VERIFY_MS);
+    }
+    // Bracketed-paste end + TUI catch-up. Warm pane: 400ms is invisible.
+    // Fresh respawn: 1500ms+ — claude --resume is still loading the transcript.
+    await sleepMs(pasteSeen ? POST_PASTE_SETTLE_MS : POST_PASTE_SETTLE_FALLBACK_MS);
+    const sendEnter = async () => {
+        const e = await tmuxRun(["send-keys", "-t", target, "Enter"]);
+        return e.ok ? { ok: true } : { ok: false, reason: `tmux send-keys failed: ${e.stderr.slice(-200)}` };
+    };
+    const waitForCleared = async (timeoutMs) => {
+        const t0 = Date.now();
+        while (Date.now() - t0 < timeoutMs) {
+            await sleepMs(POLL_MS);
+            if (!(await inputBoxStillHasTail()))
+                return true;
+        }
+        return false;
+    };
+    const e1 = await sendEnter();
+    if (!e1.ok)
+        return e1;
+    if (!pasteSeen)
+        log.warn({ target }, "mirror inject: submitted without paste verification (capture-pane lag)");
+    if (!tailFp)
+        return { ok: true }; // empty/whitespace text — nothing to verify
+    if (await waitForCleared(CLEARED_TIMEOUT_MS))
+        return { ok: true };
+    // Input box still holds our tail — Enter was eaten (cold TUI) or the
+    // bracketed-paste end hadn't been processed yet. One retry with extra
+    // settle. We keep this to ONE retry to bound damage if our cleared-check
+    // is wrong (would otherwise spam Enters into a real conversation).
+    log.warn({ target, tailFp }, "mirror inject: input box still has text after Enter, retrying once");
+    await sleepMs(RETRY_SETTLE_MS);
+    const e2 = await sendEnter();
+    if (!e2.ok)
+        return e2;
+    if (await waitForCleared(CLEARED_TIMEOUT_MS))
+        return { ok: true };
+    // freshSpawn fallback: claude --resume can take longer than our budget to
+    // process bracketed-paste end. The Enter was sent twice; if it lands later,
+    // claude will process the prompt and the user gets their reply. Trust it
+    // rather than reporting a hard failure that the user actually got served.
+    //
+    // Warm-pane path also trusts: in practice tmux Enter is reliable once the
+    // pane exists, and the verifier has structural false-positive risk —
+    // tailFp (last 8 non-ws chars) can match the echo line directly above the
+    // input box when it falls within the 5-row capture window. Surfacing
+    // `[mirror] ✗` to the user when the prompt actually landed is worse than
+    // accepting an extra no-op Enter on the rare true-stuck case.
+    log.warn({ target, tailFp, freshSpawn }, "mirror inject: clear not observed, trusting submit");
+    // Input box still held our text after two Enters. Usually the prompt landed
+    // late (verifier false-positive), but it can also mean the target session is
+    // busy / not consuming input (e.g. running a long task, or context full) —
+    // the user's message would then silently go nowhere. Flag it uncertain so the
+    // caller can hint the user, without reporting a hard failure.
+    return { ok: true, uncertain: true, reason: "目标会话可能正忙或未消费输入(回车后输入框未清空)" };
+};
+const injectViaSpawn = (args) => {
+    const { text, images = [], cfg, log, sessionId, jsonlPath } = args;
+    const bin = backendForPath(jsonlPath).bin;
+    // Spawn-mode (no live TTY) can't do clipboard+C-v — fall back to `@<path>`,
+    // which Claude parses at submit time and inlines as image content blocks
+    // without a model-decided Read tool turn.
+    const refs = images.map((p) => `@${p}`).join("\n");
+    const finalText = refs ? (text ? `${refs}\n${text}` : refs) : text;
+    const cliArgs = [
+        "-p",
+        finalText,
+        "--resume",
+        sessionId,
+        "--output-format",
+        "stream-json",
+        "--verbose",
+        ...cfg.wrc.extraArgs,
+    ];
+    log.info({ sessionId, bin, len: text.length }, "mirror inject");
+    return new Promise((resolve) => {
+        const proc = spawn(bin, cliArgs, {
+            cwd: expandHome(cfg.wrc.cwd),
+            env: { ...process.env, PATH: augmentedPath(process.env.PATH) },
+            stdio: ["ignore", "ignore", "pipe"],
+        });
+        let stderrTail = "";
+        let spawnError;
+        proc.on("error", (err) => {
+            spawnError = err;
+        });
+        proc.stderr?.on("data", (chunk) => {
+            stderrTail = (stderrTail + chunk.toString("utf8")).slice(-1500);
+        });
+        proc.on("close", (code) => {
+            if (spawnError) {
+                log.error({ err: spawnError.message }, "mirror spawn error");
+                resolve({ ok: false, reason: `spawn ${bin}: ${spawnError.message}` });
+                return;
+            }
+            if (code !== 0) {
+                log.error({ code, stderrTail: stderrTail.slice(-400) }, "mirror inject non-zero");
+                resolve({ ok: false, reason: `${bin} exited ${code}: ${stderrTail.slice(-300)}` });
+                return;
+            }
+            resolve({ ok: true });
+        });
+    });
+};
+const inject = (args) => {
+    const target = (args.tmuxTarget ?? "").trim();
+    if (!target)
+        return injectViaSpawn(args);
+    const backendName = backendForPath(args.jsonlPath).name;
+    return injectViaTmux(target, args.text, args.images ?? [], args.log, args.freshSpawn ?? false, backendName);
+};
+const queues = new Map();
+const enqueue = (key, job) => {
+    const prev = queues.get(key) ?? Promise.resolve();
+    const next = prev.then(job, job).catch(() => undefined);
+    queues.set(key, next.finally(() => {
+        if (queues.get(key) === next)
+            queues.delete(key);
+    }));
+    return next;
+};
+export const startMirror = (deps) => {
+    const { cfg, log, client } = deps;
+    // 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).
+    const bySessionId = new Map();
+    const byTarget = new Map();
+    // Ring buffer of recently-injected user texts to suppress WeCom→CLI echo.
+    const INJECT_TTL_MS = 60_000;
+    const recentInjects = [];
+    const rememberInject = (text) => {
+        const t = text.trim();
+        if (!t)
+            return;
+        recentInjects.push({ text: t, ts: Date.now() });
+        // Slash commands land in the jsonl wrapped in <command-name>...</command-name>
+        // tags; cleanUserText renders that as `/cmd args` (backticked). Push that
+        // form too so the dedupe filter catches the tail's emission — without this,
+        // /clear (and any other slash inject) echoes back as a quoted bubble.
+        if (t.startsWith("/")) {
+            const head = t.split(/\s+/, 1)[0] ?? t;
+            const args = t.slice(head.length).trim();
+            recentInjects.push({ text: `\`${head}${args ? ` ${args}` : ""}\``, ts: Date.now() });
+        }
+        if (recentInjects.length > 64)
+            recentInjects.shift();
+    };
+    const isOwnInject = (text) => {
+        const now = Date.now();
+        const t = text.trim();
+        for (let i = recentInjects.length - 1; i >= 0; i--) {
+            const e = recentInjects[i];
+            if (now - e.ts > INJECT_TTL_MS)
+                continue;
+            if (e.text === t)
+                return true;
+        }
+        return false;
+    };
+    // Assistant prose pushed EARLY from a pane capture (pre-card preamble). The
+    // same text lands in the jsonl later — CC flushes a tool-terminated turn only
+    // when the tool resolves, i.e. after the card is answered — so the tail would
+    // re-send it. Match normalized (ws-stripped) so a wrapped/dedented pane copy
+    // equals the clean jsonl text; boundary match covers a pane that only caught
+    // part of a long preamble. findAssistantSend peeks (dup-guard for the per-
+    // question flushBeforeCard re-calls); isOwnAssistantSend consumes one-shot.
+    const recentAssistantSends = [];
+    const normAssistant = (s) => s.replace(/\s+/gu, "");
+    const findAssistantSend = (text) => {
+        const sig = normAssistant(text);
+        if (sig.length < 12)
+            return -1;
+        const cutoff = Date.now() - INJECT_TTL_MS;
+        for (let i = recentAssistantSends.length - 1; i >= 0; i--) {
+            const e = recentAssistantSends[i];
+            if (e.ts < cutoff)
+                continue;
+            if (sig === e.sig || sig.startsWith(e.sig) || e.sig.startsWith(sig) || sig.endsWith(e.sig) || e.sig.endsWith(sig))
+                return i;
+        }
+        return -1;
+    };
+    const rememberAssistantSend = (text) => {
+        const sig = normAssistant(text);
+        if (sig.length < 12)
+            return;
+        recentAssistantSends.push({ sig, ts: Date.now() });
+        if (recentAssistantSends.length > 32)
+            recentAssistantSends.shift();
+    };
+    const isOwnAssistantSend = (text) => {
+        const i = findAssistantSend(text);
+        if (i === -1)
+            return false;
+        recentAssistantSends.splice(i, 1); // one-shot: a genuine later re-say still streams
+        return true;
+    };
+    // ── 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
+    // (5s ack timeout each). After 6 min the server stops accepting refreshes.
+    // We keep the stream open until either (a) the next inbound supersedes it,
+    // (b) the hard cap fires (just under 6 min), (c) server rejects (s.dead),
+    // or (d) we hit the byte cap. No idle-based close — claude can sit thinking
+    // 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;
+    /** 软收口静默期。后端只能说"这条消息写完了"(codebuddy) 时, 等这么久没有新 item
+     *  才认定一轮结束。取值只需盖住"叙述消息落盘 → 紧随其后的 function_call 落盘"
+     *  这一段, 与模型思考/工具执行时长无关。 */
+    const SOFT_TURN_END_MS = 4_000;
+    const STREAM_SOFT_CAP = 18_000;
+    const TOOL_DETAIL_TTL_MS = 24 * 60 * 60 * 1000;
+    const turnRegistry = new Map();
+    const evictTurns = () => {
+        const now = Date.now();
+        for (const [k, v] of turnRegistry)
+            if (v.expiresAt < now)
+                turnRegistry.delete(k);
+    };
+    const TOOL_DETAIL_PREFIX = "TOOL_DETAIL|";
+    const newTurnId = () => `t${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
+    const detailCardFor = (s, target) => {
+        if (s.tools.length === 0)
+            return undefined;
+        const tag = tagOfTarget(target);
+        const titlePrefix = tag ? `${labelFor(tag)} #${tag} · ` : "";
+        return {
+            card_type: "button_interaction",
+            main_title: { title: `${titlePrefix}本轮工具调用` },
+            sub_title_text: `共 ${s.tools.length} 次调用，点击查看详情`,
+            task_id: s.turnId,
+            button_list: [{ text: "查看详情", style: 1, key: `${TOOL_DETAIL_PREFIX}${s.turnId}` }],
+        };
+    };
+    const flushStream = async (s) => {
+        s.flushTimer = undefined;
+        if (s.closed || s.dead || s.acc === s.lastSent)
+            return;
+        const content = s.acc;
+        s.lastSent = content;
+        try {
+            await client.replyStream(s.frame, s.streamId, withSessionTag(s.target, content || " "), false);
+            log.debug({ turnId: s.turnId, len: content.length }, "stream flush ok");
+        }
+        catch (e) {
+            log.warn({ turnId: s.turnId, err: e.message }, "stream flush failed; marking dead");
+            s.dead = true;
+        }
+    };
+    const scheduleFlush = (s) => {
+        if (s.flushTimer || s.closed || s.dead)
+            return;
+        s.flushTimer = setTimeout(() => void flushStream(s), FLUSH_MS);
+    };
+    const finalizeStream = async (a, s) => {
+        if (s.closed)
+            return;
+        s.closed = true;
+        if (s.flushTimer) {
+            clearTimeout(s.flushTimer);
+            s.flushTimer = undefined;
+        }
+        if (s.idleTimer) {
+            clearTimeout(s.idleTimer);
+            s.idleTimer = undefined;
+        }
+        if (s.hardTimer) {
+            clearTimeout(s.hardTimer);
+            s.hardTimer = undefined;
+        }
+        if (!s.dead) {
+            const card = detailCardFor(s, a.target);
+            try {
+                if (card) {
+                    s.cardSent = true;
+                    await client.replyStreamWithCard(s.frame, s.streamId, withSessionTag(a.target, s.acc || " "), true, { templateCard: card });
+                }
+                else {
+                    await client.replyStream(s.frame, s.streamId, withSessionTag(a.target, s.acc || " "), true);
+                }
+                log.info({ sessionId: a.sessionId, turnId: s.turnId, accLen: s.acc.length, tools: s.tools.length, withCard: !!card }, "stream finalize");
+            }
+            catch (e) {
+                log.warn({ sessionId: a.sessionId, turnId: s.turnId, err: e.message }, "stream finalize failed");
+                s.dead = true;
+            }
+        }
+        else {
+            log.info({ sessionId: a.sessionId, turnId: s.turnId, accLen: s.acc.length, tools: s.tools.length }, "stream finalize (dead)");
+        }
+        if (s.tools.length > 0) {
+            turnRegistry.set(s.turnId, {
+                tools: s.tools,
+                target: a.target,
+                expiresAt: Date.now() + TOOL_DETAIL_TTL_MS,
+            });
+            evictTurns();
+        }
+        if (a.liveStream === s)
+            a.liveStream = undefined;
+    };
+    const openStream = (a, frame, streamId) => {
+        const s = {
+            turnId: newTurnId(),
+            frame, streamId,
+            target: a.target,
+            acc: "", lastSent: "",
+            capped: false, closed: false, dead: false, cardSent: false,
+            tools: [], sawTool: false,
+        };
+        s.hardTimer = setTimeout(() => void finalizeStream(a, s), HARD_TIMEOUT_MS);
+        log.info({ sessionId: a.sessionId, turnId: s.turnId, streamId }, "stream open");
+        return s;
+    };
+    // Standalone fallback (no live stream / stream dead). Per-attachment FIFO so
+    // pushes from a single mirror stay ordered; different mirrors run in parallel.
+    const sendStandalone = (a, content) => {
+        const chatId = stripPrincipalPrefix(a.target);
+        // Tag AFTER splitting — one header per bubble, so chunk 2..N stay
+        // attributable to the session instead of arriving anonymous.
+        const pieces = splitChunks(content, Math.max(200, cfg.wrc.mirror.chunkChars - TAG_HEADER_BUDGET));
+        const chunks = pieces.map((p, i) => withSessionTag(a.target, p, pieces.length > 1 ? `${i + 1}/${pieces.length}` : undefined));
+        a.standalonePending = a.standalonePending
+            .then(async () => {
+            for (const c of chunks) {
+                try {
+                    await client.sendMessage(chatId, { msgtype: "markdown", markdown: { content: c } });
+                }
+                catch (e) {
+                    log.warn({ sessionId: a.sessionId, err: e.message }, "standalone push failed");
+                }
+            }
+        })
+            .catch(() => undefined);
+    };
+    // Pre-card preamble recovery. Called right before an approval card when the
+    // gating tool_use is NOT yet in the jsonl (mirror mode: CC defers the whole
+    // tool-terminated turn's flush until the tool resolves — after the card is
+    // answered). The "why" text is therefore only in the live pane; capture it,
+    // push it ahead of the card, and remember it so the later jsonl-tailed copy
+    // is dropped as a dup. Enqueues on standalonePending, which flushBeforeCard
+    // awaits — so the card lands after. Fail-safe: any miss → just the card.
+    const sendPanePreamble = async (a) => {
+        if (!cfg.wrc.mirror.panePreamble || !a.tmuxPane)
+            return;
+        try {
+            const pane = await capturePaneTail(a.tmuxPane, PANE_PREAMBLE_ROWS);
+            const text = extractPaneAssistantTail(pane);
+            if (!text || findAssistantSend(text) !== -1)
+                return; // nothing new / already queued
+            rememberAssistantSend(text);
+            sendStandalone(a, text);
+            log.info({ sessionId: a.sessionId, len: text.length }, "flushBeforeCard: pushed pane preamble before card");
+        }
+        catch (e) {
+            log.warn({ sessionId: a.sessionId, err: e.message }, "pane preamble capture failed");
+        }
+    };
+    // Debounce 聚合: 仅 standalone 路径用。窗口内 onItem 多次落入 → 合并成单条 markdown。
+    // 0 关闭时退化为透传。flushStandalone 也用于 detach 时的 drain。
+    const flushStandalone = (a) => {
+        const buf = a.standaloneBuf;
+        if (!buf)
+            return;
+        a.standaloneBuf = undefined;
+        sendStandalone(a, buf.parts.join("\n\n"));
+    };
+    const enqueueStandalone = (a, content) => {
+        const ms = cfg.wrc.mirror.standaloneDebounceMs;
+        if (ms <= 0) {
+            sendStandalone(a, content);
+            return;
+        }
+        if (a.standaloneBuf) {
+            clearTimeout(a.standaloneBuf.timer);
+            a.standaloneBuf.parts.push(content);
+            a.standaloneBuf.timer = setTimeout(() => flushStandalone(a), ms);
+            return;
+        }
+        a.standaloneBuf = {
+            parts: [content],
+            timer: setTimeout(() => flushStandalone(a), ms),
+        };
+    };
+    const recordToolEntry = (s, item) => {
+        if (item.kind === "tool_use") {
+            for (const c of item.calls) {
+                s.tools.push({ toolUseId: c.toolUseId, name: c.name, input: c.input });
+            }
+        }
+        else if (item.kind === "tool_result") {
+            // Match by toolUseId; if not found, append a standalone result entry.
+            const existing = item.toolUseId
+                ? s.tools.find((t) => t.toolUseId === item.toolUseId && t.result === undefined)
+                : undefined;
+            if (existing)
+                existing.result = item.full;
+            else
+                s.tools.push({ toolUseId: item.toolUseId, name: "(result)", input: undefined, result: item.full });
+        }
+    };
+    // ── Outbound deferral (DEFERRED / AWAITING_APPR state machine) ────────
+    // 进入 AWAITING_APPR 的唯一触发口是 daemon 真要发卡前调的 flushBeforeCard。
+    // 历史上 mirror 这边还做过一次本地 needsApproval 预判直接早闪 standalone, 但那
+    // 条路无法预知 hook 会不会被 auto / bypass / 自定义 self-call 放行 — 预判错时
+    // 就会出现 standalone 已经发出、随即又新开 stream 的"气泡分裂"。现在去掉,
+    // 让 flushBeforeCard 作为单一信号: 发卡的真实路径 → flush as standalone,
+    // 不发卡的所有路径 (auto mode、cache、bypass) → deferMs 计时器原地促进到 STREAMING。
+    const renderBuf = (buf) => buf.map((i) => ("body" in i ? i.body : "")).filter(Boolean).join("\n\n");
+    // Drain any pending standalone debounce so the prior turn's tail content
+    // doesn't sandwich into our pre-card flush. Caller already ensured `outbound`
+    // points at a deferred slot.
+    const flushPendingStandalone = (a) => {
+        if (!a.standaloneBuf)
+            return;
+        clearTimeout(a.standaloneBuf.timer);
+        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.
+    const promoteToStandalone = (a) => {
+        const out = a.outbound;
+        if (out?.kind !== "deferred")
+            return;
+        clearTimeout(out.timer);
+        const md = renderBuf(out.buf);
+        a.outbound = { kind: "awaiting_appr", frame: out.frame, streamId: out.streamId };
+        flushPendingStandalone(a);
+        if (md)
+            sendStandalone(a, md);
+        log.info({ sessionId: a.sessionId, items: out.buf.length, mdLen: md.length }, "outbound: DEFERRED → AWAITING_APPR (needs-approval flush)");
+    };
+    // Path C: turn ended inside the deferral window (fast pure-text reply, or
+    // an end-to-end tool turn that happened to fit in the window). The inbound's
+    // streamId is already showing a "loading" bubble in WeCom (server polls us
+    // for every msg.msgid; we haven't replied to this one) — sending a separate
+    // standalone leaves that loading bubble dangling until WeCom's ~6-min
+    // server-side timeout. Push the buffered content into the held streamId
+    // with finish=true so the bubble fills + closes in one shot.
+    //
+    // Split mirrors the STREAMING tool→FINAL_text rule: if buf saw a tool AND
+    // ends with a run of final-text items, peel that run out into a standalone
+    // so the answer gets its own bubble (preview = real answer, not tool noise).
+    // Pure-text turn or no trailing final text → no split, all into streamId.
+    const exitDeferredAsFinalStream = (a) => {
+        const out = a.outbound;
+        if (out?.kind !== "deferred")
+            return;
+        clearTimeout(out.timer);
+        const buf = out.buf;
+        const sawTool = buf.some((i) => i.kind === "tool_use" || i.kind === "tool_result");
+        let bubbleEnd = buf.length;
+        if (sawTool) {
+            while (bubbleEnd > 0) {
+                const it = buf[bubbleEnd - 1];
+                if (it.kind === "text" && it.final === true)
+                    bubbleEnd--;
+                else
+                    break;
+            }
+        }
+        const bubbleItems = buf.slice(0, bubbleEnd);
+        const trailingFinal = buf.slice(bubbleEnd);
+        const bubbleMd = renderBuf(bubbleItems);
+        const trailingMd = renderBuf(trailingFinal);
+        a.outbound = undefined;
+        flushPendingStandalone(a);
+        void (async () => {
+            try {
+                await client.replyStream(out.frame, out.streamId, withSessionTag(a.target, bubbleMd || " "), true);
+            }
+            catch (e) {
+                log.warn({ sessionId: a.sessionId, err: e.message }, "exit-deferred finalize failed; falling back to standalone");
+                if (bubbleMd)
+                    sendStandalone(a, bubbleMd);
+            }
+            if (trailingMd)
+                sendStandalone(a, trailingMd);
+        })();
+        log.info({ sessionId: a.sessionId, items: buf.length, bubbleLen: bubbleMd.length, trailingLen: trailingMd.length, sawTool }, "outbound: DEFERRED → IDLE (turn_end, finalized to streamId)");
+    };
+    // Path B: deferral timer fired without a needs-approval tool. Open a normal
+    // stream and replay the buffer through onItem — it'll flow through the
+    // STREAMING branch since outbound is now undefined.
+    const promoteToStream = (a) => {
+        const out = a.outbound;
+        if (out?.kind !== "deferred")
+            return;
+        const { buf, frame, streamId } = out;
+        a.outbound = undefined;
+        const s = openStream(a, frame, streamId);
+        a.liveStream = s;
+        if (buf.length === 0) {
+            // Empty buffer — claude still thinking. Send the "…" ack so the user
+            // sees the bubble; subsequent items grow it as today.
+            void (async () => {
+                try {
+                    await client.replyStream(frame, streamId, withSessionTag(a.target, "…"), false);
+                }
+                catch (e) {
+                    log.warn({ sessionId: a.sessionId, err: e.message }, "stream initial ack failed");
+                }
+            })();
+        }
+        log.info({ sessionId: a.sessionId, items: buf.length, turnId: s.turnId }, "outbound: DEFERRED → STREAMING (timer)");
+        for (const item of buf)
+            onItem(a, item);
+    };
+    const enterDeferred = (a, frame, streamId) => {
+        // Safety net: if nothing ever arrives (inject stuck, claude crashed, or
+        // claude went silent forever), promote-to-stream after 5 min to clean up.
+        // The REAL deferral window (cfg.wrc.mirror.outboundDeferMs) is armed by
+        // handleDeferredItem when the first tail item lands — measuring from "claude
+        // starts producing" not from "dispatch starts", which would otherwise fire
+        // during inject latency (typical 1-4s for tmux paste verify) + post-inject
+        // thinking gap (often 5-15s for non-trivial prompts) and falsely promote
+        // an empty buffer before any tool_use can be evaluated for approval-needs.
+        const SAFETY_MS = 5 * 60_000;
+        const timer = setTimeout(() => promoteToStream(a), SAFETY_MS);
+        a.outbound = { kind: "deferred", buf: [], frame, streamId, timer };
+        log.info({ sessionId: a.sessionId, safetyMs: SAFETY_MS }, "outbound: IDLE → DEFERRED (safety net)");
+    };
+    // Buffer / decide while in DEFERRED. user_text is CLI-side typing (not the
+    // WeCom inbound), unrelated to this turn — drop. tool_use triggers Path A
+    // when ANY parallel call needs approval. First item arms the short window;
+    // subsequent items don't reset (bounded promote delay).
+    const handleDeferredItem = (a, item) => {
+        const out = a.outbound;
+        if (out?.kind !== "deferred")
+            return;
+        if (item.kind === "turn_end") {
+            exitDeferredAsFinalStream(a);
+            return;
+        }
+        if (item.kind === "user_text")
+            return;
+        // Skill outputs (e.g. /model) bypass deferred filtering — emit directly
+        // as a standalone bubble so the user sees the result immediately.
+        if (item.kind === "skill_output") {
+            enqueueStandalone(a, item.body);
+            return;
+        }
+        const wasEmpty = out.buf.length === 0;
+        out.buf.push(item);
+        if (wasEmpty) {
+            // First activity from claude — swap the safety net for the short defer
+            // window. flushBeforeCard 会在真要发卡前把 buf 转 AWAITING_APPR; 没卡可发
+            // 时这个计时器到点就 promoteToStream, 让 bypass/auto 场景也只走一条 stream。
+            clearTimeout(out.timer);
+            const deferMs = cfg.wrc.mirror.outboundDeferMs;
+            out.timer = setTimeout(() => promoteToStream(a), deferMs);
+            log.info({ sessionId: a.sessionId, deferMs, kind: item.kind }, "outbound: first item → short defer armed");
+        }
+    };
+    // ── Brief mode ────────────────────────────────────────────────────────
+    // 每个 turn 挂一条 loading 气泡 (起始 "…" finish=false, 不立刻关掉)。收口时:
+    //   • 无工具 → 直接把 Claude 最终文本 (或 slash 命令的 skill_output) 写进这条气泡。
+    //   • 有工具 → 气泡收成 "✴️ 详情链接", 最终文本另发一条 standalone。
+    // 其它所有 item 只写入 turn detail store。
+    // 能证明"assistant 已经在产出"的 item —— 见到它们才补开无气泡 turn。
+    const BRIEF_TURN_OPENERS = new Set(["text", "tool_use", "tool_result", "skill_output"]);
+    // 链接落到 chat 视图: 默认选中本 turn 所属的 #tag, 贴底显示整条会话。turnId 依旧
+    // 是凭据 (不可枚举), 只是页面从"一个 turn"扩成"这个 chat 的全部会话"。
+    const briefDetailLink = (turnId) => `✴️ [View chat details](${buildChatUrl(cfg.daemon.detailPublicBase, cfg.daemon.host, cfg.daemon.port, turnId)})`;
+    // 收口一条 loading 气泡: finish=true 写入最终内容, 只生效一次。发送失败退回 standalone。
+    // 排队中的 turn 也持有气泡, 所以气泡是显式入参而不是从 a 上取。
+    const finishBubble = async (a, b, content) => {
+        if (!b || b.done)
+            return;
+        b.done = true;
+        clearTimeout(b.hardTimer);
+        if (a.briefBubble === b)
+            a.briefBubble = undefined;
+        try {
+            await client.replyStream(b.frame, b.streamId, withSessionTag(a.target, content || " "), true);
+        }
+        catch (e) {
+            log.warn({ sessionId: a.sessionId, err: e.message }, "brief: bubble finish failed; standalone fallback");
+            if (content.trim())
+                sendStandalone(a, content);
+        }
+    };
+    const finishBriefBubble = (a, content) => finishBubble(a, a.briefBubble, content);
+    // 让一个已建好记录的 turn 成为活跃 turn。turn 级状态在这里统一归零 —— 唯一入口。
+    const openBriefTurn = (a, q) => {
+        a.briefTurnId = q.turnId;
+        a.briefBubble = q.bubble;
+        a.briefIsSlash = q.isSlash;
+        a.briefHadTool = false;
+        a.briefConcluded = false;
+        a.briefLastText = undefined;
+        log.info({ sessionId: a.sessionId, turnId: q.turnId, isSlash: q.isSlash }, "brief: turn started");
+    };
+    // WeCom 侧发起一个 turn: 立刻挂 loading 气泡当 ack, 再决定是马上激活还是排队。
+    // 上一 turn 还在跑时绝不能强关它 —— CC 那边新消息也是排队的, 当前轮的后半段还会
+    // 继续落盘, 强关会把它们改挂到新 turn 上, 旧 turn 页则提前变「已完成」。
+    const startBriefTurn = async (a, frame, streamId, isSlash = false, userQuery = "") => {
+        const turnId = newTurnId();
+        recordTurnStart({ id: turnId, target: a.target, sessionId: a.sessionId, userQuery: userQuery.trim() || undefined });
+        // hardTimer 兜底: turn 若无终句 / turn_end 收口 (卡死/漏收), 到点仍收气泡。
+        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);
+            }
+            void finishBubble(a, bubble, briefDetailLink(turnId));
+        }, HARD_TIMEOUT_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);
+        }
+        try {
+            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");
+        }
+    };
+    // 无气泡 turn。CLI 侧自己开的一轮 (WeCom 从没发过消息, 拿不到 frame/streamId), 以及
+    // 收口后仍有 item 补写进来的情况, 都要有一个 turn 承接 —— 否则每条 tool/text 都掉进
+    // fallback standalone, 一轮工具密集的对话能在群里刷出几十条散装气泡。这里只推一条
+    // 详情链接当入口, 其余全部收进 turn 页, 与 WeCom 侧发起的 turn 表现一致。
+    const ensureBriefTurn = (a) => {
+        if (a.briefTurnId)
+            return;
+        const turnId = newTurnId();
+        const query = a.pendingBriefQuery?.replace(/^> ?/gm, "").trim();
+        a.pendingBriefQuery = undefined;
+        recordTurnStart({ id: turnId, target: a.target, sessionId: a.sessionId, userQuery: query || undefined });
+        a.briefTurnId = turnId;
+        a.briefBubble = undefined;
+        a.briefIsSlash = false;
+        a.briefHadTool = false;
+        a.briefConcluded = false;
+        a.briefLastText = undefined;
+        enqueueStandalone(a, briefDetailLink(turnId));
+        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;
+        a.briefHadTool = true;
+        void finishBriefBubble(a, briefDetailLink(a.briefTurnId));
+    };
+    // 本轮结论落地, 只生效一次:
+    //   • 无工具 → 结论 + 详情链接一并写进 loading 气泡 (仍是一条消息);
+    //   • 有工具 / 无气泡 turn → 气泡留给 closeBriefTurn 收详情链接, 结论另发 standalone。
+    // 每个 turn 都必须留一个可回溯入口, 单句回答也要带链接。
+    const concludeBriefTurn = (a, body) => {
+        const turnId = a.briefTurnId;
+        if (!turnId || a.briefConcluded || !body.trim())
+            return;
+        a.briefConcluded = true;
+        if (a.briefHadTool || !a.briefBubble)
+            sendStandalone(a, body);
+        else
+            void finishBriefBubble(a, `${body}\n\n${briefDetailLink(turnId)}`);
+        // 排队中的 turn 已经建了记录但还没跑, 不能被这把扫帚扫成「已完成」。
+        const keep = [turnId, ...(a.briefQueue ?? []).map((q) => q.turnId)];
+        recordCloseOpenTurns({ target: a.target, sessionId: a.sessionId, exceptIds: keep });
+    };
+    /** soft=true: 收口信号来自静默期确认 (后端无终句标记), 拿本轮最后一句 text 当结论。
+     *  硬信号路径上结论早已由 final text 落地, briefConcluded 会挡住重复推送。 */
+    const closeBriefTurn = (a, soft = false) => {
+        if (!a.briefTurnId)
+            return;
+        if (soft)
+            concludeBriefTurn(a, a.briefLastText ?? "");
+        // 气泡还开着 (有工具的 turn: 结论只发了 standalone, 气泡留到这里收链接; 或空 turn
+        // 没有结论) —— 收口: 统一写详情链接, 保证每个 turn 都有可点入口。
+        if (a.briefBubble && !a.briefBubble.done) {
+            void finishBriefBubble(a, briefDetailLink(a.briefTurnId));
+        }
+        recordTurnClose(a.briefTurnId);
+        log.info({ sessionId: a.sessionId, turnId: a.briefTurnId }, "brief: turn closed");
+        a.briefTurnId = undefined;
+        a.briefBubble = undefined;
+        a.briefHadTool = false;
+        a.briefIsSlash = false;
+        a.briefConcluded = false;
+        a.briefLastText = undefined;
+        // 放行下一个排队的 turn —— 它的气泡早在 ack 时就挂出去了, 这里只是激活。
+        const next = a.briefQueue?.shift();
+        if (next)
+            openBriefTurn(a, next);
+    };
+    // Route one RenderItem into the turn store. final text 会额外作为 standalone 发群。
+    const handleBriefItem = (a, item) => {
+        const turnId = a.briefTurnId;
+        if (!turnId)
+            return;
+        const now = Date.now();
+        if (item.kind === "tool_use") {
+            a.briefHadTool = true; // 有工具 → 气泡收口写详情链接, 结论另发 standalone
+            earlyLinkBubble(a); // 立刻推详情链接, 不等 turn 收口
+            for (const c of item.calls) {
+                // 也走单卡 detail record — turn 页里 tool_use 段可点开链到独立详情 (以后有需要时)。
+                if (c.toolUseId) {
+                    recordTool({
+                        id: c.toolUseId,
+                        toolName: c.name,
+                        toolInput: c.input,
+                        sessionId: a.sessionId,
+                        target: a.target,
+                    });
+                }
+                recordTurnItem(turnId, {
+                    t: "tool_use",
+                    toolUseId: c.toolUseId,
+                    toolName: c.name,
+                    toolInput: c.input,
+                    ts: now,
+                });
+            }
+            return;
+        }
+        if (item.kind === "tool_result") {
+            earlyLinkBubble(a);
+            recordTurnItem(turnId, { t: "tool_result", toolUseId: item.toolUseId, body: item.full, ts: now });
+            return;
+        }
+        if (item.kind === "text") {
+            recordTurnItem(turnId, { t: "text", body: item.body, ts: now, final: item.final === true });
+            a.briefLastText = item.body; // 软收口时拿它当结论 (那条路径上没有 final 标记)
+            // final===false 才是"确知的中途输出"; undefined 是后端说不清, 不能据此提前收气泡。
+            if (item.final === false)
+                earlyLinkBubble(a);
+            if (item.final === true)
+                concludeBriefTurn(a, item.body);
+            return;
+        }
+        if (item.kind === "turn_end") {
+            closeBriefTurn(a, item.soft === true);
+            return;
+        }
+        if (item.kind === "turn_usage") {
+            recordTurnUsage(turnId, { model: item.model, messageId: item.messageId, usage: item.usage });
+            return;
+        }
+        if (item.kind === "skill_output") {
+            recordTurnItem(turnId, { t: "text", body: item.body, ts: now });
+            // slash 命令 (/context…) 的 skill_output 即本轮答案 (无 final text 收口) —— 写进
+            // loading 气泡。非 slash 场景的 skill_output (task 通知等) 是中间反馈, 照旧 standalone。
+            if (a.briefIsSlash && !a.briefHadTool && a.briefBubble && !a.briefBubble.done) {
+                void finishBriefBubble(a, item.body);
+            }
+            else {
+                sendStandalone(a, item.body);
+            }
+            return;
+        }
+        // user_text (CLI 侧输入) 在 brief 下丢弃 — turn 视角不需要展示。
+    };
+    const goalBanner = (cond) => cond
+        ? `🎯 目标已设置，进入自主执行：${cond}\n进度将实时推送。`
+        : "🎯 进入目标自主执行模式，进度将实时推送。";
+    // Enter goal-progress mode. The /goal was (usually) sent from WeCom, so a brief
+    // loading bubble is open — finalize it to the goal banner and close the brief
+    // turn so its turn_end-gated state doesn't dangle for the whole (never-ending)
+    // run. When goal was set from the CLI there's no brief turn — just announce.
+    const enterGoalMode = (a, condition) => {
+        if (a.goalActive)
+            return; // 幂等: 重放/重复 marker 不再重发 banner
+        const banner = goalBanner(condition);
+        if (a.briefBubble && !a.briefBubble.done)
+            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
+        a.goalActive = true;
+        log.info({ sessionId: a.sessionId, target: a.target, condition }, "goal: entered progress mode");
+    };
+    // Route items while a goal is active. Text (the model's inter-tool narration and
+    // the final answer) streams as standalone progress; tools/results stay in the
+    // detail store only (renderLine already recorded them) to avoid flooding the
+    // chat with hundreds of tool bubbles. turn_end = the goal auto-cleared and the
+    // model finally stopped → leave goal mode; normal brief resumes next turn.
+    const handleGoalItem = (a, item) => {
+        if (item.kind === "text" || item.kind === "skill_output") {
+            enqueueStandalone(a, item.body);
+            return;
+        }
+        if (item.kind === "turn_end") {
+            a.goalActive = false;
+            log.info({ sessionId: a.sessionId, target: a.target }, "goal: cleared (turn ended)");
+            return;
+        }
+        // tool_use / tool_result / user_text / turn_usage: recorded to detail store; no bubble.
+    };
+    // 软收口到点: 静默期内没有新 item, 确认这一轮真的结束了。
+    const fireSoftTurnEnd = (a) => {
+        a.softEnd = undefined;
+        log.debug({ sessionId: a.sessionId, turnId: a.briefTurnId }, "soft turn_end confirmed");
+        if (a.goalActive) {
+            handleGoalItem(a, { kind: "turn_end" });
+            return;
+        }
+        if (cfg.wrc.mirror.brief && a.briefTurnId) {
+            closeBriefTurn(a, true);
+            return;
+        }
+        if (a.liveStream && !a.liveStream.closed)
+            void finalizeStream(a, a.liveStream);
+    };
+    const onItem = (a, item) => {
+        // 任何新 item 到达 = 上一条"消息写完了"并不代表这一轮结束 → 撤销待确认的软收口。
+        // 硬信号 (end_turn / turn_duration) 的后端永远不会走到这里。
+        if (a.softEnd) {
+            clearTimeout(a.softEnd);
+            a.softEnd = undefined;
+        }
+        if (item.kind === "turn_end" && item.soft === true) {
+            a.softEnd = setTimeout(() => fireSoftTurnEnd(a), SOFT_TURN_END_MS);
+            return;
+        }
+        // Record tool_use signatures unconditionally (before any state branching),
+        // so flushBeforeCard's poll-drain can detect that the to-be-approved tool
+        // is now persisted in the jsonl regardless of DEFERRED/STREAMING/IDLE.
+        if (item.kind === "tool_use") {
+            for (const c of item.calls) {
+                const sig = toolUseSig(c.name, c.input);
+                a.recentToolSigs.delete(sig); // re-insert at tail to keep recency order
+                a.recentToolSigs.set(sig, Date.now());
+                while (a.recentToolSigs.size > RECENT_SIGS_MAX) {
+                    const oldest = a.recentToolSigs.keys().next().value;
+                    if (oldest === undefined)
+                        break;
+                    a.recentToolSigs.delete(oldest);
+                }
+            }
+        }
+        // /goal mode overrides everything below: the session-scoped Stop hook
+        // self-drives the model with no terminal stop_reason, so turn_end never fires
+        // and brief-mode would swallow the entire run into the turn store (silent
+        // WeCom for the whole goal). Enter progress-streaming on the marker; while
+        // active, stream text + drop tool bubbles until the completing turn's
+        // turn_end. Placed before the brief short-circuit so goal wins over brief.
+        if (item.kind === "goal_start") {
+            enterGoalMode(a, item.condition);
+            return;
+        }
+        if (a.goalActive) {
+            handleGoalItem(a, item);
+            return;
+        }
+        // Brief 模式下没有活跃 turn 时, 任何 assistant 侧产出都补开一个无气泡 turn ——
+        // 覆盖 CLI 侧直接开的新一轮 (WeCom 没参与, 拿不到 frame) 与收口后的零星补写。
+        // user_text 只记下来当下一轮的 query, 不开 turn (CLI 敲字 ≠ 一定有回复)。
+        if (cfg.wrc.mirror.brief && !a.briefTurnId) {
+            if (item.kind === "user_text")
+                a.pendingBriefQuery = item.body;
+            else if (BRIEF_TURN_OPENERS.has(item.kind))
+                ensureBriefTurn(a);
+        }
+        // Usage snapshots never flow into WeCom bubbles — brief 分支下 handleBriefItem
+        // 会把它写进 turn store, 非 brief 下直接吞掉, 保持 onItem 主流程只处理有渲染
+        // 输出的 item 类型。
+        if (item.kind === "turn_usage" && !(cfg.wrc.mirror.brief && a.briefTurnId)) {
+            return;
+        }
+        // Brief mode 短路: 所有正常流/deferral/awaiting 全跳过, 只写入 turn store,
+        // 唯一发到群里的是 turn 结束时的 finish text (下文 handleBriefItem 处理)。
+        if (cfg.wrc.mirror.brief && a.briefTurnId) {
+            handleBriefItem(a, item);
+            return;
+        }
+        // 到这里已经过了 brief 分支; turn_usage 若还残留(brief=false 走上面早退,
+        // brief && briefTurnId 走 handleBriefItem), 逻辑上不可能, 兜底再吞一次让 TS
+        // 收窄类型 —— 下方 append/standalone 分支只处理带 body 的 item。
+        if (item.kind === "turn_usage")
+            return;
+        // tool_result 气泡推送开关。parseLine 现在无条件发出 tool_result (供 detail/turn
+        // 页消费); 非-brief 的所有气泡消费路径(deferred/awaiting/streaming/standalone)
+        // 在此统一 gate: includeToolResults=false 时不把 result 推进气泡, 与旧行为一致。
+        if (item.kind === "tool_result" && !cfg.wrc.mirror.includeToolResults)
+            return;
+        // Brief mode 短路: 所有正常流/deferral/awaiting 全跳过, 只写入 turn store,
+        // 唯一发到群里的是 turn 结束时的 finish text (下文 handleBriefItem 处理)。
+        if (cfg.wrc.mirror.brief && a.briefTurnId) {
+            handleBriefItem(a, item);
+            return;
+        }
+        if (a.outbound?.kind === "deferred") {
+            handleDeferredItem(a, item);
+            return;
+        }
+        // AWAITING_APPR 兜底: needsApproval 是 mirror 这一侧的预判, hook (pre-tool-use.sh)
+        // 那边在 permission_mode=auto/bypassPermissions/dontAsk 时直接放行, daemon 根本
+        // 收不到 /approve, 也就永远不会有 card 点击 → onApproved 永远不触发 → AWAITING_APPR
+        // 卡住, 后续 tool/text 全走 standalone fallback。这里只要看到任何新 item 到达就
+        // 说明 claude 已继续执行 (hook 必然已返回 / 根本没拦), 把状态提升回 STREAMING,
+        // 复用原 frame/streamId 让本轮回到打字机气泡。
+        if (a.outbound?.kind === "awaiting_appr") {
+            const { frame, streamId } = a.outbound;
+            a.outbound = undefined;
+            const s = openStream(a, frame, streamId);
+            a.liveStream = s;
+            log.info({ sessionId: a.sessionId, kind: item.kind, turnId: s.turnId }, "outbound: AWAITING_APPR → STREAMING (hook bypassed, item arrived)");
+        }
+        // Skill outputs (e.g. /model) always emit as standalone — never append to
+        // an active stream so the result is independently visible.
+        if (item.kind === "skill_output") {
+            enqueueStandalone(a, item.body);
+            return;
+        }
+        // Assistant turn truly ended (stop_reason terminal). Finalize the live
+        // bubble synchronously so it becomes quotable in WeCom without waiting
+        // for the next inbound or the 6-min hard timeout. No body to append.
+        if (item.kind === "turn_end") {
+            if (a.liveStream && !a.liveStream.closed) {
+                log.debug({ sessionId: a.sessionId, turnId: a.liveStream.turnId }, "turn_end → finalize");
+                void finalizeStream(a, a.liveStream);
+            }
+            return;
+        }
+        // CLI-side user line marks a turn boundary that did NOT come from WeCom.
+        // Close any open WeCom liveStream first so the new conversation gets its
+        // own bubble — otherwise the user's CLI exchange silently mutates the
+        // previous WeCom bubble (still within its 6min update window) and is
+        // invisible on the chat side.
+        if (item.kind === "user_text" && a.liveStream && !a.liveStream.closed) {
+            void finalizeStream(a, a.liveStream);
+        }
+        const s = a.liveStream;
+        if (s && !s.closed && !s.dead && !s.capped) {
+            // 规则 1: tool→FINAL_text 截断。仅当 text 是本 turn 的终态文本(line
+            // stop_reason ∈ end_turn/stop_sequence/max_tokens)且本流已出现过 tool
+            // 时, 把"最终答复"切到独立 standalone — WeCom 消息列表预览看到的就是答
+            // 案而不是中间 tool 噪声。中间过程的 text(final=false)保持 append, 多
+            // 轮 think→tool→think 不再被切碎。
+            if (item.kind === "text" && s.sawTool && item.final === true) {
+                void finalizeStream(a, s);
+                enqueueStandalone(a, item.body);
+                return;
+            }
+            const sep = s.acc ? "\n\n" : "";
+            const next = s.acc + sep + item.body;
+            if (next.length > STREAM_SOFT_CAP) {
+                s.acc = `${s.acc}${sep}…(超出 stream 容量上限，详情见"查看详情")`;
+                s.capped = true;
+            }
+            else {
+                s.acc = next;
+            }
+            if (item.kind !== "text") {
+                recordToolEntry(s, item);
+                s.sawTool = true;
+            }
+            log.debug({ sessionId: a.sessionId, turnId: s.turnId, kind: item.kind, accLen: s.acc.length }, "stream append");
+            scheduleFlush(s);
+            return;
+        }
+        log.info({ sessionId: a.sessionId, kind: item.kind, hasLive: !!s, closed: s?.closed, dead: s?.dead, capped: s?.capped }, "fallback standalone");
+        enqueueStandalone(a, item.body);
+    };
+    const resolveTarget = (override) => sanitizeId(override?.trim() || cfg.wrc.mirror.pushChat.trim() || cfg.defaultChat.trim());
+    // Detach an attachment: finalize any live stream, stop the tail, drop from indexes.
+    const detach = (a, reason) => {
+        if (a.migrationWatcher) {
+            a.migrationWatcher.cancel();
+            a.migrationWatcher = undefined;
+        }
+        if (a.outbound?.kind === "deferred")
+            clearTimeout(a.outbound.timer);
+        a.outbound = undefined;
+        if (a.softEnd) {
+            clearTimeout(a.softEnd);
+            a.softEnd = undefined;
+        }
+        while (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);
+        }
+        a.tail.stop();
+        bySessionId.delete(a.sessionId);
+        if (byTarget.get(a.target) === a)
+            byTarget.delete(a.target);
+        log.info({ sessionId: a.sessionId, target: a.target, reason }, "mirror detached");
+    };
+    // Click-to-detail URL for a tool_use id. Cached on the bridge so both
+    // attach() and migrateAttachment() share the same closure. Returns ""
+    // when disabled in config — renderLine then drops the markdown wrapping.
+    const detailUrlFor = (id) => cfg.daemon.detailLinksInMirror && id
+        ? buildDetailUrl(cfg.daemon.detailPublicBase, cfg.daemon.host, cfg.daemon.port, id)
+        : "";
+    const attach = ({ sessionId, jsonlPath, target: targetOverride, tmuxPane, tmuxSession, cwd, pendingCwd }) => {
+        const target = resolveTarget(targetOverride);
+        if (!target)
+            return { ok: false, reason: "no target chat (set wrc.mirror.pushChat or defaultChat, or pass target)" };
+        // Note: jsonlPath may not exist yet on the auto-spawn path — claude only
+        // creates its transcript after the first user input. The tail tolerates a
+        // missing file (existsSync gate at start, try/catch in drain) and the 1s
+        // poll picks it up the moment claude writes the first line.
+        // Replace any existing attach with the same sessionId or same target. The
+        // sessionId clash is the "/wrc again from same window" case; the target
+        // clash is "different window steals my WeCom chat" — both end the previous.
+        const prevBySid = bySessionId.get(sessionId);
+        if (prevBySid)
+            detach(prevBySid, "sessionId reattach");
+        const prevByTarget = byTarget.get(target);
+        // Carry over pending request only when caller didn't explicitly say
+        // otherwise. `undefined` (omitted) → carry from prev (re-attach case);
+        // `""` → explicit clear (newSession just consumed it); `"/foo"` → set.
+        const carryPending = pendingCwd !== undefined ? pendingCwd : (prevByTarget?.pendingCwd ?? "");
+        if (prevByTarget)
+            detach(prevByTarget, "target reassigned");
+        // Build the attachment first so the tail's onItem closure can capture it.
+        const a = {
+            sessionId,
+            jsonlPath,
+            target,
+            tmuxPane: (tmuxPane ?? "").trim(),
+            tmuxSession: (tmuxSession ?? "").trim(),
+            // Explicit cwd (spawn path) wins; otherwise derive from jsonl head so
+            // /wrc attaches inherit the bound session's real project dir instead of
+            // 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
+            standalonePending: Promise.resolve(),
+            recentToolSigs: new Map(),
+        };
+        a.tail = startMirrorTail({
+            jsonlPath,
+            log: log.child({ sub: "tail", sessionId }),
+            includeUser: cfg.wrc.mirror.includeUser,
+            includeTools: cfg.wrc.mirror.includeTools,
+            includeToolResults: cfg.wrc.mirror.includeToolResults,
+            toolResultMaxChars: cfg.wrc.mirror.toolResultMaxChars,
+            toolUseInlineMaxChars: cfg.wrc.mirror.toolUseInlineMaxChars,
+            isOwnInject,
+            isOwnAssistantSend,
+            onItem: (item) => onItem(a, item),
+            detailUrlFor,
+            sessionId,
+            target,
+            // Dialect comes from the transcript's own root, not defaultCli — that is
+            // what lets a claude session and a codebuddy session be mirrored at once.
+            normalizeLine: backendForPath(jsonlPath).normalizeTranscriptLine,
+        });
+        bySessionId.set(sessionId, a);
+        byTarget.set(target, a);
+        deps.store.set(target, {
+            sessionId,
+            jsonlPath,
+            tmuxSession: a.tmuxSession || undefined,
+            tmuxPane: a.tmuxPane || undefined,
+            cwd: a.runningCwd || undefined,
+            pendingCwd: a.pendingCwd || undefined,
+        });
+        log.info({ sessionId, jsonlPath, target, tmuxSession: a.tmuxSession, runningCwd: a.runningCwd, pendingCwd: a.pendingCwd, mirrors: bySessionId.size }, "mirror attached");
+        return { ok: true, sessionId, jsonlPath, target };
+    };
+    // ── Persistence: restore-from-store (lazy + boot) ────────────────────
+    const tmuxRun = (args) => new Promise((resolve) => {
+        const p = spawn("tmux", args, {
+            env: { ...process.env, PATH: augmentedPath(process.env.PATH) },
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        let out = "";
+        p.stdout?.on("data", (c) => (out += c.toString("utf8")));
+        p.on("error", () => resolve({ code: null, stdout: "" }));
+        p.on("close", (code) => resolve({ code, stdout: out }));
+    });
+    // Verify a paneId still exists. `display-message -t <paneId>` succeeds iff
+    // the pane is alive — and tmux pane ids monotonically increment within a
+    // server lifetime, so a freed id will not be silently reused. We don't need
+    // the session name, which matters because /wrc attaches capture only $TMUX_PANE.
+    const tmuxPaneAlive = async (paneId) => {
+        if (!paneId)
+            return false;
+        const r = await tmuxRun(["display-message", "-p", "-t", paneId, "#{pane_id}"]);
+        return r.code === 0 && r.stdout.trim() === paneId;
+    };
+    // Re-attach a stored binding for `principal`. Returns the resulting state, or
+    // undefined if the on-disk transcript is gone (in which case the entry is
+    // dropped so the next inbound flows through /new auto-spawn).
+    const restoreFromStore = async (principal) => {
+        const rec = deps.store.get(principal);
+        if (!rec)
+            return undefined;
+        let jsonlAbs = expandHome(rec.jsonlPath);
+        if (!existsSync(jsonlAbs)) {
+            // First: the SAME-sid transcript may have merely relocated to a sibling
+            // project dir (Claude Code EnterWorktree/ExitWorktree moved it while the
+            // daemon was down). Re-home onto it WITHOUT changing the sessionId — the
+            // tail then follows it natively. Must precede the latestJsonlForCwd heal,
+            // which would otherwise grab whatever session is newest in the original
+            // cwd's dir (usually a *different* chat) and cross-wire the mirror.
+            const owner = backendForPath(expandHome(rec.jsonlPath));
+            const relocated = findJsonlBySid(rec.sessionId, owner);
+            if (relocated) {
+                log.info({ principal, sessionId: rec.sessionId, from: rec.jsonlPath, to: relocated }, "mirror restore: sid relocated (worktree), re-homed");
+                rec.jsonlPath = relocated;
+                jsonlAbs = relocated;
+                deps.store.set(principal, rec);
+            }
+            else {
+                // Recorded session rotated out from under us — a `/clear` or native `/new`
+                // the daemon didn't record (e.g. it restarted while the /clear migration
+                // watcher was still open). The rotation left a newer jsonl in the same
+                // project dir; heal onto it instead of dropping the binding, else the
+                // chat silently loses all further responses. Fail-closed drop only when
+                // the project dir is truly empty.
+                const healed = latestJsonlForCwd(rec.cwd || cfg.wrc.cwd, owner);
+                if (!healed) {
+                    log.warn({ principal, jsonlPath: rec.jsonlPath }, "mirror restore: jsonl missing and no sibling, dropping entry");
+                    deps.store.drop(principal);
+                    return undefined;
+                }
+                log.warn({ principal, from: rec.sessionId, to: healed.sessionId }, "mirror restore: recorded jsonl gone, healed to latest in project dir");
+                rec.sessionId = healed.sessionId;
+                rec.jsonlPath = healed.jsonlPath;
+                jsonlAbs = healed.jsonlPath;
+                deps.store.set(principal, rec);
+            }
+        }
+        // Prefer the stored pane id and validate via display-message. Pane ids
+        // (`%N`) are monotonic per tmux server lifetime, so they're stable across
+        // daemon reloads as long as the tmux server didn't restart. With the
+        // shared `weclaude` session hosting many chats, listing panes by session
+        // name would mis-route to whichever window happens to be first — never
+        // do that. If the stored pane is dead, leave tmuxPane empty and let
+        // dispatch's respawn check reincarnate via `claude --resume <sid>`.
+        const storedPane = (rec.tmuxPane ?? "").trim();
+        const livePane = storedPane && (await tmuxPaneAlive(storedPane)) ? storedPane : "";
+        // Pane-cwd worktree re-home: the stored jsonl can EXIST yet be stale because
+        // the live pane entered/selected a git worktree, switching it to a DIFFERENT
+        // sessionId in a sibling project dir. Trust the pane's real cwd — if its
+        // project dir differs and holds a live session under another sid, bind that.
+        // Without this, two chats whose panes diverged into worktrees but still
+        // carry the old shared sid collide in bySessionId (attach → replace) and one
+        // is silently detached; that detached chat then never mirrors again. Runs at
+        // boot; the 3s drift follower maintains it thereafter.
+        if (livePane) {
+            const cwdRes = await tmuxRun(["display-message", "-p", "-t", livePane, "#{pane_current_path}"]);
+            const paneCwd = cwdRes.stdout.trim();
+            if (paneCwd) {
+                // Encode under the backend that owns the bound transcript — comparing
+                // with the primary dialect would report a phantom drift for every
+                // session belonging to a non-primary CLI.
+                const paneDir = projectDirFor(jsonlAbs, expandHome(paneCwd));
+                if (paneDir !== dirname(jsonlAbs)) {
+                    const live = liveSessionForCwd(paneCwd, backendForPath(jsonlAbs));
+                    if (live && live.sessionId !== rec.sessionId) {
+                        log.info({ principal, from: rec.sessionId, to: live.sessionId, paneCwd }, "mirror restore: pane in worktree, re-homed to live session");
+                        rec.sessionId = live.sessionId;
+                        rec.jsonlPath = live.jsonlPath;
+                        jsonlAbs = live.jsonlPath;
+                        rec.cwd = expandHome(paneCwd);
+                        deps.store.set(principal, rec);
+                    }
+                }
+            }
+        }
+        const r = attach({
+            sessionId: rec.sessionId,
+            jsonlPath: jsonlAbs,
+            target: principal,
+            tmuxPane: livePane,
+            tmuxSession: rec.tmuxSession ?? "",
+            cwd: rec.cwd,
+            pendingCwd: rec.pendingCwd,
+        });
+        if (!r.ok) {
+            log.warn({ principal, reason: r.reason }, "mirror restore: re-attach failed");
+            return undefined;
+        }
+        log.info({ principal, sessionId: rec.sessionId, livePane: livePane || "(spawn-mode)" }, "mirror restored from store");
+        return byTarget.get(principal);
+    };
+    // We re-attach lazily on demand too (see restoreFromStore in dispatch /
+    // hasMirrorTarget), but eager boot-restore makes outbound (tail → push) work
+    // even before any inbound arrives — e.g. claude finishes a long-running
+    // background task and writes assistant content to the jsonl while idle.
+    const persisted = deps.store.all();
+    const persistedKeys = Object.keys(persisted);
+    if (persistedKeys.length > 0) {
+        for (const principal of persistedKeys) {
+            void restoreFromStore(principal);
+        }
+    }
+    else if (cfg.wrc.mirror.sessionId.trim()) {
+        // Pinned-sessionId fallback: only honor when the store is empty (otherwise
+        // the persisted bindings already cover the right sessions).
+        const resolved = resolveSession(cfg, log);
+        if (resolved) {
+            const r = attach({ sessionId: resolved.sessionId, jsonlPath: resolved.jsonlPath });
+            if (!r.ok)
+                log.warn({ reason: r.reason }, "mirror: pinned auto-attach skipped");
+        }
+    }
+    else {
+        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).
+    const renderToolDetails = (tools) => {
+        const parts = [];
+        let i = 0;
+        for (const t of tools) {
+            i += 1;
+            const inputJson = t.input === undefined
+                ? "(no input)"
+                : (() => {
+                    try {
+                        return JSON.stringify(t.input, null, 2);
+                    }
+                    catch {
+                        return "(unrenderable)";
+                    }
+                })();
+            const result = t.result ?? "(no result captured)";
+            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));
+    };
+    const resolveToolDetail = (turnId) => {
+        evictTurns();
+        const r = turnRegistry.get(turnId);
+        if (!r)
+            return undefined;
+        return { target: r.target, markdown: renderToolDetails(r.tools) };
+    };
+    // ── /clear → session migration ──────────────────────────────────────
+    // After `/clear` claude rotates to a fresh sessionId on the very next user
+    // input. Detect the rotation by watching the project dir for a new .jsonl
+    // that didn't exist at /clear time and contains a non-empty user line, then
+    // re-target this attachment onto it.
+    const isClearCommand = (text) => {
+        const t = text.trim();
+        return t === "/clear" || t.startsWith("/clear ") || t.startsWith("/clear\n");
+    };
+    const listJsonls = (dir) => {
+        try {
+            return new Set(readdirSync(dir).filter((n) => n.endsWith(".jsonl")));
+        }
+        catch {
+            return new Set();
+        }
+    };
+    // Post-/clear identification: claude rotates the session IMMEDIATELY on
+    // /clear (not on next user input as the original design assumed) and writes
+    // the `/clear` command itself as the first non-meta user line of the brand-
+    // new jsonl. Match that signature to (a) confirm the file is a /clear-rotated
+    // child, (b) avoid mis-migrating onto an unrelated jsonl that some other
+    // claude process happened to create on the same cwd in our window.
+    const SLASH_CLEAR_USER_RE = /<command-name>\s*\/clear\s*<\/command-name>/;
+    const jsonlIsPostClearChild = (path) => {
+        try {
+            const fd = openSync(path, "r");
+            const size = statSync(path).size;
+            const cap = Math.min(size, 64 * 1024);
+            const buf = Buffer.alloc(cap);
+            readSync(fd, buf, 0, cap, 0);
+            closeSync(fd);
+            const text = buf.toString("utf8");
+            for (const line of text.split("\n")) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const j = normalizeForPath(path, JSON.parse(line));
+                    if (!j || j.type !== "user" || j.isMeta || j.isSidechain)
+                        continue;
+                    const c = j.message?.content;
+                    // codebuddy writes the caveat + /clear + stdout as sibling plain user
+                    // messages — skip the noise so the DECIDING line is the first real
+                    // one, same as Claude's isMeta-filtered stream.
+                    if (isLocalCommandNoise(c))
+                        continue;
+                    // First non-meta user line decides: /clear → match; anything else → reject.
+                    return typeof c === "string" && SLASH_CLEAR_USER_RE.test(c);
+                }
+                catch { /* partial line */ }
+            }
+        }
+        catch { /* unreadable */ }
+        return false;
+    };
+    // First non-meta user-line uuid of a transcript. A freshly resume-forked
+    // child (`claude --resume <sid>` interactive) is seeded with a copy of the
+    // parent transcript, so it carries a real user line the instant it appears —
+    // this distinguishes it from an empty just-touched jsonl. (We can't reuse the
+    // /clear signature: a resume fork's first user line is the actual prompt, not
+    // `/clear`.) Returns undefined for empty/garbled files.
+    const firstUserUuid = (path) => {
+        try {
+            const fd = openSync(path, "r");
+            const size = statSync(path).size;
+            const cap = Math.min(size, 256 * 1024);
+            const buf = Buffer.alloc(cap);
+            readSync(fd, buf, 0, cap, 0);
+            closeSync(fd);
+            for (const line of buf.toString("utf8").split("\n")) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const j = normalizeForPath(path, JSON.parse(line));
+                    if (j?.type === "user" && !j.isMeta && !j.isSidechain && !isLocalCommandNoise(j.message?.content) && typeof j.uuid === "string")
+                        return j.uuid;
+                }
+                catch { /* partial line */ }
+            }
+        }
+        catch { /* unreadable */ }
+        return undefined;
+    };
+    // startOffset semantics differ by caller: /clear passes 0 to replay the
+    // freshly-rotated jsonl (only holds the /clear line + new content); resume
+    // migration omits it (→ tail from EOF) because the fork file is seeded with
+    // the FULL prior transcript and replaying from 0 would re-dump it to WeCom.
+    const migrateAttachment = (a, newSessionId, newJsonlPath, startOffset) => {
+        const oldSessionId = a.sessionId;
+        const oldJsonlPath = a.jsonlPath;
+        a.tail.stop();
+        bySessionId.delete(oldSessionId);
+        a.sessionId = newSessionId;
+        a.jsonlPath = newJsonlPath;
+        bySessionId.set(newSessionId, a);
+        a.tail = startMirrorTail({
+            jsonlPath: newJsonlPath,
+            log: log.child({ sub: "tail", sessionId: newSessionId }),
+            includeUser: cfg.wrc.mirror.includeUser,
+            includeTools: cfg.wrc.mirror.includeTools,
+            includeToolResults: cfg.wrc.mirror.includeToolResults,
+            toolResultMaxChars: cfg.wrc.mirror.toolResultMaxChars,
+            toolUseInlineMaxChars: cfg.wrc.mirror.toolUseInlineMaxChars,
+            isOwnInject,
+            isOwnAssistantSend,
+            onItem: (item) => onItem(a, item),
+            detailUrlFor,
+            sessionId: newSessionId,
+            target: a.target,
+            startOffset,
+            // A migration can cross backends (rare, but the new jsonl is resolved by
+            // path, not by CLI) — re-derive the dialect from the destination.
+            normalizeLine: backendForPath(newJsonlPath).normalizeTranscriptLine,
+        });
+        deps.store.set(a.target, {
+            sessionId: newSessionId,
+            jsonlPath: newJsonlPath,
+            tmuxSession: a.tmuxSession || undefined,
+            tmuxPane: a.tmuxPane || undefined,
+            cwd: a.runningCwd || undefined,
+            pendingCwd: a.pendingCwd || undefined,
+        });
+        log.info({ target: a.target, oldSessionId, newSessionId, oldJsonlPath, newJsonlPath, startOffset }, "mirror migrated session");
+    };
+    // Watch the project dir for a new jsonl (not in `baseline`) that satisfies
+    // `isChild`, then re-bind the attachment onto it. Used by both /clear
+    // (predicate = first user line is /clear; replay from 0) and dead-pane resume
+    // (predicate = file has real user content; tail from EOF — the fork is seeded
+    // with full history). `startOffset` flows through to migrateAttachment.
+    const startMigrationWatcher = (a, baseline, isChild, startOffset) => {
+        if (a.migrationWatcher)
+            a.migrationWatcher.cancel(); // re-armed (e.g. /clear twice, or respawn during a pending watch)
+        const projectDir = dirname(a.jsonlPath);
+        // baseline is captured by the caller BEFORE inject/respawn runs — claude
+        // creates the rotated/forked jsonl while processing it, so a baseline taken
+        // here (post-inject) would already include it and migration would never fire.
+        const POLL_MS = 500;
+        const TIMEOUT_MS = 5 * 60_000; // generous: user may take a while to type
+        const t0 = Date.now();
+        let stopped = false;
+        let timer;
+        const tick = () => {
+            if (stopped)
+                return;
+            if (Date.now() - t0 > TIMEOUT_MS) {
+                log.warn({ target: a.target, sessionId: a.sessionId }, "mirror migration: timeout, giving up");
+                a.migrationWatcher = undefined;
+                return;
+            }
+            const current = listJsonls(projectDir);
+            const candidates = [];
+            for (const name of current)
+                if (!baseline.has(name))
+                    candidates.push(name);
+            // Pick newest-mtime candidate that has user content. Older candidates
+            // without content stay in the running until they accrue — never aborts.
+            const ranked = candidates
+                .map((n) => ({ n, mtime: (() => { try {
+                    return statSync(join(projectDir, n)).mtimeMs;
+                }
+                catch {
+                    return 0;
+                } })() }))
+                .sort((x, y) => y.mtime - x.mtime);
+            for (const c of ranked) {
+                const p = join(projectDir, c.n);
+                if (isChild(p)) {
+                    stopped = true;
+                    a.migrationWatcher = undefined;
+                    const newSid = c.n.replace(/\.jsonl$/, "");
+                    if (newSid !== a.sessionId)
+                        migrateAttachment(a, newSid, p, startOffset);
+                    return;
+                }
+            }
+            timer = setTimeout(tick, POLL_MS);
+        };
+        a.migrationWatcher = {
+            cancel: () => { stopped = true; if (timer)
+                clearTimeout(timer); },
+        };
+        log.info({ target: a.target, sessionId: a.sessionId, projectDir, baselineCount: baseline.size }, "mirror migration: watcher armed");
+        timer = setTimeout(tick, POLL_MS);
+    };
+    // A user who runs /clear (or restarts claude) directly in the live TUI forks
+    // the pane onto a NEW sid in the SAME project dir — invisible to both watchers
+    // above (startMigrationWatcher wants a daemon-injected new file; followPaneDrift
+    // wants a cross-dir move). The tail then sits on the dead old jsonl and the "…"
+    // bubble never updates. After every inject, if the bound jsonl stays silent
+    // while a same-dir sibling swallowed our exact injected text, rebind onto it —
+    // replaying from our message so the response is mirrored.
+    //
+    // The rebind is only safe because the fork lives under THIS chat's own pane.
+    // Three guards keep it from mis-migrating across the many sessions that
+    // legitimately share one project dir (the classic "串session"):
+    //   1. pane liveness — a dead pane means the fork premise is void (the
+    //      dead-pane respawn path owns that); never cross-rebind then.
+    //   2. pane cwd — the pane must still sit in the bound project dir; if it
+    //      drifted elsewhere, followPaneDrift is the right handler.
+    //   3. ownership — never adopt a sid another live mirror is already tailing;
+    //      a fingerprint hit on a concurrently-busy sibling is a false positive,
+    //      not our fork. A genuine TUI fork is a brand-new, unowned session.
+    // The fingerprint itself is lengthened (and its min-length raised) so short /
+    // common messages can't collide onto a stranger's transcript in the first place.
+    const armSilentForkRebind = (a, text) => {
+        if (a.migrationWatcher)
+            return; // don't race an in-flight watcher
+        if (!a.tmuxPane)
+            return; // spawn-mode: no pane to fork under
+        const stripped = text.replace(/\s+/gu, "");
+        if (stripped.length < 16)
+            return; // too short to fingerprint safely
+        const fp = stripped.slice(0, 120); // long contiguous run → collision-resistant
+        const dir = dirname(a.jsonlPath);
+        const boundPath = a.jsonlPath;
+        let baseSize = 0;
+        try {
+            baseSize = statSync(boundPath).size;
+        }
+        catch { /* fresh */ }
+        const POLL_MS = 700;
+        const TIMEOUT_MS = 25_000;
+        const t0 = Date.now();
+        let stopped = false;
+        let timer;
+        const reschedule = () => { timer = setTimeout(() => void tick(), POLL_MS); };
+        const tick = async () => {
+            if (stopped)
+                return;
+            if (Date.now() - t0 > TIMEOUT_MS) {
+                a.migrationWatcher = undefined;
+                return;
+            }
+            // Bound jsonl grew → our message landed in the right session; nothing to do.
+            try {
+                if (statSync(boundPath).size > baseSize) {
+                    a.migrationWatcher = undefined;
+                    return;
+                }
+            }
+            catch { /* */ }
+            // Guard 1+2: pane must be alive AND still in the bound project dir. One
+            // display-message gives both — it fails on a dead pane, and its cwd tells
+            // us whether the pane still belongs here.
+            const r = await tmuxRun(["display-message", "-p", "-t", a.tmuxPane, "#{pane_current_path}"]);
+            if (stopped)
+                return;
+            const paneCwd = r.code === 0 ? r.stdout.trim() : "";
+            if (!paneCwd) {
+                a.migrationWatcher = undefined;
+                return;
+            } // pane gone → dead-pane path owns it
+            const paneDir = projectDirFor(boundPath, expandHome(paneCwd));
+            if (paneDir !== dir) {
+                reschedule();
+                return;
+            } // pane drifted → followPaneDrift owns it
+            let names = [];
+            try {
+                names = readdirSync(dir).filter((n) => n.endsWith(".jsonl"));
+            }
+            catch { /* */ }
+            const boundName = boundPath.slice(dir.length + 1);
+            const ranked = names
+                .filter((n) => n !== boundName)
+                .map((n) => ({ n, m: (() => { try {
+                    return statSync(join(dir, n)).mtimeMs;
+                }
+                catch {
+                    return 0;
+                } })() }))
+                .sort((x, y) => y.m - x.m);
+            for (const c of ranked) {
+                const off = findInjectOffset(join(dir, c.n), fp);
+                if (off === undefined)
+                    continue;
+                const newSid = c.n.replace(/\.jsonl$/, "");
+                // Guard 3: a sid another live mirror already tails is that chat's
+                // session, not our fork — a fingerprint false positive. Skip it and
+                // keep scanning; a real fork is unowned.
+                const owner = bySessionId.get(newSid);
+                if (owner && owner !== a) {
+                    log.warn({ target: a.target, newSid, ownerTarget: owner.target }, "mirror: skip fork rebind — session owned by another mirror (fingerprint false positive)");
+                    continue;
+                }
+                stopped = true;
+                a.migrationWatcher = undefined;
+                if (newSid !== a.sessionId) {
+                    log.info({ target: a.target, oldSid: a.sessionId, newSid, off }, "mirror: silent same-dir fork, rebinding onto forked session");
+                    migrateAttachment(a, newSid, join(dir, c.n), off);
+                }
+                return;
+            }
+            reschedule();
+        };
+        a.migrationWatcher = { cancel: () => { stopped = true; if (timer)
+                clearTimeout(timer); } };
+        reschedule();
+    };
+    // ── Worktree / session drift follow ─────────────────────────────────
+    // An inject isn't the only way the live session under a pane changes:
+    // entering OR selecting a git worktree makes Claude Code switch the pane to a
+    // DIFFERENT sessionId in a sibling project dir (the worktree cwd encodes to
+    // its own dir). That's neither a same-sid rename (findJsonlBySid follows those
+    // with a continuous offset) nor an inject-triggered rotation (startMigration-
+    // Watcher catches those) — the old jsonl just goes quiet and the mirror tails
+    // a dead file. Poll each attached pane's real cwd; when it points at a
+    // different project dir whose live session has a different sid, migrate onto
+    // it. Tail from EOF (undefined startOffset): the worktree session already
+    // carries full history we don't want to re-dump to WeCom.
+    let paneDriftTicking = false;
+    const followPaneDrift = async () => {
+        if (paneDriftTicking)
+            return; // skip overlapping ticks (tmux call is async)
+        paneDriftTicking = true;
+        try {
+            const attachments = Array.from(byTarget.values()).filter((a) => a.tmuxPane);
+            if (attachments.length === 0)
+                return;
+            const r = await tmuxRun(["list-panes", "-a", "-F", "#{pane_id}\t#{pane_current_path}"]);
+            if (r.code !== 0)
+                return;
+            const paneCwd = new Map();
+            for (const line of r.stdout.split("\n")) {
+                const tab = line.indexOf("\t");
+                if (tab !== -1)
+                    paneCwd.set(line.slice(0, tab).trim(), line.slice(tab + 1).trim());
+            }
+            for (const a of attachments) {
+                if (a.migrationWatcher)
+                    continue; // inject-driven migration in flight
+                if (a.liveStream && !a.liveStream.closed)
+                    continue; // mid typewriter — don't yank the tail
+                const cwd = paneCwd.get(a.tmuxPane);
+                if (!cwd)
+                    continue; // pane gone
+                const paneDir = projectDirFor(a.jsonlPath, expandHome(cwd));
+                if (paneDir === dirname(a.jsonlPath))
+                    continue; // same project dir — no drift
+                const live = liveSessionForCwd(cwd, backendForPath(a.jsonlPath));
+                if (!live || live.sessionId === a.sessionId)
+                    continue; // empty dir, or same-sid rename (tail follows it)
+                a.runningCwd = expandHome(cwd); // migrateAttachment persists this to store
+                log.info({ target: a.target, pane: a.tmuxPane, fromDir: dirname(a.jsonlPath), toDir: paneDir, oldSid: a.sessionId, newSid: live.sessionId }, "mirror: pane drifted (worktree), following live session");
+                migrateAttachment(a, live.sessionId, live.jsonlPath);
+            }
+        }
+        catch (e) {
+            log.warn({ err: e.message }, "pane-drift follow tick failed");
+        }
+        finally {
+            paneDriftTicking = false;
+        }
+    };
+    const paneDriftTimer = setInterval(() => void followPaneDrift(), 3000);
+    // ── Cwd lifecycle ───────────────────────────────────────────────────
+    // Per-chat project path. Stored on the attachment (live) and persisted to
+    // mirror-attachments.json so /pwd survives reload. `pendingCwd` is the
+    // user-requested next cwd — applied only on /new (or /clear when it differs
+    // 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);
+    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 = [`📂 当前项目: \`${running}\``];
+        if (pending && pending !== running) {
+            lines.push(`下次切换: \`${pending}\` (使用 /new 或 /clear 生效)`);
+        }
+        lines.push("> 切换其他项目: 在对话中告诉 AI 调用 `cd` MCP 工具");
+        // 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");
+    };
+    const pushProjectInfo = (target) => {
+        const md = renderProjectInfo(target);
+        const a = byTarget.get(target);
+        if (a) {
+            sendStandalone(a, md);
+            return;
+        }
+        // No attachment (rare — newSession always re-attaches before pushing).
+        // Send via plain sendMessage so the user still gets the info.
+        const chatId = stripPrincipalPrefix(target);
+        void client
+            .sendMessage(chatId, { msgtype: "markdown", markdown: { content: withSessionTag(target, md) } })
+            .catch((e) => log.warn({ err: e.message, target }, "pushProjectInfo (no attach) failed"));
+    };
+    // Cwd is CHAT-SCOPED, not session-scoped: all sessions in the same chat
+    // (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.
+    const chatCwdFallback = (target) => {
+        const base = basePrincipalOf(target);
+        const baseA = byTarget.get(base);
+        const baseRec = deps.store.get(base);
+        return {
+            pending: (baseA?.pendingCwd?.trim()) || (baseRec?.pendingCwd?.trim()) || "",
+            running: (baseA?.runningCwd?.trim()) || (baseRec?.cwd?.trim()) || "",
+        };
+    };
+    // /new path: kill the old pane (so we don't leak orphan tmux windows) and
+    // spawn a fresh claude in pendingCwd ?? runningCwd ?? default. Returns the
+    // new sessionId/cwd so callers can render the user-facing reply.
+    const newSession = async (target, windowName, cli, opts) => {
+        const prev = byTarget.get(target);
+        // Resolution precedence (all chat-scoped except the running-cwd fallback):
+        //   base.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
+        // an already-spawned tagged pane on every base-cwd change.
+        const chat = chatCwdFallback(target);
+        const rec = !prev ? deps.store.get(target) : undefined;
+        // An explicit per-node cwd (graph spec) outranks every chat-scoped fallback:
+        // the point of declaring it is that this node lives in a different repo.
+        const eff = (opts?.cwd?.trim() ? expandHome(opts.cwd.trim()) : "") ||
+            chat.pending ||
+            (prev?.runningCwd?.trim()) ||
+            (rec?.cwd?.trim()) ||
+            chat.running ||
+            expandedDefaultCwd;
+        // Inherit the outgoing session's CLI when the caller didn't name one: a
+        // `/new` (or a /clear upgraded to /new) on a codebuddy-bound chat must stay
+        // on codebuddy rather than silently reverting to `defaultCli`. Inheritance
+        // is chat-scoped like cwd — a FIRST `/new #tag` has no record of its own,
+        // so it falls back to the base session's binding instead of `defaultCli`
+        // (otherwise a tagged sibling silently forks onto a different CLI).
+        const base = basePrincipalOf(target);
+        const baseBound = base === target ? undefined : byTarget.get(base)?.jsonlPath ?? deps.store.get(base)?.jsonlPath;
+        const boundPath = prev?.jsonlPath ?? rec?.jsonlPath ?? baseBound;
+        const effCli = cli ?? (boundPath ? backendForPath(expandHome(boundPath)).name : undefined);
+        if (prev?.tmuxPane) {
+            // Best-effort kill; ignore errors (pane may already be dead).
+            void tmuxRun(["kill-pane", "-t", prev.tmuxPane]);
+        }
+        if (prev)
+            detach(prev, "/new respawn");
+        const r = await spawnTmuxClaude({
+            cfg,
+            log: log.child({ sub: "new-session", target }),
+            windowName: windowName ?? target,
+            cwdOverride: eff,
+            cli: effCli,
+            model: opts?.model,
+        });
+        if (!r.ok)
+            return { ok: false, reason: r.reason };
+        const att = attach({
+            sessionId: r.sessionId,
+            jsonlPath: r.jsonlPath,
+            target,
+            tmuxPane: r.tmuxPane,
+            tmuxSession: r.tmuxSession,
+            cwd: r.cwd,
+            // Explicit "" clears any carried-over pending — it has just been applied.
+            pendingCwd: "",
+        });
+        if (!att.ok)
+            return { ok: false, reason: att.reason };
+        // 首条注入吃冷时序(injectText 走 /mirror/spawn 时已经硬编码 freshSpawn:true,
+        // dispatch 这条隐式建会话的路径此前漏了)。
+        const spawned = byTarget.get(target);
+        if (spawned)
+            spawned.justSpawned = true;
+        // Clear the chat's pendingCwd on the BASE record too — the queued switch
+        // has just been consumed by this respawn. Without this, a subsequent /new
+        // #other would re-apply the same cd and diverge from user intent.
+        if (base !== target) {
+            const baseA = byTarget.get(base);
+            if (baseA?.pendingCwd) {
+                baseA.pendingCwd = "";
+                deps.store.set(base, {
+                    sessionId: baseA.sessionId,
+                    jsonlPath: baseA.jsonlPath,
+                    tmuxSession: baseA.tmuxSession || undefined,
+                    tmuxPane: baseA.tmuxPane || undefined,
+                    cwd: baseA.runningCwd || undefined,
+                    pendingCwd: undefined,
+                });
+            }
+            else {
+                const baseRec = deps.store.get(base);
+                if (baseRec?.pendingCwd)
+                    deps.store.set(base, { ...baseRec, pendingCwd: undefined });
+            }
+        }
+        pushProjectInfo(target);
+        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).
+        const chat = chatCwdFallback(target);
+        const pending = chat.pending;
+        const a = byTarget.get(target);
+        if (a)
+            return { runningCwd: a.runningCwd || expandedDefaultCwd, pendingCwd: pending, defaultCwd: expandedDefaultCwd };
+        const rec = deps.store.get(target);
+        if (rec)
+            return { runningCwd: rec.cwd?.trim() || expandedDefaultCwd, pendingCwd: pending, defaultCwd: expandedDefaultCwd };
+        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".
+    const setPendingCwd = (target, cwd) => {
+        const trimmed = (cwd ?? "").trim();
+        if (!trimmed)
+            return { ok: false, reason: "empty cwd", runningCwd: "", pendingCwd: "" };
+        const expanded = expandHome(trimmed);
+        if (!expanded.startsWith("/"))
+            return { ok: false, reason: "cwd must be absolute (or start with ~)", runningCwd: "", pendingCwd: "" };
+        const base = basePrincipalOf(target);
+        const callerA = byTarget.get(target);
+        const callerRunning = callerA?.runningCwd?.trim() || deps.store.get(target)?.cwd?.trim() || expandedDefaultCwd;
+        const baseA = byTarget.get(base);
+        if (baseA) {
+            baseA.pendingCwd = expanded;
+            deps.store.set(base, {
+                sessionId: baseA.sessionId,
+                jsonlPath: baseA.jsonlPath,
+                tmuxSession: baseA.tmuxSession || undefined,
+                tmuxPane: baseA.tmuxPane || undefined,
+                cwd: baseA.runningCwd || undefined,
+                pendingCwd: baseA.pendingCwd || undefined,
+            });
+            log.info({ target, base, runningCwd: callerRunning, pendingCwd: expanded }, "setPendingCwd (chat-scoped, live base)");
+            return { ok: true, runningCwd: callerRunning, pendingCwd: expanded };
+        }
+        const baseRec = deps.store.get(base);
+        if (baseRec) {
+            deps.store.set(base, { ...baseRec, pendingCwd: expanded });
+            log.info({ target, base, runningCwd: callerRunning, pendingCwd: expanded }, "setPendingCwd (chat-scoped, persisted base)");
+            return { ok: true, runningCwd: callerRunning, pendingCwd: expanded };
+        }
+        // No base binding yet (caller is a tagged session created before any
+        // default session existed). Fall back to writing on the caller's own
+        // record so the pending switch isn't lost — the next default /new will
+        // then inherit via chatCwdFallback and normalize onto the base.
+        if (callerA) {
+            callerA.pendingCwd = expanded;
+            deps.store.set(target, {
+                sessionId: callerA.sessionId,
+                jsonlPath: callerA.jsonlPath,
+                tmuxSession: callerA.tmuxSession || undefined,
+                tmuxPane: callerA.tmuxPane || undefined,
+                cwd: callerA.runningCwd || undefined,
+                pendingCwd: callerA.pendingCwd || undefined,
+            });
+            log.info({ target, runningCwd: callerA.runningCwd, pendingCwd: callerA.pendingCwd }, "setPendingCwd (fallback: no base, wrote to caller)");
+            return { ok: true, runningCwd: callerA.runningCwd, pendingCwd: callerA.pendingCwd };
+        }
+        const callerRec = deps.store.get(target);
+        if (callerRec) {
+            deps.store.set(target, { ...callerRec, pendingCwd: expanded });
+            log.info({ target, runningCwd: callerRec.cwd, pendingCwd: expanded }, "setPendingCwd (fallback: no base, wrote to caller persist)");
+            return { ok: true, runningCwd: callerRec.cwd?.trim() || expandedDefaultCwd, pendingCwd: expanded };
+        }
+        return { ok: false, reason: "no mirror binding for target — send a message in the WeCom chat first", runningCwd: "", pendingCwd: "" };
+    };
+    // ── Peer graph (sibling sessions of one chat) ────────────────────────
+    // A chat's sessions are exactly the keys sharing its base principal: the
+    // 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 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();
+    };
+    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 || "");
+    // Busy ≡ the pane is showing an interrupt hint. A dead or unbound pane is
+    // reported idle, not busy: "nothing is running there" is the truthful answer
+    // and it keeps a graph step from blocking forever on a session that vanished.
+    const paneBusy = async (pane) => !!pane && (await tmuxPaneAlive(pane)) && paneIsBusy(await capturePaneTail(pane, 12));
+    const isBusy = (target) => paneBusy(paneOf(target));
+    const lastText = (target) => {
+        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);
+    };
+    // Capture a few extra rows then compact away the TUI's blank padding, so
+    // `rows` counts lines the user actually cares about.
+    const peekPane = async (target, rows = 24) => {
+        const pane = paneOf(target);
+        if (!pane)
+            return { ok: false, reason: "no tmux pane bound for target" };
+        if (!(await tmuxPaneAlive(pane)))
+            return { ok: false, reason: "tmux pane no longer alive — the session needs /new or a respawn" };
+        const raw = await capturePaneTail(pane, Math.max(8, rows) + 12);
+        return { ok: true, pane: compactPane(raw, rows), busy: paneIsBusy(raw) };
+    };
+    return {
+        attach,
+        peers,
+        peekPane,
+        isBusy,
+        lastText,
+        status: () => {
+            const list = Array.from(bySessionId.values()).map((a) => ({
+                sessionId: a.sessionId,
+                jsonlPath: a.jsonlPath,
+                target: a.target,
+            }));
+            // Keep a single-attach view for back-compat; first entry wins when there's
+            // exactly one mirror, callers iterating `mirrors` get the full picture.
+            const first = list[0];
+            return first
+                ? { attached: true, mirrors: list, sessionId: first.sessionId, jsonlPath: first.jsonlPath, target: first.target }
+                : { attached: false, mirrors: [] };
+        },
+        resolveToolDetail,
+        hasMirrorTarget: (principal) => {
+            if (byTarget.has(principal))
+                return true;
+            // Lazy: a persisted binding counts as "attached" if its transcript is
+            // still on disk. The actual re-attach happens on dispatch (async).
+            const rec = deps.store.get(principal);
+            if (!rec)
+                return false;
+            return existsSync(expandHome(rec.jsonlPath));
+        },
+        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
+            // 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.
+            const live = bySessionId.get(sessionId)?.target;
+            if (live)
+                return live;
+            const all = deps.store.all();
+            for (const [target, rec] of Object.entries(all)) {
+                if (rec.sessionId === sessionId)
+                    return target;
+            }
+            return undefined;
+        },
+        targetForPane: (tmuxPane) => {
+            const pane = (tmuxPane ?? "").trim();
+            if (!pane)
+                return undefined;
+            for (const a of bySessionId.values()) {
+                if (a.tmuxPane === pane)
+                    return a.target;
+            }
+            for (const [target, rec] of Object.entries(deps.store.all())) {
+                if ((rec.tmuxPane ?? "") === pane)
+                    return target;
+            }
+            return undefined;
+        },
+        terminateLiveStream: (sessionId) => {
+            const a = bySessionId.get(sessionId);
+            if (!a)
+                return;
+            if (a.liveStream && !a.liveStream.closed) {
+                log.info({ sessionId, turnId: a.liveStream.turnId }, "approval click — terminating liveStream");
+                void finalizeStream(a, a.liveStream);
+            }
+            // Promote AWAITING_APPR → STREAMING on any approval click (allow / deny /
+            // allow_window — claude resumes after each, producing tool_result + text
+            // that need a stream destination). If frame is stale (>~6min from inbound),
+            // the first flushStream will reject, mark s.dead=true, and subsequent items
+            // route to standalone via the existing :1206 fall-through. Self-healing.
+            if (a.outbound?.kind === "awaiting_appr") {
+                const { frame, streamId } = a.outbound;
+                a.outbound = undefined;
+                const s = openStream(a, frame, streamId);
+                a.liveStream = s;
+                log.info({ sessionId, turnId: s.turnId }, "outbound: AWAITING_APPR → STREAMING (approved)");
+            }
+        },
+        // 解决"卡片先于思考过程到达 WeCom"的赛跑: hook 触发的 /approve 直接走
+        // client.sendMessage 发卡, 而 mirror 这条管道里同一 turn 的 text/tool_use 还
+        // 可能卡在三处 — DEFERRED 的 buf、standaloneBuf 的 3s 防抖、liveStream 的
+        // 250ms flush。逐一强制 drain, 再 await standalonePending FIFO, 让发卡前 mirror
+        // 已经把"为什么发这张卡"推完。
+        flushBeforeCard: async (sessionId, expect) => {
+            const a = bySessionId.get(sessionId);
+            if (!a)
+                return;
+            // 1) fs.watch 通常即时, 但本调用是发卡前最后一道屏障 — 主动拽一次 tail,
+            //    把刚落盘的 assistant 行(可能含 text + tool_use)立刻喂给 onItem。
+            //    若 caller 给了 expect, 进一步轮询 drain 直到对应 tool_use 落盘 —
+            //    Claude Code 的 jsonl 写入相对 hook fire 有 tens-to-hundreds ms 的
+            //    异步抖动, 单次 drain 经常抓空, 最终用户先看到卡再看到为什么。
+            const expectSig = expect ? toolUseSig(expect.toolName, expect.toolInput) : "";
+            if (expectSig) {
+                const deadline = Date.now() + cfg.wrc.mirror.flushBeforeCardWaitMs;
+                let polls = 0;
+                while (Date.now() < deadline) {
+                    try {
+                        a.tail.drain();
+                    }
+                    catch (e) {
+                        log.warn({ sessionId, err: e.message }, "flushBeforeCard tail drain failed");
+                    }
+                    if (a.recentToolSigs.has(expectSig))
+                        break;
+                    polls++;
+                    await sleepMs(50);
+                }
+                if (!a.recentToolSigs.has(expectSig)) {
+                    log.warn({ sessionId, polls, toolName: expect?.toolName }, "flushBeforeCard wait timed out — sending card without sig confirm");
+                }
+                else if (polls > 0) {
+                    log.info({ sessionId, polls, toolName: expect?.toolName }, "flushBeforeCard waited for tool_use to materialize");
+                }
+            }
+            else {
+                try {
+                    a.tail.drain();
+                }
+                catch (e) {
+                    log.warn({ sessionId, err: e.message }, "flushBeforeCard tail drain failed");
+                }
+            }
+            // 1.5) 门控 tool_use 始终没在 jsonl 落盘 → CC 把整条 tool-terminated turn 攒着
+            //     等工具 resolve 才 flush(而工具正卡在这张卡上), 前言此刻既不在 jsonl 也
+            //     不在 hook 的 transcript_tail 里, 只剩活着的 pane 有。抠出来先推, 稍后
+            //     jsonl 落盘 tail 出来的同一条由 isOwnAssistantSend 抑制。
+            const sigConfirmed = expectSig !== "" && a.recentToolSigs.has(expectSig);
+            if (expect && !sigConfirmed) {
+                await sendPanePreamble(a);
+            }
+            // 2) DEFERRED 状态如果还在 buffering(needsApproval 因任何原因没触发就走到这),
+            //    这里手动提升 → 立刻把 buf 当 standalone 推出, 进入 AWAITING_APPR。
+            if (a.outbound?.kind === "deferred" && a.outbound.buf.length > 0) {
+                promoteToStandalone(a);
+            }
+            // 3) standalone 防抖里 (3s 默认) 还压着的合并文案 — 强制立刻发。
+            if (a.standaloneBuf) {
+                clearTimeout(a.standaloneBuf.timer);
+                flushStandalone(a);
+            }
+            // 4) liveStream 半成品: 当前 acc 里有内容但还没 flush 出去 — 同步刷一刀,
+            //    保留 stream 不 finalize (后续 tool_result 还要继续 append 同一气泡)。
+            const ls = a.liveStream;
+            if (ls && !ls.closed && !ls.dead && ls.acc && ls.acc !== ls.lastSent) {
+                if (ls.flushTimer) {
+                    clearTimeout(ls.flushTimer);
+                    ls.flushTimer = undefined;
+                }
+                await flushStream(ls);
+            }
+            // 5) 上面的 sendStandalone 都串在 standalonePending FIFO 上, 等它把 WeCom
+            //    投递落地, 才算前奏到位 — 这步是关键, 确保返回时卡片可以安心发。
+            try {
+                await a.standalonePending;
+            }
+            catch {
+                // 队列内单条失败已在 sendStandalone 里 warn 过, 这里吞掉, 不阻塞发卡。
+            }
+        },
+        injectText: async (target, text) => {
+            // Lazy restore, same as dispatch: a peer session that hasn't been talked
+            // to in this process lifetime (or any session after a reload) has an empty
+            // in-memory slot but a perfectly good persisted binding. Without this, an
+            // agent driving a cold sibling gets "not attached" for a live pane.
+            const a = byTarget.get(target) ?? (await restoreFromStore(target));
+            if (!a)
+                return { ok: false, reason: "no mirror attached for target" };
+            if (!text.trim())
+                return { ok: false, reason: "empty text" };
+            // Pre-record so the tail's user-line emission is suppressed by the
+            // recentInjects dedupe (otherwise the user sees their own demo prompt
+            // echoed back as a quoted bubble).
+            rememberInject(text);
+            const sid = a.sessionId;
+            const paneAlive = a.tmuxPane ? await tmuxPaneAlive(a.tmuxPane) : false;
+            if (!paneAlive) {
+                log.warn({ target, sessionId: sid, oldPane: a.tmuxPane }, "injectText: pane not alive, respawning");
+                // Same resume-fork hazard as dispatch: snapshot before spawn, re-bind
+                // onto the forked jsonl once it appears (EOF offset — fork is seeded).
+                const resumeBaseline = listJsonls(dirname(a.jsonlPath));
+                const r = await spawnTmuxClaude({ cfg, log: log.child({ sub: "respawn-init", sessionId: sid }), resumeSessionId: sid, windowName: tagOfTarget(target) || target, cwdOverride: a.runningCwd, cli: backendForPath(a.jsonlPath).name });
+                if (!r.ok || !r.tmuxPane)
+                    return { ok: false, reason: `respawn failed: ${r.reason ?? "unknown"}` };
+                a.tmuxPane = r.tmuxPane;
+                a.tmuxSession = r.tmuxSession ?? a.tmuxSession;
+                if (r.cwd)
+                    a.runningCwd = r.cwd;
+                deps.store.set(target, { sessionId: sid, jsonlPath: a.jsonlPath, tmuxSession: a.tmuxSession, tmuxPane: a.tmuxPane, cwd: a.runningCwd || undefined, pendingCwd: a.pendingCwd || undefined });
+                startMigrationWatcher(a, resumeBaseline, (p) => firstUserUuid(p) !== undefined);
+            }
+            // freshSpawn: true — the pane was just minted by /mirror/spawn, the TUI
+            // is still warming up so the verifier in injectViaTmux needs the slack.
+            return await inject({
+                text, images: [], cfg, log: log.child({ principal: target, sessionId: sid, sub: "init-demo" }),
+                sessionId: sid, jsonlPath: a.jsonlPath, tmuxTarget: a.tmuxPane, freshSpawn: true,
+            });
+        },
+        interruptPane: async (target) => {
+            const a = byTarget.get(target);
+            if (!a)
+                return { ok: false, reason: "no mirror attached for target" };
+            if (!a.tmuxPane)
+                return { ok: false, reason: "no live tmux pane (spawn-mode attachment)" };
+            const alive = await tmuxPaneAlive(a.tmuxPane);
+            if (!alive)
+                return { ok: false, reason: "tmux pane no longer alive" };
+            const r = await tmuxRun(["send-keys", "-t", a.tmuxPane, "Escape"]);
+            if (r.code !== 0)
+                return { ok: false, reason: `send-keys Escape failed: ${r.stdout.slice(-200) || r.code}` };
+            log.info({ target, sessionId: a.sessionId, pane: a.tmuxPane }, "mirror /stop — Esc sent to pane");
+            return { ok: true };
+        },
+        submitPane: async (target) => {
+            const a = byTarget.get(target);
+            if (!a)
+                return { ok: false, reason: "no mirror attached for target" };
+            if (!a.tmuxPane)
+                return { ok: false, reason: "no live tmux pane (spawn-mode attachment)" };
+            const alive = await tmuxPaneAlive(a.tmuxPane);
+            if (!alive)
+                return { ok: false, reason: "tmux pane no longer alive" };
+            const r = await tmuxRun(["send-keys", "-t", a.tmuxPane, "Enter"]);
+            if (r.code !== 0)
+                return { ok: false, reason: `send-keys Enter failed: ${r.stdout.slice(-200) || r.code}` };
+            log.info({ target, sessionId: a.sessionId, pane: a.tmuxPane }, "mirror /n — Enter sent to pane");
+            return { ok: true };
+        },
+        revealPane: async (target) => {
+            // paneOf (not byTarget.get) so a cold binding surviving only in the
+            // persisted store can still be revealed after a daemon reload.
+            const pane = paneOf(target);
+            if (!pane)
+                return { ok: false, reason: "no tmux pane bound for target" };
+            if (!(await tmuxPaneAlive(pane)))
+                return { ok: false, reason: "tmux pane no longer alive — the session needs /new or a respawn" };
+            // Only clients already attached to the pane's OWN session are candidates:
+            // switching a client that sits on an unrelated session would yank the
+            // user's other terminal window into weclaude. Most-recently-active wins —
+            // switch-client with no -c is ambiguous under multiple clients.
+            const s = await tmuxRun(["display-message", "-p", "-t", pane, "#{session_name}"]);
+            const sess = s.stdout.trim() || cfg.wrc.tmuxPrefix;
+            const clients = await tmuxRun(["list-clients", "-t", sess, "-F", "#{client_activity} #{client_name}"]);
+            const best = clients.stdout.split("\n").filter(Boolean)
+                .map((l) => { const i = l.indexOf(" "); return { act: Number(l.slice(0, i)), name: l.slice(i + 1) }; })
+                .sort((x, y) => y.act - x.act)[0]?.name;
+            if (!best) {
+                // Nothing to switch; tell the user how to get a client onto the session.
+                return { ok: false, reason: `没有 attach 到 \`${sess}\` 的 tmux 客户端。先在终端执行: \`tmux attach -t ${sess}\`` };
+            }
+            // A pane target pulls session + window selection along with it.
+            const r = await tmuxRun(["switch-client", "-c", best, "-t", pane]);
+            if (r.code !== 0)
+                return { ok: false, reason: `switch-client failed: ${r.stdout.slice(-200) || r.code}` };
+            log.info({ target, pane, client: best }, "mirror /reveal — tmux client switched");
+            return { ok: true };
+        },
+        getCwd,
+        setPendingCwd,
+        newSession,
+        shutdown: () => {
+            clearInterval(paneDriftTimer);
+            for (const a of bySessionId.values()) {
+                if (a.outbound?.kind === "deferred")
+                    clearTimeout(a.outbound.timer);
+                a.outbound = undefined;
+                if (a.liveStream && !a.liveStream.closed)
+                    void finalizeStream(a, a.liveStream);
+                a.tail.stop();
+            }
+            bySessionId.clear();
+            byTarget.clear();
+        },
+        dispatch: async ({ principal, text, images, frame, streamId }) => {
+            // Route by inbound principal — the WeCom chat the user just messaged us
+            // from is the same string we registered as `target` on attach. After a
+            // daemon reload the in-memory map is empty; restore from the persisted
+            // store before giving up so the conversation continues in the prior
+            // claude session instead of getting "not attached".
+            let a = byTarget.get(principal);
+            if (!a)
+                a = await restoreFromStore(principal);
+            if (!a) {
+                try {
+                    await client.replyStream(frame, streamId, withSessionTag(principal, "[weclaude] wecom remote control not attached — run `/wrc` inside the target Claude session"), true);
+                }
+                catch {
+                    /* ignore */
+                }
+                return;
+            }
+            // Finalize prior live stream (if any) so this new turn renders into its
+            // own message bubble. Then open a fresh stream tied to the new frame and
+            // ack immediately so WeCom doesn't time out while inject queues.
+            const armMigration = isClearCommand(text);
+            // `/model <arg>` opens the TUI picker preselected on the match — the
+            // switch only lands after a confirm Enter. Bare `/model` is excluded:
+            // auto-confirming it would just re-pick the current model.
+            const isModelSwitch = /^\/model\s+\S/.test(text.trim());
+            // 任意 slash 命令 (/context, /cost, /status…): 产物走 skill_output standalone,
+            // 详情链接是纯噪声 —— brief 起 turn 时不推链接。
+            const isSlash = /^\/[a-z]/i.test(text.trim());
+            // Auto-upgrade /clear → /new when the user has queued a project switch:
+            // a plain /clear would only rotate sessionId in the same pane, which sits
+            // in the OLD cwd. Killing+respawning is the only way to honor the switch.
+            // pendingCwd is chat-scoped, so read it via the shared fallback rather
+            // than from this attachment's own record (which is now always empty for
+            // tagged sessions).
+            const pending = chatCwdFallback(a.target).pending;
+            if (armMigration && pending && pending !== a.runningCwd) {
+                if (a.liveStream && !a.liveStream.closed)
+                    await finalizeStream(a, a.liveStream);
+                log.info({ target: a.target, runningCwd: a.runningCwd, pendingCwd: pending }, "/clear upgraded to /new (cwd switch)");
+                // Prefer the tag suffix as tmux window name when present (matches
+                // /new #tag behavior), fall back to the full target for untagged.
+                const tag = tagOfTarget(a.target);
+                const r = await newSession(a.target, tag || a.target);
+                if (!r.ok) {
+                    try {
+                        await client.replyStream(frame, streamId, withSessionTag(a.target, `[mirror] 切换失败: ${r.reason ?? "unknown"}`), true);
+                    }
+                    catch { /* ignore */ }
+                }
+                return;
+            }
+            // Snapshot the project dir BEFORE inject runs. Claude rotates the session
+            // synchronously while processing /clear and writes the rotated jsonl
+            // immediately — capturing baseline post-inject would already include it,
+            // and the watcher would never see a "new" candidate (the bug this fixes).
+            const preClearBaseline = armMigration ? listJsonls(dirname(a.jsonlPath)) : undefined;
+            // 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.
+            if (a.outbound) {
+                if (a.outbound.kind === "deferred")
+                    clearTimeout(a.outbound.timer);
+                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);
+            }
+            // /clear produces no assistant output; opening a stream would leave a
+            // stale "…" + quoted-user bubble in WeCom. Skip the stream entirely on
+            // success path; only surface a terse "clean" if inject fails.
+            if (a.liveStream && !a.liveStream.closed) {
+                await finalizeStream(a, a.liveStream);
+            }
+            // Three paths from here:
+            //  • armMigration → s undefined, no defer (existing /clear behavior)
+            //  • outboundDeferMs > 0 → DEFERRED slot; stream opens later via promote
+            //  • outboundDeferMs === 0 → eager openStream + "…" ack (legacy behavior)
+            const brief = cfg.wrc.mirror.brief && !armMigration;
+            const eagerOpen = !armMigration && !brief && cfg.wrc.mirror.outboundDeferMs <= 0;
+            const s = eagerOpen ? openStream(a, frame, streamId) : undefined;
+            if (s) {
+                a.liveStream = s;
+                try {
+                    await client.replyStream(frame, streamId, withSessionTag(a.target, "…"), false);
+                }
+                catch (e) {
+                    log.warn({ sessionId: a.sessionId, err: e.message }, "stream initial ack failed");
+                }
+            }
+            if (brief) {
+                // 挂 loading 气泡并起新 turn (上一 turn 还在跑则排队, 由它收口时放行)。
+                // 后续 onItem 走 handleBriefItem, 不再走 stream / defer 路径。
+                await startBriefTurn(a, frame, streamId, isSlash, text);
+            }
+            else if (!armMigration && !eagerOpen) {
+                enterDeferred(a, frame, streamId);
+            }
+            const sid = a.sessionId;
+            await enqueue(sid, async () => {
+                if (s && s.closed)
+                    return; // (eager path) superseded by a newer dispatch
+                // Always reincarnate when no live pane: covers (a) pane closed between
+                // turns, (b) daemon reload restored a binding without a live pane, AND
+                // (c) /wrc'd from a non-tmux context (no tmuxSession ever stored) —
+                // that last case used to permanently lock the chat into spawn-mode.
+                // If respawn fails, fall through to spawn-mode inject for THIS turn
+                // but DON'T erase tmuxSession from store — next inbound will retry,
+                // making the system self-healing instead of one-failure-permanent.
+                const paneAlive = a.tmuxPane ? await tmuxPaneAlive(a.tmuxPane) : false;
+                let freshSpawn = a.justSpawned === true;
+                a.justSpawned = false;
+                if (!paneAlive) {
+                    log.warn({ target: a.target, sessionId: sid, oldPane: a.tmuxPane, oldSession: a.tmuxSession }, "mirror: no live tmux pane, respawning");
+                    // Interactive `claude --resume <sid>` does NOT keep appending to the
+                    // same <sid>.jsonl — it FORKS to a fresh <newSid>.jsonl seeded with a
+                    // copy of the transcript. Our tail stays bound to the OLD, now-frozen
+                    // jsonl, so the chat would go silent after respawn. Snapshot the
+                    // project dir BEFORE spawn so the fork surfaces as a new file the
+                    // watcher can re-bind onto. Skip when /clear already owns a watcher
+                    // for this turn (its migration supersedes the fork).
+                    const resumeBaseline = !armMigration ? listJsonls(dirname(a.jsonlPath)) : undefined;
+                    // Respawn in the binding's runningCwd (pendingCwd doesn't apply to a
+                    // mid-turn reincarnation — only /new and /clear-with-pending swap cwd).
+                    const r = await spawnTmuxClaude({ cfg, log: log.child({ sub: "respawn", sessionId: sid }), resumeSessionId: sid, windowName: tagOfTarget(a.target) || a.target, cwdOverride: a.runningCwd, cli: backendForPath(a.jsonlPath).name });
+                    if (r.ok && r.tmuxPane && r.tmuxSession) {
+                        a.tmuxPane = r.tmuxPane;
+                        a.tmuxSession = r.tmuxSession;
+                        if (r.cwd)
+                            a.runningCwd = r.cwd;
+                        freshSpawn = true;
+                        deps.store.set(a.target, {
+                            sessionId: sid,
+                            jsonlPath: a.jsonlPath,
+                            tmuxSession: a.tmuxSession,
+                            tmuxPane: a.tmuxPane,
+                            cwd: a.runningCwd || undefined,
+                            pendingCwd: a.pendingCwd || undefined,
+                        });
+                        log.info({ target: a.target, sessionId: sid, newPane: a.tmuxPane, newSession: a.tmuxSession }, "mirror: tmux respawned");
+                        // Re-bind onto the resume fork once it appears (EOF offset: the fork
+                        // already holds the full prior transcript — replaying from 0 would
+                        // re-dump it). If --resume happens to keep the same jsonl, no new
+                        // file appears, the watcher times out harmlessly, and the existing
+                        // tail keeps working — safe under either behavior.
+                        if (resumeBaseline)
+                            startMigrationWatcher(a, resumeBaseline, (p) => firstUserUuid(p) !== undefined);
+                    }
+                    else {
+                        // Drop only the stale pane id; keep tmuxSession (if any) so the
+                        // store still reflects "user wanted tmux" — next turn retries.
+                        log.error({ reason: r.reason }, "mirror: tmux respawn failed, this turn falls back to spawn-mode");
+                        a.tmuxPane = "";
+                    }
+                }
+                // Remember BEFORE inject (not after success): a fresh-spawn paste can
+                // submit late, after our verifier reports failure. The tail still
+                // surfaces the user's text, and without a pre-recorded entry the
+                // dedupe filter wouldn't suppress it — user's chat msg gets echoed
+                // back as a quoted bubble. Recording up front fixes that.
+                rememberInject(text);
+                const r = await inject({
+                    text, images, cfg, log: log.child({ principal, sessionId: sid }),
+                    sessionId: sid, jsonlPath: a.jsonlPath, tmuxTarget: a.tmuxPane, freshSpawn,
+                });
+                if (!r.ok) {
+                    if (s) {
+                        s.acc = s.acc ? `${s.acc}\n\n[mirror] ✗ ${r.reason ?? "failed"}` : `[mirror] ✗ ${r.reason ?? "failed"}`;
+                        await finalizeStream(a, s);
+                    }
+                    else if (armMigration) {
+                        // /clear path has no live stream — surface failure as a one-shot
+                        // terse reply ("clean" per project convention).
+                        try {
+                            await client.replyStream(frame, streamId, withSessionTag(a.target, "clean"), true);
+                        }
+                        catch { /* ignore */ }
+                    }
+                    else {
+                        // Deferred path: tear down outbound, surface error as standalone.
+                        // promote* may have already cleared the slot if a tail item raced
+                        // ahead of inject completion — in that case just send the error.
+                        if (a.outbound?.kind === "deferred")
+                            clearTimeout(a.outbound.timer);
+                        a.outbound = undefined;
+                        sendStandalone(a, `[mirror] ✗ ${r.reason ?? "failed"}`);
+                    }
+                    return;
+                }
+                // Inject "succeeded" but the input box never cleared — the target
+                // session may be busy / not consuming input (long task, full context).
+                // Hint the user once so a silently-dropped message isn't mistaken for a
+                // weclaude bug. Skip on the /clear path (armMigration), which has its
+                // own "cleared" feedback below.
+                //
+                // OFF by default: the clear-check has a structural false-positive (the
+                // tailFp can match the message's own echo line just above the input box
+                // when it falls in the 5-row capture window), so in the common mirror
+                // case this fires on essentially every message even though it landed
+                // fine — pure noise. A genuinely dropped message still surfaces as the
+                // `[mirror] ✗` hard failure above. Opt back in with
+                // WECLAUDE_WARN_UNCERTAIN_INJECT=1 if you want the (noisy) heads-up.
+                if (r.uncertain && !armMigration && process.env.WECLAUDE_WARN_UNCERTAIN_INJECT === "1") {
+                    sendStandalone(a, `[mirror] ⚠️ 消息已发送,但目标会话似乎正忙或未响应(输入框未清空),可能未被处理。可稍后重试,或用 \`/sessions\` 切到其它会话。`);
+                }
+                // Follow a user-initiated same-dir fork (/clear or manual restart in the
+                // live TUI) that would otherwise leave the tail — and the "…" bubble —
+                // stuck on the dead old jsonl. /clear via WeCom (armMigration) has its
+                // own watcher; skip spawn-mode (no shared pane to fork under us).
+                if (!armMigration && a.tmuxPane)
+                    armSilentForkRebind(a, text);
+                // Confirm the /model picker. Early Enter (before the picker renders)
+                // would leave it unconfirmed, so settle first; a late Enter is a
+                // harmless no-op in the empty input box. On confirm, claude writes
+                // "Set model to …" as <local-command-stdout> — the tail mirrors that
+                // back to the chat as a ⚙️ bubble, which IS the readback.
+                if (isModelSwitch && a.tmuxPane) {
+                    await sleepMs(1000);
+                    const e = await tmuxRun(["send-keys", "-t", a.tmuxPane, "Enter"]);
+                    if (e.code !== 0)
+                        log.warn({ pane: a.tmuxPane, reason: e.stdout.slice(-200) || e.code }, "/model confirm Enter failed — user can send /n manually");
+                }
+                // /clear was just injected — claude rotates sessionId on the next user
+                // input. Arm a watcher to migrate the attachment onto the new jsonl,
+                // and surface a standalone "cleared" so the user gets explicit
+                // feedback (the skip-stream path otherwise leaves WeCom silent).
+                if (armMigration) {
+                    sendStandalone(a, `cleared\n\n${renderProjectInfo(a.target)}`);
+                    startMigrationWatcher(a, preClearBaseline, jsonlIsPostClearChild, 0);
+                }
+                // Don't await the stream's lifetime — it stays open until next inbound
+                // or hard timeout. Releasing the inject queue here lets the next
+                // dispatch start its inject promptly while tail content keeps flowing
+                // into the (still-open) stream until superseded.
+            });
+        },
+    };
+};
+const TOOL_DETAIL_PREFIX_EXT = "TOOL_DETAIL|";
+// Install a click-handler for the "查看详情" button. On click, look up the
+// turn's tool entries and push them as standalone markdown messages to the
+// originating chat.
+export const installMirrorEventListener = (client, bridge, log) => {
+    client.on("event.template_card_event", (frame) => {
+        const ev = frame.body?.event;
+        const key = ev?.event_key ?? "";
+        if (!key.startsWith(TOOL_DETAIL_PREFIX_EXT))
+            return;
+        const turnId = key.slice(TOOL_DETAIL_PREFIX_EXT.length);
+        const detail = bridge.resolveToolDetail(turnId);
+        if (!detail) {
+            log.warn({ turnId }, "tool detail expired or unknown");
+            return;
+        }
+        const chatId = stripPrincipalPrefix(detail.target);
+        void (async () => {
+            const n = detail.markdown.length;
+            for (const [i, md] of detail.markdown.entries()) {
+                try {
+                    const content = withSessionTag(detail.target, md, n > 1 ? `${i + 1}/${n}` : undefined);
+                    await client.sendMessage(chatId, { msgtype: "markdown", markdown: { content } });
+                }
+                catch (e) {
+                    log.warn({ err: e.message, turnId }, "tool detail push failed");
+                }
+            }
+        })();
+    });
+};
+//# sourceMappingURL=mirror-bridge.js.map