wezard 1.4.0 → 1.4.2

package/dist/daemon/mirror-bridge.js

@@ -16,13 +16,16 @@ 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 { augmentedPath } from "../shared/exec-path.js";
+import { sleep, truncateWithCount, mapLimit } from "../shared/std.js";
 import { activeBackends, backendForPath, projectDirFor, projectDirsFor, } from "../shared/cli-backends.js";
 import { isModalPane, isAskqSubmitPage, parseModalOptions, pickModalAnswer, pickAutoAllowAnswer, parseConfirmContext, looksLikePicker } from "../shared/modal-pane.js";
 import { hasMirrorAskq, runMirrorAskqFlow, hasMirrorPlan, mootMirrorPlan, runMirrorPlanFlow, hasMirrorPicker, mootMirrorPicker, runMirrorPickerFlow } from "./approval.js";
 import { isAutoWindowActive } from "./session-cache.js";
 import { noticeSuffixFor } from "./notices.js";
 import { dangerOf } from "./danger.js";
-import { runTmux as runTmuxCmd, spawnTmuxClaude } from "./spawn-tmux.js";
+import { runTmux, spawnTmuxClaude } from "./spawn-tmux.js";
+import { wizardStore } from "./wizard.js";
 import { startSubagentWatch } from "./subagent-tail.js";
 import { recordTool, recordToolResult, recordMark, recordTurnStart, recordTurnItem, recordTurnUsage, recordTurnClose, recordCloseOpenTurns, buildDetailUrl, buildChatUrl } from "./detail.js";
 import { labelFor, tagOfKey, baseOfKey, keyOf, withTagHeader, headSep, parseTagHeader } from "../shared/session-label.js";
@@ -32,25 +35,6 @@ import { chatBaseOf, chatNameOf, listChatNames, normChatName, parsePeerRef, peer
 import { stripAnsi, compactPane, paneIsBusy, paneIsStalled, transcriptStalled, summarizeTail, lastAssistantText, lastContextTokens, keepaliveStamps, tailTurns, renderDialog } from "./peers.js";
 // Same PATH augmentation logic as cc-bridge: launchd / systemd start the daemon
 // with a stripped PATH that often lacks nvm / homebrew, breaking spawn(claudeBin).
-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
@@ -264,15 +248,6 @@ const stripPrincipalPrefix = (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>
@@ -330,7 +305,6 @@ const cleanUserText = (raw) => {
     }
     return stripped;
 };
-const truncate = (s, max) => s.length <= max ? s : `${s.slice(0, max)}…(+${s.length - max})`;
 // 后台子agent 完成通知的无标签形态 —— codebuddy 平台在子agent 跑完后注入
 // `[Framework Auto-Notification] <agent> completed` 的纯文本 user 行 (不套
 // <task-notification>)。只认"整条消息以它开头", 免得把正文里提到它的消息吞掉。
@@ -371,7 +345,7 @@ const textSimilarity = (x, y) => {
 const renderToolInput = (input) => {
     try {
         const json = JSON.stringify(input ?? {}, null, 0);
-        return truncate(json, 600);
+        return truncateWithCount(json, 600);
     }
     catch {
         return "{}";
@@ -393,7 +367,7 @@ const extractToolResultText = (block) => {
 const DETAIL_RESULT_MAX = 64 * 1024;
 const oneLineSummary = (s, max = 40) => {
     const flat = s.replace(/\s+/g, " ").trim();
-    return truncate(flat, max);
+    return truncateWithCount(flat, max);
 };
 // WeCom's markdown sanitizer strips HTML-like `<...>` runs even inside inline
 // code spans — so a Bash command containing `<<'EOF'` (heredoc), `<file>`,
@@ -537,7 +511,7 @@ const renderLine = (raw, deps) => {
                 if (!raw)
                     continue;
                 const toolUseId = b.tool_use_id ?? "";
-                const full = truncate(raw, DETAIL_RESULT_MAX);
+                const full = truncateWithCount(raw, DETAIL_RESULT_MAX);
                 // 始终把完整 result 落 detail 库 + 作为 tool_result item 发出 — 与
                 // includeToolResults(气泡推送开关)彻底解耦: 关掉气泡时 detail 页与 brief
                 // turn 页(handleBriefItem 消费本 item 写 turn store)都仍要看到 result。
@@ -704,7 +678,6 @@ const renderLine = (raw, deps) => {
 };
 // Block-wise packing (shared/md-chunk): never cuts mid-line, and never cuts a
 // fenced block or table in a way that breaks rendering — see splitMarkdown.
-const splitChunks = splitMarkdown;
 // Room reserved in every chunk for the `emoji \`#tag\` \`2/5\`` header line
 // (up to ~110 bytes in its linked `[🧙 #tag](url)` form).
 const TAG_HEADER_BUDGET = 64;
@@ -827,13 +800,10 @@ export const startMirrorTail = (deps) => {
         livePath: resolveLive,
     };
 };
-// Run a tmux subcommand, capturing stdout/stderr. Delegates to spawn-tmux's
-// runTmux so there is exactly ONE tmux exec path in the daemon — and therefore
-// exactly one place where the hard timeout lives. (Two hand-rolled copies used
-// to exist here; both could hang forever, which is how a wedged tmux server
-// silently killed a whole chat. See TMUX_TIMEOUT_MS.)
-const tmuxRun = (args, opts) => runTmuxCmd(args, opts);
-const sleepMs = (ms) => new Promise((r) => setTimeout(r, ms));
+const parsePaneList = (out) => new Map(out.split("\n").flatMap((line) => {
+    const [id, ...rest] = line.trim().split("\t");
+    return id?.startsWith("%") ? [[id, rest.join("\t")]] : [];
+}));
 // 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.
@@ -955,7 +925,7 @@ const setMacClipboardImage = async (imgPath) => {
 // 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}`]);
+    const r = await runTmux(["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
@@ -1043,7 +1013,7 @@ const MODAL_SCAN_ROWS = 15;
 // `screen` = 实际参与判定的那一屏文本, 一并返回给调用方做选项解析 —— 再 capture
 // 一次会拿到"下一瞬间"的屏幕, 与 verdict 不同源(框可能已被本地按掉), 按键就按错了。
 const detectModalPicker = async (target) => {
-    const r = await tmuxRun(["capture-pane", "-t", target, "-p"]);
+    const r = await runTmux(["capture-pane", "-t", target, "-p"]);
     if (!r.ok)
         return { modal: false, screen: "" };
     const lines = r.stdout.replace(/\s+$/u, "").split("\n");
@@ -1060,8 +1030,8 @@ const MODAL_PRESS_SETTLE_MS = 400;
 const MODAL_ARROW_SETTLE_MS = 150;
 const highlightedIndex = (screen) => parseModalOptions(screen).find((o) => o.selected)?.index;
 const pressModalIndex = async (pane, before, index) => {
-    await tmuxRun(["send-keys", "-t", pane, String(index)]);
-    await sleepMs(MODAL_PRESS_SETTLE_MS);
+    await runTmux(["send-keys", "-t", pane, String(index)]);
+    await sleep(MODAL_PRESS_SETTLE_MS);
     let after = await detectModalPicker(pane);
     if (!after.modal || after.title !== before.title)
         return after;
@@ -1070,16 +1040,16 @@ const pressModalIndex = async (pane, before, index) => {
         const cur = highlightedIndex(after.screen);
         if (cur === undefined || cur === index)
             break;
-        await tmuxRun(["send-keys", "-t", pane, cur < index ? "Down" : "Up"]);
-        await sleepMs(MODAL_ARROW_SETTLE_MS);
+        await runTmux(["send-keys", "-t", pane, cur < index ? "Down" : "Up"]);
+        await sleep(MODAL_ARROW_SETTLE_MS);
         after = await detectModalPicker(pane);
         if (!after.modal || after.title !== before.title)
             return after;
     }
     if (highlightedIndex(after.screen) !== index)
         return after; // 核不准, 绝不盲按
-    await tmuxRun(["send-keys", "-t", pane, "Enter"]);
-    await sleepMs(MODAL_PRESS_SETTLE_MS);
+    await runTmux(["send-keys", "-t", pane, "Enter"]);
+    await sleep(MODAL_PRESS_SETTLE_MS);
     return detectModalPicker(pane);
 };
 // 「聊聊这个」收尾: 文本 inject 已把引导语贴进自定义文本行 (❯ N. <text>)。codebuddy
@@ -1097,7 +1067,7 @@ const ASKQ_CONFIRM_STAGE_MS = 2500; // 每阶段 (到提交页 / 面板关闭)
 const ASKQ_SECONDARY_ENTERS = 3;
 const confirmAskqSubmit = async (target, paneAlive) => {
     const capture = async () => {
-        const r = await tmuxRun(["capture-pane", "-t", target, "-p"]);
+        const r = await runTmux(["capture-pane", "-t", target, "-p"]);
         return r.ok ? r.stdout.replace(/\s+$/u, "") : "";
     };
     // 轮询到 pred 为真; 期间 pane 死了立即失败。
@@ -1110,10 +1080,10 @@ const confirmAskqSubmit = async (target, paneAlive) => {
                 return true;
             if (Date.now() - t0 >= timeoutMs)
                 return false;
-            await sleepMs(ASKQ_CONFIRM_POLL_MS);
+            await sleep(ASKQ_CONFIRM_POLL_MS);
         }
     };
-    const sendKey = (key) => tmuxRun(["send-keys", "-t", target, key]);
+    const sendKey = (key) => runTmux(["send-keys", "-t", target, key]);
     for (let attempt = 0; attempt < ASKQ_CONFIRM_ENTERS; attempt++) {
         if (!(await paneAlive()))
             return { ok: false, reason: "pane_dead" };
@@ -1135,7 +1105,7 @@ const confirmAskqSubmit = async (target, paneAlive) => {
         const d = await sendKey("Down");
         if (!d.ok)
             return { ok: false, reason: `send-keys Down: ${d.stderr.slice(-200) || d.code}` };
-        await sleepMs(ASKQ_CONFIRM_POLL_MS); // 等光标移动重绘
+        await sleep(ASKQ_CONFIRM_POLL_MS); // 等光标移动重绘
         const e = await sendKey("Enter");
         if (!e.ok)
             return { ok: false, reason: `send-keys Enter: ${e.stderr.slice(-200) || e.code}` };
@@ -1165,14 +1135,46 @@ const fingerprints = (text) => {
     const stripped = text.replace(/\s+/gu, "").trim();
     return { headFp: stripped.slice(0, 8), tailFp: stripped.slice(-8) };
 };
+// 输入框本体 = 两条 ruler 之间那几行, 首行以 `❯ `/`> ` 打头:
+//
+//   ────────────────────────
+//   ❯ [Pasted text #1 +5 lines]
+//   ────────────────────────
+//     <cwd>            <status>
+//
+// 读整块、跟「贴之前」的快照比对, 判据就与文本内容无关了 —— 这恰恰是指纹法的
+// 盲区: Claude Code 把多行粘贴折叠成 `[Pasted text #N +M lines]`, headFp/tailFp
+// 双双不在屏上, 于是「没贴进去」被误判 → 盲目重贴 → 两份提示叠在一个输入框里
+// (实测第三次粘贴渲染成 `…OMEGATAIL[Pasted text #2 +5 lines]`)。同一个盲区也让
+// 回车后的「框清空了吗」永远立刻为真, 等于根本没校验过提交。
+const BOX_RULER_RE = /^[\u2500-\u257F\u2014-]{8,}\s*$/u;
+const BOX_PROMPT_RE = /^\s*[❯>]\s?/u;
+/** 底 ruler 之下只该剩 cwd/模式两行状态; 多于此说明框到的不是输入框。 */
+const BOX_FOOTER_ROWS = 6;
+const UNKNOWN_BOX = { known: false, body: "" };
+export const parseInputBox = (cap) => {
+    const lines = cap.split("\n");
+    while (lines.length && lines[lines.length - 1].trim() === "")
+        lines.pop();
+    const rulers = lines.reduce((acc, l, i) => (BOX_RULER_RE.test(l) ? [...acc, i] : acc), []);
+    const bottom = rulers[rulers.length - 1];
+    const top = rulers[rulers.length - 2];
+    if (top === undefined || bottom === undefined || bottom - top < 1)
+        return UNKNOWN_BOX;
+    if (lines.length - bottom > BOX_FOOTER_ROWS)
+        return UNKNOWN_BOX;
+    const rows = lines.slice(top + 1, bottom);
+    if (!rows.length || !BOX_PROMPT_RE.test(rows[0]))
+        return UNKNOWN_BOX;
+    const body = [rows[0].replace(BOX_PROMPT_RE, ""), ...rows.slice(1)].join("\n").replace(/[\s\u200b\ufeff]+/gu, " ").trim();
+    return { known: true, body };
+};
+// 24 行足够容纳展开后的多行粘贴 (折叠态只占一行)。
+const readInputBox = async (target) => parseInputBox(await capturePaneTail(target, 24));
 // 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.
+// the prompt sits typed-but-unsent. 校验策略见 injectViaTmuxText —— 以输入框
+// 整块为判据, 粘贴只在「确凿看见框仍是空的」时才重来。
 const injectViaTmux = async (target, text, images, log, freshSpawn, backendName, bypassModalGuard = false) => {
     log.info({ target, len: text.length, images: images.length, freshSpawn, backendName }, "mirror inject (tmux)");
     // Never type into a modal picker (see detectModalPicker). Checked before the
@@ -1219,10 +1221,10 @@ const injectViaTmux = async (target, text, images, log, freshSpawn, backendName,
             log.warn({ imgPath, reason: cb.reason }, "mirror inject: clipboard set failed, skipping image");
             continue;
         }
-        const cv = await tmuxRun(["send-keys", "-t", target, "C-v"]);
+        const cv = await runTmux(["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);
+        await sleep(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
@@ -1230,13 +1232,20 @@ const injectViaTmux = async (target, text, images, log, freshSpawn, backendName,
     if (!text) {
         if (images.length === 0)
             return { ok: true };
-        const e = await tmuxRun(["send-keys", "-t", target, "Enter"]);
+        const e = await runTmux(["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 逻辑。
+//
+// 两个判据都以**输入框整块**为准 (parseInputBox), 指纹只是认不出布局时的退路:
+//   1. 贴完轮询「框变了」→ 粘贴已被 TUI 消化 (折叠成占位符也算)。这是个**正**
+//      信号, 只有确凿看见框仍是贴之前的样子才重贴 —— 存疑一律不重贴, 多贴一次
+//      的代价 (两份提示叠进同一个输入框) 远高于少贴一次。
+//   2. 回车后轮询「框回到贴之前的样子」→ 提交被吃下了。框认得出来时这条判据可
+//      信, 于是允许多补一次回车 (空框上的回车在 CLI 里是 no-op)。
 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
@@ -1247,13 +1256,24 @@ const injectViaTmuxText = async (target, text, log, freshSpawn) => {
     const POST_PASTE_SETTLE_FALLBACK_MS = freshSpawn ? 2500 : 700;
     const CLEARED_TIMEOUT_MS = freshSpawn ? 4000 : 1500;
     const RETRY_SETTLE_MS = freshSpawn ? 1500 : 800;
+    const { headFp, tailFp } = fingerprints(text);
+    const POLL_MS = 100;
+    const stripWs = (s) => s.replace(/\s+/gu, "");
+    // 贴之前框里是什么: 空框、幽灵提示 (`Try "how do I log an error?"`)、甚至用户
+    // 自己敲了一半的字 —— 一律作为基线, 免得去维护一张「哪些文案算空」的清单。
+    const preBox = await readInputBox(target);
+    // 基线读不出来 (框被模态顶掉 / 正在重绘) 就整条退回指纹法: 没有基线,「框变了」
+    // 无从谈起, 而把幽灵提示 (`Try "…"`) 误当成「贴进去了」会让这条消息静静消失。
+    const boxVerify = preBox.known;
+    /** 框里还是贴之前那样 (或彻底空了) = 我们的文本不在框里。 */
+    const boxIntact = (b) => boxVerify && b.known && (b.body === "" || b.body === preBox.body);
     const loadAndPaste = async () => {
         // stdin variant of the shared exec path — it carries the same hard timeout,
         // which a hand-rolled spawn here did not.
-        const loaded = await tmuxRun(["load-buffer", "-"], { stdin: text });
+        const loaded = await runTmux(["load-buffer", "-"], { stdin: text });
         if (!loaded.ok)
             return { ok: false, reason: `tmux load-buffer failed: ${loaded.stderr.slice(-200) || loaded.code}` };
-        const pasted = await tmuxRun(["paste-buffer", "-p", "-d", "-t", target]);
+        const pasted = await runTmux(["paste-buffer", "-p", "-d", "-t", target]);
         if (!pasted.ok)
             return { ok: false, reason: `tmux paste-buffer failed: ${pasted.stderr.slice(-200)}` };
         return { ok: true };
@@ -1261,100 +1281,88 @@ const injectViaTmuxText = async (target, text, log, freshSpawn) => {
     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) => {
+    // 框认得出来 → 看它变没变; 认不出来 → 退回宽窗口找 headFp (长文本会换行,
+    // 头部可能在框顶, 所以窗口要宽)。
+    const sawLanded = async (timeoutMs) => {
         const t0 = Date.now();
         while (Date.now() - t0 < timeoutMs) {
-            const pane = await capturePaneTail(target, 12);
-            if (headFp && stripWs(pane).includes(headFp))
+            const cap = await capturePaneTail(target, 24);
+            const box = parseInputBox(cap);
+            if (boxVerify && box.known ? !boxIntact(box) : Boolean(headFp) && stripWs(cap).includes(headFp))
                 return true;
-            await sleepMs(POLL_MS);
+            await sleep(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.
+    // 窄窗口 = 只有输入框本身。tailFp 紧挨光标, 提交前必在窗内、提交后消失。
+    // 仅用于 parseInputBox 认不出布局的后端。
     const inputBoxStillHasTail = async () => {
         const pane = await capturePaneTail(target, 5);
         return Boolean(tailFp) && stripWs(pane).includes(tailFp);
     };
-    let pasteSeen = await sawHead(PASTE_VERIFY_MS);
+    let pasteSeen = await sawLanded(PASTE_VERIFY_MS);
     if (!pasteSeen) {
-        // headFp not seen — but on a cold fresh-spawn the TUI can render the paste
-        // just outside our capture window / after our budget, so `sawHead` yields a
-        // FALSE negative even though the text is sitting in the input box. Blindly
-        // re-pasting then stacks a SECOND copy → the classic doubled prompt. Guard:
-        // re-paste only if the box genuinely lacks our tail; otherwise the first
-        // paste landed and we just proceed to submit.
-        if (await inputBoxStillHasTail()) {
-            log.warn({ target, headFp }, "mirror inject: headFp not seen but tail present in box — first paste landed, skipping re-paste");
+        const box = await readInputBox(target);
+        const empty = boxVerify && box.known ? boxIntact(box) : !(await inputBoxStillHasTail());
+        if (!empty) {
+            log.warn({ target, headFp, boxKnown: box.known }, "mirror inject: 粘贴未验证但输入框非空 — 首次粘贴已落地, 不重贴");
             pasteSeen = true;
         }
         else {
-            log.warn({ target, headFp }, "mirror inject: paste headFp not seen, re-pasting");
-            await sleepMs(RETRY_SETTLE_MS);
+            log.warn({ target, headFp, boxKnown: box.known }, "mirror inject: 输入框确认为空, 重贴一次");
+            await sleep(RETRY_SETTLE_MS);
             r = await loadAndPaste();
             if (!r.ok)
                 return r;
-            pasteSeen = await sawHead(PASTE_VERIFY_MS);
+            pasteSeen = await sawLanded(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);
+    await sleep(pasteSeen ? POST_PASTE_SETTLE_MS : POST_PASTE_SETTLE_FALLBACK_MS);
     const sendEnter = async () => {
-        const e = await tmuxRun(["send-keys", "-t", target, "Enter"]);
+        const e = await runTmux(["send-keys", "-t", target, "Enter"]);
         return e.ok ? { ok: true } : { ok: false, reason: `tmux send-keys failed: ${e.stderr.slice(-200)}` };
     };
+    const cleared = async () => {
+        const box = await readInputBox(target);
+        return boxVerify && box.known ? boxIntact(box) : !(await inputBoxStillHasTail());
+    };
     const waitForCleared = async (timeoutMs) => {
         const t0 = Date.now();
         while (Date.now() - t0 < timeoutMs) {
-            await sleepMs(POLL_MS);
-            if (!(await inputBoxStillHasTail()))
+            await sleep(POLL_MS);
+            if (await cleared())
                 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.
+    if (!tailFp) {
+        // empty/whitespace text — nothing to verify, fire once and go.
+        const e = await sendEnter();
+        return e.ok ? { ok: true } : e;
+    }
+    // 回车可能被冷启动中的 TUI 吞掉 (框里躺着没提交的提示)。框认得出来时判据可信,
+    // 多补一次; 认不出来时维持原来的「只补一次」, 免得判据出错往真实对话里灌回车。
+    const boxTrusted = boxVerify && (await readInputBox(target)).known;
+    const attempts = boxTrusted ? 3 : 2;
+    for (let i = 0; i < attempts; i++) {
+        if (i > 0) {
+            log.warn({ target, tailFp, attempt: i + 1 }, "mirror inject: 回车后输入框未清空, 再补一次");
+            await sleep(RETRY_SETTLE_MS);
+        }
+        const e = await sendEnter();
+        if (!e.ok)
+            return e;
+        if (await waitForCleared(CLEARED_TIMEOUT_MS))
+            return { ok: true };
+    }
+    // 补到头还没清空。通常是渲染滞后 (回车其实落了), 但也可能是目标会话正忙 /
+    // 上下文满了不消费输入 —— 那样用户这条消息会悄无声息地消失。不报硬失败 (用户
+    // 多半已经被服务到了), 标 uncertain 让调用方按需提示。
+    log.warn({ target, tailFp, freshSpawn, boxTrusted }, "mirror inject: clear not observed, trusting submit");
     return { ok: true, uncertain: true, reason: "目标会话可能正忙或未消费输入(回车后输入框未清空)" };
 };
 const injectViaSpawn = (args) => {
@@ -1573,7 +1581,7 @@ export const startMirror = (deps) => {
     const detailCardFor = (s, target) => {
         if (s.tools.length === 0)
             return undefined;
-        const tag = tagOfTarget(target);
+        const tag = tagOfKey(target);
         const titlePrefix = tag ? `${labelFor(tag)} #${tag} · ` : "";
         return {
             card_type: "button_interaction",
@@ -1590,7 +1598,7 @@ export const startMirror = (deps) => {
         const content = s.acc;
         s.lastSent = content;
         try {
-            await client.replyStream(s.frame, s.streamId, withSessionTag(s.target, content || " "), false);
+            await client.replyStream(s.frame, s.streamId, withTagHeader(s.target, content || " "), false);
             log.debug({ turnId: s.turnId, len: content.length }, "stream flush ok");
         }
         catch (e) {
@@ -1672,7 +1680,7 @@ export const startMirror = (deps) => {
     // Standalone fallback (no live stream / stream dead). Per-attachment FIFO so
     // pushes from a single mirror stay ordered; different mirrors run in parallel.
     // Linked tag prefix: emoji+tag becomes a chat-detail link. Falls back to
-    // plain withSessionTag when no turnId is available (no active turn to link).
+    // plain withTagHeader when no turnId is available (no active turn to link).
     const linkedTagPrefix = (target, turnId) => {
         if (!turnId)
             return "";
@@ -1686,7 +1694,7 @@ export const startMirror = (deps) => {
             const seqBit = seq ? ` ${seq}` : "";
             return `${prefix}${seqBit}${headSep(content)}${content}`;
         }
-        return withSessionTag(a.target, content, seq);
+        return withTagHeader(a.target, content, seq);
     };
     // 空正文一票否决 (近源拦截): 剥掉可能存在的路由头 (`🦊 #tag` / `[🧙](url)`)
     // 后没有可见内容就不发。中央 chat-gate (last-response 的 SDK 包装) 是最后一道
@@ -1697,7 +1705,7 @@ export const startMirror = (deps) => {
         if (!hasVisibleBody(content))
             return;
         const chatId = stripPrincipalPrefix(a.target);
-        const pieces = splitChunks(content, Math.max(200, cfg.wrc.mirror.chunkBytes - TAG_HEADER_BUDGET));
+        const pieces = splitMarkdown(content, Math.max(200, cfg.wrc.mirror.chunkBytes - TAG_HEADER_BUDGET));
         const chunks = pieces.map((p, i) => withLinkedTag(a, p, pieces.length > 1 ? `${i + 1}/${pieces.length}` : undefined));
         a.standalonePending = a.standalonePending
             .then(async () => {
@@ -1712,7 +1720,7 @@ export const startMirror = (deps) => {
         })
             .catch(() => undefined);
     };
-    // Like sendStandalone but skips withSessionTag — content already contains the tag header (e.g. as a link).
+    // Like sendStandalone but skips withTagHeader — content already contains the tag header (e.g. as a link).
     const sendRaw = (a, content) => {
         if (!hasVisibleBody(content))
             return;
@@ -1906,7 +1914,7 @@ export const startMirror = (deps) => {
             // sees the bubble; subsequent items grow it as today.
             void (async () => {
                 try {
-                    await client.replyStream(frame, streamId, withSessionTag(a.target, "…"), false);
+                    await client.replyStream(frame, streamId, withTagHeader(a.target, "…"), false);
                 }
                 catch (e) {
                     log.warn({ sessionId: a.sessionId, err: e.message }, "stream initial ack failed");
@@ -2050,7 +2058,7 @@ export const startMirror = (deps) => {
     // 只在 brief 下生效: 抑制的前提是详情页兜得住内容, 而 turn store 只有 brief 在写。
     const turnSilent = (a) => cfg.wrc.mirror.brief && cfg.wrc.mirror.chatOriginOnly && a.turnFromChat === false;
     // 收口一条 loading 气泡: finish=true 写入最终内容, 只生效一次。发送失败退回 standalone。
-    // raw=true skips withSessionTag (used when content already contains the linked tag header).
+    // raw=true skips withTagHeader (used when content already contains the linked tag header).
     // WeCom 客户端收到 finish=true 后仍有打字机动画要播放, 如果紧接着就下发
     // standalone (sendMessage), 用户会看到 standalone 抢在气泡动画结束之前出现。
     // 把 finishBubble 的 replyStream promise 链入 standalonePending, 让后续
@@ -2110,6 +2118,12 @@ export const startMirror = (deps) => {
         a.pendingOrigin = undefined;
         return p && Date.now() - p.at <= ORIGIN_TTL_MS ? p.origin : undefined;
     };
+    /** 同上, 出处那一枚印章。 */
+    const consumeFrom = (a) => {
+        const p = a.pendingFrom;
+        a.pendingFrom = undefined;
+        return p && Date.now() - p.at <= ORIGIN_TTL_MS ? p.from : undefined;
+    };
     // 详情页要按后端的名字称呼它 ("Claude 正在思考" / "CodeBuddy 正在思考") —— 后端
     // 由 transcript 落盘路径唯一确定, 所以每次开 turn 时现算, 不必额外记在 AttachState 上。
     const cliOf = (a) => a.jsonlPath ? backendForPath(a.jsonlPath).name : undefined;
@@ -2118,7 +2132,7 @@ export const startMirror = (deps) => {
         a.queryEpoch = (a.queryEpoch ?? 0) + 1; // WeCom 侧的新一轮同样是 query 边界
         a.turnFromChat = true; // 出处确凿: 这一轮有 frame, 群里就是它的主场
         a.pendingFromCli = false; // 人改从聊天里说话了, 之前那条 CLI 输入不再是出处
-        recordTurnStart({ id: turnId, target: a.target, sessionId: a.sessionId, cli: cliOf(a), cwd: a.runningCwd || undefined, userQuery: userQuery.trim() || undefined, origin: consumeOrigin(a) });
+        recordTurnStart({ id: turnId, target: a.target, sessionId: a.sessionId, cli: cliOf(a), cwd: a.runningCwd || undefined, userQuery: userQuery.trim() || undefined, origin: consumeOrigin(a), from: consumeFrom(a) });
         // hardTimer 兜底: turn 若无终句 / turn_end 收口 (卡死/漏收), 到点仍收气泡。
         const bubble = { frame, streamId, hardTimer: undefined, done: false };
         const q = { turnId, bubble, isSlash };
@@ -2164,7 +2178,7 @@ export const startMirror = (deps) => {
         const fromCli = a.pendingFromCli === true;
         a.pendingFromCli = false;
         a.turnFromChat = fromCli ? false : a.turnFromChat ?? true;
-        recordTurnStart({ id: turnId, target: a.target, sessionId: a.sessionId, cli: cliOf(a), cwd: a.runningCwd || undefined, userQuery: query || undefined, origin: consumeOrigin(a) });
+        recordTurnStart({ id: turnId, target: a.target, sessionId: a.sessionId, cli: cliOf(a), cwd: a.runningCwd || undefined, userQuery: query || undefined, origin: consumeOrigin(a), from: consumeFrom(a) });
         a.briefTurnId = turnId;
         a.briefBubble = undefined;
         a.briefIsSlash = false;
@@ -2836,7 +2850,7 @@ export const startMirror = (deps) => {
                                 return { ok: false, reason: "no_live_pane" };
                             if (!(await tmuxPaneAlive(a.tmuxPane)))
                                 return { ok: false, reason: "pane_dead" };
-                            const r = await tmuxRun(["send-keys", "-t", a.tmuxPane, key]);
+                            const r = await runTmux(["send-keys", "-t", a.tmuxPane, key]);
                             return r.code === 0 ? { ok: true } : { ok: false, reason: `send-keys ${key} failed: ${r.stdout.slice(-200) || r.code}` };
                         },
                     });
@@ -2887,13 +2901,13 @@ export const startMirror = (deps) => {
                                 }
                                 else {
                                     for (const key of act.keys) {
-                                        const r = await tmuxRun(["send-keys", "-t", a.tmuxPane, key]);
+                                        const r = await runTmux(["send-keys", "-t", a.tmuxPane, key]);
                                         if (r.code !== 0)
                                             return { ok: false, reason: `send-keys ${key}: ${r.stdout.slice(-200) || r.code}` };
-                                        await sleepMs(120); // 键间距 — 等 TUI 重渲染, 防吞键
+                                        await sleep(120); // 键间距 — 等 TUI 重渲染, 防吞键
                                     }
                                 }
-                                await sleepMs(300); // 题间/阶段间隔 — 等面板翻页
+                                await sleep(300); // 题间/阶段间隔 — 等面板翻页
                             }
                             return { ok: true };
                         },
@@ -3162,7 +3176,7 @@ export const startMirror = (deps) => {
     const tmuxPaneAlive = async (paneId) => {
         if (!paneId)
             return false;
-        const r = await tmuxRun(["display-message", "-p", "-t", paneId, "#{pane_id}"]);
+        const r = await runTmux(["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
@@ -3185,7 +3199,9 @@ export const startMirror = (deps) => {
                 s.add(a.sessionId);
         return s;
     };
-    const restoreFromStore = async (principal) => {
+    // `panes` = boot 快照; 给了就不再为每个 principal 单独问 tmux。lazy 调用方
+    // 不传, 维持原来的逐个探活。
+    const restoreFromStore = async (principal, panes) => {
         const rec = deps.store.get(principal);
         if (!rec)
             return undefined;
@@ -3202,7 +3218,7 @@ export const startMirror = (deps) => {
         // jsonl means "no input yet", NOT "rotated away" — healing it onto some
         // unrelated newest-in-cwd file is exactly the cross-wire we must avoid.
         const storedPane = (rec.tmuxPane ?? "").trim();
-        const livePane = storedPane && (await tmuxPaneAlive(storedPane)) ? storedPane : "";
+        const livePane = storedPane && (panes ? panes.has(storedPane) : await tmuxPaneAlive(storedPane)) ? storedPane : "";
         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
@@ -3255,8 +3271,9 @@ export const startMirror = (deps) => {
         // 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();
+            const paneCwd = panes
+                ? (panes.get(livePane) ?? "")
+                : (await runTmux(["display-message", "-p", "-t", livePane, "#{pane_current_path}"])).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
@@ -3310,12 +3327,20 @@ export const startMirror = (deps) => {
     // 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 RESTORE_CONC = 8;
     const persisted = deps.store.all();
     const persistedKeys = Object.keys(persisted);
     if (persistedKeys.length > 0) {
-        for (const principal of persistedKeys) {
-            void restoreFromStore(principal);
-        }
+        // 裸 fan-out 会把 2N 次 tmux 同时压下去 —— 几百个绑定就是七百个 client 一起
+        // 撞 10s 超时, spawn 风暴顺带把事件循环压住, :17890 要 25s 才 bind, 而 CLI 的
+        // reload 探测早放弃了 (「reload issued but /status not responding」的真身)。
+        // 一张快照 + 封顶并发; await 立刻让出, startHttp 先绑端口。
+        void (async () => {
+            const snap = await runTmux(["list-panes", "-a", "-F", "#{pane_id}\t#{pane_current_path}"]);
+            const panes = snap.ok ? parsePaneList(snap.stdout) : undefined;
+            await mapLimit(persistedKeys, RESTORE_CONC, (principal) => restoreFromStore(principal, panes));
+            log.info({ restored: persistedKeys.length, panes: panes?.size ?? -1 }, "mirror: boot restore done");
+        })();
     }
     else if (cfg.wrc.mirror.sessionId.trim()) {
         // Pinned-sessionId fallback: only honor when the store is empty (otherwise
@@ -3348,10 +3373,10 @@ export const startMirror = (deps) => {
                     }
                 })();
             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\`\`\``);
+            parts.push(`### ${i}. 🔧 ${t.name}\n\n**input**\n\`\`\`json\n${truncateWithCount(inputJson, 4000)}\n\`\`\`\n\n**result**\n\`\`\`\n${truncateWithCount(result, 4000)}\n\`\`\``);
         }
         const merged = parts.join("\n\n---\n\n");
-        return splitChunks(merged, Math.max(200, cfg.wrc.mirror.chunkBytes - TAG_HEADER_BUDGET));
+        return splitMarkdown(merged, Math.max(200, cfg.wrc.mirror.chunkBytes - TAG_HEADER_BUDGET));
     };
     const resolveToolDetail = (turnId) => {
         evictTurns();
@@ -3696,7 +3721,7 @@ export const startMirror = (deps) => {
             // 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}"]);
+            const r = await runTmux(["display-message", "-p", "-t", a.tmuxPane, "#{pane_current_path}"]);
             if (stopped)
                 return;
             const paneCwd = r.code === 0 ? r.stdout.trim() : "";
@@ -3774,7 +3799,7 @@ export const startMirror = (deps) => {
             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}"]);
+            const r = await runTmux(["list-panes", "-a", "-F", "#{pane_id}\t#{pane_current_path}"]);
             if (r.code !== 0)
                 return;
             const paneCwd = new Map();
@@ -3833,7 +3858,7 @@ export const startMirror = (deps) => {
         // 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) } })
+            .sendMessage(chatId, { msgtype: "markdown", markdown: { content: withTagHeader(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
@@ -3842,7 +3867,7 @@ export const startMirror = (deps) => {
     // own `runningCwd` (the tmux pane's actual working dir at spawn time), but
     // cwd fallbacks and `set_workspace` pendingCwd writes always resolve against the base.
     const chatCwdFallback = (target) => {
-        const base = basePrincipalOf(target);
+        const base = baseOfKey(target);
         const baseA = byTarget.get(base);
         const baseRec = deps.store.get(base);
         return {
@@ -3894,13 +3919,13 @@ export const startMirror = (deps) => {
         // 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 base = baseOfKey(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]);
+            void runTmux(["kill-pane", "-t", prev.tmuxPane]);
         }
         if (prev)
             detach(prev, "/new respawn");
@@ -4002,7 +4027,7 @@ export const startMirror = (deps) => {
             const hit = born[0];
             if (hit)
                 return { sessionId: hit.n.replace(/\.jsonl$/, ""), jsonlPath: hit.path };
-            await sleepMs(FORK_POLL_MS);
+            await sleep(FORK_POLL_MS);
         }
         return undefined;
     };
@@ -4047,7 +4072,7 @@ export const startMirror = (deps) => {
             tmuxTarget: r.tmuxPane, freshSpawn: true,
         });
         if (!boot.ok) {
-            await tmuxRun(["kill-pane", "-t", r.tmuxPane ?? ""]);
+            await runTmux(["kill-pane", "-t", r.tmuxPane ?? ""]);
             return { ok: false, reason: `分身开场白注入失败: ${boot.reason ?? "unknown"}`, inherited: false };
         }
         const fork = await awaitFork(projectDir, baseline, sidsClaimedByOthers(args.target));
@@ -4055,7 +4080,7 @@ export const startMirror = (deps) => {
         // 同一个会话 (attach 也会正当地拒绝)。留一个孤儿 pane 比留一条错绑更好收拾 ——
         // 所以连 pane 一起杀掉, 调用方拿到的是一个干净的失败。
         if (!fork) {
-            await tmuxRun(["kill-pane", "-t", r.tmuxPane ?? ""]);
+            await runTmux(["kill-pane", "-t", r.tmuxPane ?? ""]);
             return { ok: false, reason: "分身没能在超时内分叉出自己的会话 (CLI 可能不支持 --fork-session)", inherited: false };
         }
         const att = attach({
@@ -4126,7 +4151,7 @@ export const startMirror = (deps) => {
         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 base = baseOfKey(target);
         const callerA = byTarget.get(target);
         const callerRunning = callerA?.runningCwd?.trim() || deps.store.get(target)?.cwd?.trim() || expandedDefaultCwd;
         const baseA = byTarget.get(base);
@@ -4184,8 +4209,8 @@ export const startMirror = (deps) => {
         return Array.from(keys).sort();
     };
     const chatTargets = (target) => {
-        const base = basePrincipalOf(target);
-        return allTargets().filter((k) => basePrincipalOf(k) === base);
+        const base = baseOfKey(target);
+        return allTargets().filter((k) => baseOfKey(k) === base);
     };
     // 名字解析:`daily` / `chat:wrxxx` → base principal。认不出就把已知名字一并回给
     // 调用方 —— 跨 chat 出错时"我该写什么"比"你写错了"有用得多。
@@ -4205,7 +4230,8 @@ export const startMirror = (deps) => {
     //   `fix`         本 chat 优先,本 chat 没有再全局兜底(全 host 唯一才认)——
     //                 命名之前唯一的跨 chat 路子,老调用方不能因为引入命名而断掉;
     //   `daily#fix`   daily 这个 chat 里的 `#fix`,精确到点,不问 tag 全不全局唯一;
-    //   `daily#`      daily 的 default 会话;
+    //   `daily`       daily 这个聊天的 default 会话 —— 默认 wizard 的名字就是聊天名,
+    //                 所以裸聊天名就是它的地址 (`daily#` 这种老写法继续认);
     //   `chat:wr…#fix` 全量 key 同理(list_peers 吐的就是它)。
     // 裸 tag 的 0 命中 / ≥2 命中依旧拒绝,但出路从"回去改 tag 名"变成"用带 chat 名
     // 的全称地址"——后者不需要动别人的会话。
@@ -4218,23 +4244,23 @@ export const startMirror = (deps) => {
                 return c;
             const target = keyOf(c.base, t);
             if (allTargets().includes(target)) {
-                return { ok: true, target, foreign: c.base !== basePrincipalOf(self) };
+                return { ok: true, target, foreign: c.base !== baseOfKey(self) };
             }
             return {
                 ok: false,
                 reason: `chat '${chat}' has no ${t ? `'#${t}'` : "default"} session — create it with new_claude_session({ chat: '${chat}'${t ? `, tag: '${t}'` : ""}, cwd })`,
                 // 候选给**地址**而不是裸 key —— 这份清单存在的意义就是让调用方照着改一个
                 // 能用的串; 隔壁两个分支早就这么做了, 只有这一条漏掉。
-                candidates: allTargets().filter((k) => basePrincipalOf(k) === c.base).map((k) => peerAddress(cfg, self, k)),
+                candidates: allTargets().filter((k) => baseOfKey(k) === c.base).map((k) => peerAddress(cfg, self, k)),
             };
         }
-        const local = keyOf(basePrincipalOf(self), t);
+        const local = keyOf(baseOfKey(self), t);
         if (!t)
             return { ok: true, target: local, foreign: false };
         const all = allTargets();
         if (all.includes(local))
             return { ok: true, target: local, foreign: false };
-        const foreignMatches = all.filter((k) => tagOfKey(k) === t && basePrincipalOf(k) !== basePrincipalOf(self));
+        const foreignMatches = all.filter((k) => tagOfKey(k) === t && baseOfKey(k) !== baseOfKey(self));
         if (foreignMatches.length === 1)
             return { ok: true, target: foreignMatches[0], foreign: true };
         if (foreignMatches.length === 0) {
@@ -4242,10 +4268,16 @@ export const startMirror = (deps) => {
             // 直接给出它的会话地址,比让人再查一次 list_chats 快。
             const asChat = chatBaseOf(cfg, t);
             if (asChat) {
+                // 裸聊天名 = 那个聊天的**默认 wizard**: 它的名字就是聊天名, peerAddress
+                // 印出来的地址也就是这个裸名字, 必须能原样喂回来 (此前这里一律报错, 于是
+                // 「名册里读到的地址」与「send_peer 收得下的地址」对不上)。
+                if (allTargets().includes(asChat)) {
+                    return { ok: true, target: asChat, foreign: asChat !== baseOfKey(self) };
+                }
                 return {
                     ok: false,
-                    reason: `'${t}' is a CHAT, not a tag — address one of its sessions, e.g. '${t}#' for its default`,
-                    candidates: allTargets().filter((k) => basePrincipalOf(k) === asChat).map((k) => peerAddress(cfg, self, k)),
+                    reason: `chat '${t}' has no default session — address one of its tagged sessions, or create it with new_claude_session({ chat: '${t}', cwd })`,
+                    candidates: allTargets().filter((k) => baseOfKey(k) === asChat).map((k) => peerAddress(cfg, self, k)),
                 };
             }
             return { ok: false, reason: `no peer with tag '#${t}' — create one with new_claude_session, or address it in full as 'chatName#${t}' (list_chats shows the names)` };
@@ -4261,14 +4293,14 @@ export const startMirror = (deps) => {
     const chatRoster = (self) => {
         const bases = new Set([
             ...listChatNames(cfg).map((c) => c.base),
-            ...allTargets().map(basePrincipalOf),
-            basePrincipalOf(self),
+            ...allTargets().map(baseOfKey),
+            baseOfKey(self),
         ]);
         return [...bases].filter(Boolean).sort().map((base) => ({
             base,
             name: chatNameOf(cfg, base),
-            self: base === basePrincipalOf(self),
-            targets: allTargets().filter((k) => basePrincipalOf(k) === base),
+            self: base === baseOfKey(self),
+            targets: allTargets().filter((k) => baseOfKey(k) === base),
         }));
     };
     const paneOf = (target) => byTarget.get(target)?.tmuxPane || deps.store.get(target)?.tmuxPane || "";
@@ -4318,7 +4350,7 @@ export const startMirror = (deps) => {
         const jsonlPath = jsonlOf(t);
         const pane = paneOf(t);
         const paneAlive = pane ? await tmuxPaneAlive(pane) : false;
-        const tag = tagOfTarget(t);
+        const tag = tagOfKey(t);
         let lastActivity = 0;
         try {
             if (jsonlPath)
@@ -4352,12 +4384,42 @@ export const startMirror = (deps) => {
     // `daily#fix` 命中)。后者是命名带来的新增量:同名 tag 不再互相遮蔽,想被找到
     // 只要给群起个名,不必回去改别人的 tag。
     const foreignPeers = async (self) => {
-        const selfBase = basePrincipalOf(self);
-        const foreign = allTargets().filter((k) => tagOfKey(k) && basePrincipalOf(k) !== selfBase);
+        const selfBase = baseOfKey(self);
+        const foreign = allTargets().filter((k) => tagOfKey(k) && baseOfKey(k) !== selfBase);
         const tagCount = foreign.reduce((acc, k) => acc.set(tagOfKey(k), (acc.get(tagOfKey(k)) ?? 0) + 1), new Map());
         const reachable = foreign.filter((k) => tagCount.get(tagOfKey(k)) === 1 || chatNameOf(cfg, k));
         return (await Promise.all(reachable.map((t) => peerInfoOf(t, self)))).sort(byRecent);
     };
+    // peerInfoOf 每个 target 要两次 tmux (pane 存活 + capture tail)。跑了几个月的
+    // 机器上 allTargets() 是几百个 —— 一次全量探活就是上千次 spawn, 足够打穿 fd
+    // 上限、把 tmux server 拖垮, 守护进程跟着崩进重启循环 (CLAUDE.md 的 fd 那一条
+    // 记的就是这个失效模式)。所以两道闸:
+    //   1. 先用**不 spawn 的**证据排序 —— transcript 的 mtime, 一次 statSync;
+    //      注册表里登记过的 wizard 无条件入选 (它们是有身份的那些, 也就那么几个)。
+    //   2. 探活并发封顶, 且只探前 WORLD_PROBE 个。
+    // 没被探到的照旧出现在名册里, 只是 busy/alive 按冷处理 —— 图上少一盏呼吸灯,
+    // 远好过把整台机器上的会话一起搞停。
+    const WORLD_PROBE = 48;
+    const WORLD_CONC = 6;
+    const worldPeers = async (self) => {
+        const mtimeOf = (t) => {
+            const p = jsonlOf(t);
+            if (!p)
+                return 0;
+            try {
+                return statSync(p).mtimeMs;
+            }
+            catch {
+                return 0;
+            }
+        };
+        const named = new Set(wizardStore()?.all().map((w) => w.target) ?? []);
+        const ranked = allTargets()
+            .map((t) => ({ t, ts: mtimeOf(t), named: named.has(t) }))
+            .sort((a, b) => (a.named !== b.named ? (a.named ? -1 : 1) : b.ts - a.ts));
+        const hot = ranked.slice(0, WORLD_PROBE).map((x) => x.t);
+        return (await mapLimit(hot, WORLD_CONC, (t) => peerInfoOf(t, self))).sort(byRecent);
+    };
     // Capture a few extra rows then compact away the TUI's blank padding, so
     // `rows` counts lines the user actually cares about.
     const peekPane = async (target, rows = 24) => {
@@ -4686,8 +4748,8 @@ export const startMirror = (deps) => {
             return { ok: false, reason: `当前确认框已是另一个调用（${now.toolName}），不代按` };
         }
         if (what === "no") {
-            await tmuxRun(["send-keys", "-t", a.tmuxPane, "Escape"]);
-            await sleepMs(MODAL_PRESS_SETTLE_MS);
+            await runTmux(["send-keys", "-t", a.tmuxPane, "Escape"]);
+            await sleep(MODAL_PRESS_SETTLE_MS);
             const after = await detectModalPicker(a.tmuxPane);
             return after.modal ? { ok: false, reason: "Escape 后确认框仍在" } : { ok: true, label: "Escape" };
         }
@@ -4707,6 +4769,7 @@ export const startMirror = (deps) => {
         chatTargets,
         peers,
         foreignPeers,
+        worldPeers,
         resolvePeerTag,
         chatRoster,
         peekPane,
@@ -4817,7 +4880,7 @@ export const startMirror = (deps) => {
                     if (a.recentToolSigs.has(expectSig))
                         break;
                     polls++;
-                    await sleepMs(50);
+                    await sleep(50);
                 }
                 if (!a.recentToolSigs.has(expectSig)) {
                     log.warn({ sessionId, polls, toolName: expect?.toolName }, "flushBeforeCard wait timed out — sending card without sig confirm");
@@ -4896,6 +4959,8 @@ export const startMirror = (deps) => {
             // resolve 之前就看到 user 行并开出 turn, 那时归因必须已经在位。
             if (origin)
                 a.pendingOrigin = { origin, at: Date.now() };
+            if (opts?.from)
+                a.pendingFrom = { from: opts.from, at: Date.now() };
             const sid = a.sessionId;
             const paneAlive = a.tmuxPane ? await tmuxPaneAlive(a.tmuxPane) : false;
             if (!paneAlive) {
@@ -4903,7 +4968,7 @@ export const startMirror = (deps) => {
                 // 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, model: a.model || undefined, systemPrompt: charterFor(target) });
+                const r = await spawnTmuxClaude({ cfg, log: log.child({ sub: "respawn-init", sessionId: sid }), resumeSessionId: sid, windowName: tagOfKey(target) || target, cwdOverride: a.runningCwd, cli: backendForPath(a.jsonlPath).name, model: a.model || undefined, systemPrompt: charterFor(target) });
                 if (!r.ok || !r.tmuxPane)
                     return { ok: false, reason: `respawn failed: ${r.reason ?? "unknown"}` };
                 a.tmuxPane = r.tmuxPane;
@@ -4964,7 +5029,7 @@ export const startMirror = (deps) => {
                 escReason = "tmux pane no longer alive";
             }
             else {
-                const r = await tmuxRun(["send-keys", "-t", a.tmuxPane, "Escape"]);
+                const r = await runTmux(["send-keys", "-t", a.tmuxPane, "Escape"]);
                 escOk = r.ok;
                 if (!r.ok)
                     escReason = `send-keys Escape failed: ${(r.stderr || r.stdout).slice(-200) || r.code}`;
@@ -4989,9 +5054,9 @@ export const startMirror = (deps) => {
             if (pane && (await tmuxPaneAlive(pane))) {
                 // Esc first, like /stop: a mid-generation CLI gets a beat to unwind and
                 // flush its transcript before the TTY is yanked out from under it.
-                await tmuxRun(["send-keys", "-t", pane, "Escape"]);
-                await sleepMs(250);
-                const r = await tmuxRun(["kill-pane", "-t", pane]);
+                await runTmux(["send-keys", "-t", pane, "Escape"]);
+                await sleep(250);
+                const r = await runTmux(["kill-pane", "-t", pane]);
                 if (r.code !== 0)
                     return { ok: false, reason: `kill-pane failed: ${r.stdout.slice(-200) || r.code}` };
             }
@@ -5014,7 +5079,7 @@ export const startMirror = (deps) => {
             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"]);
+            const r = await runTmux(["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");
@@ -5032,9 +5097,9 @@ export const startMirror = (deps) => {
             // switching a client that sits on an unrelated session would yank the
             // user's other terminal window into wezard. 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 s = await runTmux(["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 clients = await runTmux(["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;
@@ -5043,7 +5108,7 @@ export const startMirror = (deps) => {
                 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]);
+            const r = await runTmux(["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");
@@ -5063,7 +5128,7 @@ export const startMirror = (deps) => {
             const deadline = Date.now() + Math.max(0, opts.waitMs);
             let v = await detectModalPicker(pane);
             while (!v.modal && Date.now() < deadline) {
-                await sleepMs(POLL_MS);
+                await sleep(POLL_MS);
                 v = await detectModalPicker(pane);
             }
             // 没等到: 这次 CC 没弹框(会话内已授权过 / 命中盲点判断失误)。无事可做。
@@ -5116,7 +5181,7 @@ export const startMirror = (deps) => {
                 a = await restoreFromStore(principal);
             if (!a) {
                 try {
-                    await client.replyStream(frame, streamId, withSessionTag(principal, "[wezard] wecom remote control not attached — run `/wrc` inside the target Claude session"), true);
+                    await client.replyStream(frame, streamId, withTagHeader(principal, "[wezard] wecom remote control not attached — run `/wrc` inside the target Claude session"), true);
                 }
                 catch {
                     /* ignore */
@@ -5164,11 +5229,11 @@ export const startMirror = (deps) => {
                 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 tag = tagOfKey(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);
+                        await client.replyStream(frame, streamId, withTagHeader(a.target, `[mirror] 切换失败: ${r.reason ?? "unknown"}`), true);
                     }
                     catch { /* ignore */ }
                 }
@@ -5226,7 +5291,7 @@ export const startMirror = (deps) => {
             if (s) {
                 a.liveStream = s;
                 try {
-                    await client.replyStream(frame, streamId, withSessionTag(a.target, "…"), false);
+                    await client.replyStream(frame, streamId, withTagHeader(a.target, "…"), false);
                 }
                 catch (e) {
                     log.warn({ sessionId: a.sessionId, err: e.message }, "stream initial ack failed");
@@ -5271,7 +5336,7 @@ export const startMirror = (deps) => {
                     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, model: a.model || undefined, systemPrompt: charterFor(a.target) });
+                    const r = await spawnTmuxClaude({ cfg, log: log.child({ sub: "respawn", sessionId: sid }), resumeSessionId: sid, windowName: tagOfKey(a.target) || a.target, cwdOverride: a.runningCwd, cli: backendForPath(a.jsonlPath).name, model: a.model || undefined, systemPrompt: charterFor(a.target) });
                     if (r.ok && r.tmuxPane && r.tmuxSession) {
                         a.tmuxPane = r.tmuxPane;
                         a.tmuxSession = r.tmuxSession;
@@ -5341,7 +5406,7 @@ export const startMirror = (deps) => {
                         // /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);
+                            await client.replyStream(frame, streamId, withTagHeader(a.target, "clean"), true);
                         }
                         catch { /* ignore */ }
                     }
@@ -5384,8 +5449,8 @@ export const startMirror = (deps) => {
                 // "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"]);
+                    await sleep(1000);
+                    const e = await runTmux(["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");
                 }
@@ -5430,7 +5495,7 @@ export const installMirrorEventListener = (client, bridge, log) => {
             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);
+                    const content = withTagHeader(detail.target, md, n > 1 ? `${i + 1}/${n}` : undefined);
                     await client.sendMessage(chatId, { msgtype: "markdown", markdown: { content } });
                 }
                 catch (e) {