wezard 1.3.23 → 1.4.1

package/dist/daemon/mirror-bridge.js

@@ -16,40 +16,24 @@ 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 } 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 { 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, parseTagHeader } from "../shared/session-label.js";
+import { labelFor, tagOfKey, baseOfKey, keyOf, withTagHeader, headSep, parseTagHeader } from "../shared/session-label.js";
 import { splitMarkdown } from "../shared/md-chunk.js";
 import { randomTip } from "./tips.js";
 import { chatBaseOf, chatNameOf, listChatNames, normChatName, parsePeerRef, peerAddress } from "./chat-name.js";
 import { stripAnsi, compactPane, paneIsBusy, paneIsStalled, transcriptStalled, summarizeTail, lastAssistantText, lastContextTokens, keepaliveStamps, tailTurns, renderDialog } from "./peers.js";
 // 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
@@ -263,15 +247,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>
@@ -329,7 +304,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>)。只认"整条消息以它开头", 免得把正文里提到它的消息吞掉。
@@ -370,7 +344,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 "{}";
@@ -392,7 +366,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>`,
@@ -536,7 +510,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。
@@ -703,7 +677,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;
@@ -831,8 +804,6 @@ export const startMirrorTail = (deps) => {
 // 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));
 // 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.
@@ -954,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
@@ -1042,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");
@@ -1059,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;
@@ -1069,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
@@ -1096,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 死了立即失败。
@@ -1109,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" };
@@ -1134,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}` };
@@ -1164,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
@@ -1218,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
@@ -1229,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
@@ -1246,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 };
@@ -1260,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) => {
@@ -1572,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",
@@ -1589,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) {
@@ -1671,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 "";
@@ -1683,9 +1692,9 @@ export const startMirror = (deps) => {
         const prefix = linkedTagPrefix(a.target, turnId ?? a.briefTurnId);
         if (prefix) {
             const seqBit = seq ? ` ${seq}` : "";
-            return `${prefix}${seqBit} ${content}`;
+            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 包装) 是最后一道
@@ -1696,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 () => {
@@ -1711,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;
@@ -1905,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");
@@ -2049,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, 让后续
@@ -2109,12 +2118,15 @@ export const startMirror = (deps) => {
         a.pendingOrigin = undefined;
         return p && Date.now() - p.at <= ORIGIN_TTL_MS ? p.origin : undefined;
     };
+    // 详情页要按后端的名字称呼它 ("Claude 正在思考" / "CodeBuddy 正在思考") —— 后端
+    // 由 transcript 落盘路径唯一确定, 所以每次开 turn 时现算, 不必额外记在 AttachState 上。
+    const cliOf = (a) => a.jsonlPath ? backendForPath(a.jsonlPath).name : undefined;
     const startBriefTurn = async (a, frame, streamId, isSlash = false, userQuery = "") => {
         const turnId = newTurnId();
         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, 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) });
         // hardTimer 兜底: turn 若无终句 / turn_end 收口 (卡死/漏收), 到点仍收气泡。
         const bubble = { frame, streamId, hardTimer: undefined, done: false };
         const q = { turnId, bubble, isSlash };
@@ -2160,7 +2172,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, 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) });
         a.briefTurnId = turnId;
         a.briefBubble = undefined;
         a.briefIsSlash = false;
@@ -2311,6 +2323,7 @@ export const startMirror = (deps) => {
                 id: turnId,
                 target: a.target,
                 sessionId: a.sessionId,
+                cli: cliOf(a),
                 cwd: a.runningCwd || undefined,
                 userQuery: task,
                 agent: { id: agentId, type: resolved?.type, description: resolved?.description, parentTurnId: a.briefTurnId },
@@ -2665,7 +2678,7 @@ export const startMirror = (deps) => {
         if (!a.keepaliveTurnId) {
             const turnId = newTurnId();
             a.keepaliveTurnId = turnId;
-            recordTurnStart({ id: turnId, target: a.target, sessionId: a.sessionId, userQuery: text });
+            recordTurnStart({ id: turnId, target: a.target, sessionId: a.sessionId, cli: cliOf(a), userQuery: text });
         }
     };
     // A keepalive ping turn is swallowed wholesale — the reply content doesn't
@@ -2831,7 +2844,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}` };
                         },
                     });
@@ -2882,13 +2895,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 };
                         },
@@ -3057,7 +3070,7 @@ export const startMirror = (deps) => {
     const detailUrlFor = (id, principal) => cfg.daemon.detailLinksInMirror && id
         ? buildDetailUrl(cfg.daemon.detailPublicBase, cfg.daemon.host, cfg.daemon.port, id, principal ? stripPrincipalPrefix(principal) : undefined)
         : "";
-    const attach = ({ sessionId, jsonlPath, target: targetOverride, tmuxPane, tmuxSession, cwd, pendingCwd }) => {
+    const attach = ({ sessionId, jsonlPath, target: targetOverride, tmuxPane, tmuxSession, cwd, model, pendingCwd }) => {
         const target = resolveTarget(targetOverride);
         if (!target)
             return { ok: false, reason: "no target chat (set wrc.mirror.pushChat or defaultChat, or pass target)" };
@@ -3083,6 +3096,10 @@ export const startMirror = (deps) => {
         // otherwise. `undefined` (omitted) → carry from prev (re-attach case);
         // `""` → explicit clear (newSession just consumed it); `"/foo"` → set.
         const carryPending = pendingCwd !== undefined ? pendingCwd : (prevByTarget?.pendingCwd ?? "");
+        // Same carry rule as pendingCwd, and for the same reason: a spawn knows the
+        // model it asked for (possibly "" = CLI default) and says so; a re-attach
+        // onto an already-running pane doesn't, so it keeps what was recorded.
+        const carryModel = model !== undefined ? model.trim() : (prevByTarget?.model ?? deps.store.get(target)?.model ?? "");
         if (prevByTarget)
             detach(prevByTarget, "target reassigned");
         // Build the attachment first so the tail's onItem closure can capture it.
@@ -3097,6 +3114,7 @@ export const startMirror = (deps) => {
             // collapsing to cfg.wrc.cwd (which would mislabel /pwd, /clear, /new).
             runningCwd: expandHome(((cwd ?? "").trim()) || readCwdFromJsonl(jsonlPath) || cfg.wrc.cwd),
             pendingCwd: carryPending,
+            model: carryModel,
             tail: { stop: () => undefined, drain: () => undefined, livePath: () => undefined }, // placeholder; replaced below
             standalonePending: Promise.resolve(),
             recentToolSigs: new Map(),
@@ -3133,6 +3151,7 @@ export const startMirror = (deps) => {
             tmuxSession: a.tmuxSession || undefined,
             tmuxPane: a.tmuxPane || undefined,
             cwd: a.runningCwd || undefined,
+            model: a.model || undefined,
             pendingCwd: a.pendingCwd || undefined,
             keepaliveOff: prevRec?.keepaliveOff,
             keepaliveOffAt: prevRec?.keepaliveOffAt,
@@ -3151,7 +3170,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
@@ -3244,7 +3263,7 @@ 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 cwdRes = await runTmux(["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
@@ -3271,6 +3290,7 @@ export const startMirror = (deps) => {
             tmuxPane: livePane,
             tmuxSession: rec.tmuxSession ?? "",
             cwd: rec.cwd,
+            model: rec.model,
             pendingCwd: rec.pendingCwd,
         });
         if (!r.ok) {
@@ -3336,10 +3356,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();
@@ -3357,6 +3377,15 @@ export const startMirror = (deps) => {
         const t = text.trim();
         return t === "/clear" || t.startsWith("/clear ") || t.startsWith("/clear\n");
     };
+    /** mtime(ms), 0 when unreadable — "newest transcript wins" 的排序键。 */
+    const mtimeOf = (path) => {
+        try {
+            return statSync(path).mtimeMs;
+        }
+        catch {
+            return 0;
+        }
+    };
     const listJsonls = (dir) => {
         try {
             return new Set(readdirSync(dir).filter((n) => n.endsWith(".jsonl")));
@@ -3675,7 +3704,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() : "";
@@ -3753,7 +3782,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();
@@ -3812,7 +3841,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
@@ -3821,7 +3850,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 {
@@ -3832,6 +3861,20 @@ export const startMirror = (deps) => {
     // /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.
+    // 身份提供者。newSession / 重生 / clone 全都从这里取「这个 target 是谁」, 于是
+    // 无论是群里手打的 /new、pane 死了的自愈重生, 还是编排生出来的分身, 新进程一
+    // 睁眼就知道自己是谁 —— 而不是只有走 wizard 路由那一条路才有身份。
+    // 由 index.ts 在启动时装上 (注册表活在那边); 没装 = 退回无身份行为, 全链路无回归。
+    let charterOf;
+    const setCharterProvider = (fn) => { charterOf = fn; };
+    const charterFor = (target) => {
+        try {
+            return charterOf?.(target);
+        }
+        catch {
+            return undefined;
+        }
+    };
     const newSession = async (target, windowName, cli, opts) => {
         const prev = byTarget.get(target);
         // Resolution precedence (all chat-scoped except the running-cwd fallback):
@@ -3859,13 +3902,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");
@@ -3876,6 +3919,7 @@ export const startMirror = (deps) => {
             cwdOverride: eff,
             cli: effCli,
             model: opts?.model,
+            systemPrompt: opts?.systemPrompt ?? charterFor(target),
         });
         if (!r.ok)
             return { ok: false, reason: r.reason };
@@ -3888,6 +3932,9 @@ export const startMirror = (deps) => {
             cwd: r.cwd,
             // Explicit "" clears any carried-over pending — it has just been applied.
             pendingCwd: "",
+            // Likewise explicit: `/new` starts a NEW session, so an unnamed model
+            // means this CLI's default, not the dead pane's model.
+            model: opts?.model?.trim() ?? "",
         });
         if (!att.ok)
             return { ok: false, reason: att.reason };
@@ -3935,6 +3982,133 @@ export const startMirror = (deps) => {
             pushProjectInfo(target, "created");
         return { ok: true, sessionId: r.sessionId, cwd: r.cwd };
     };
+    // ── Clone ───────────────────────────────────────────────────────────
+    // 分身 = `--resume <父 sid> --fork-session` 起的新 pane: CLI 把父亲的 transcript
+    // 复制成一份新的再继续写, 于是子进程开局就带着父亲此刻读过的一切 (规范、目录、
+    // 刚啃完的那份文档), 而父亲毫发无损。这正是「先把公共材料载进一个基座, 再从它
+    // 身上分出 N 个干活的」所需要的语义: 材料只读一遍, 却进了 N 份上下文。
+    //
+    // 两件事非做不可:
+    //   `--fork-session` —— 少了它, 这个 pane 会**续写父亲的 jsonl**。两个 pane 写
+    //     同一个 transcript, 两个 target 指向同一个 sid, 群与群从此串线且无法回滚。
+    //   先说话再 attach —— 分叉文件不是开机就有的, CLI 在收到第一条消息那一刻才写。
+    //     所以 spawn 之后先注入开场白, 等分叉出现拿到它自己的 sid, 再 attach。等不到
+    //     就把 pane 一起收掉: 那时唯一已知的 sid 是父亲的, 认下去就是上面那种串线
+    //     (attach 也会正当地拒绝), 一个干净的失败远比一条错绑好收拾。
+    const FORK_POLL_MS = 400;
+    const FORK_WAIT_MS = 45_000;
+    const awaitFork = async (projectDir, baseline, claimed) => {
+        const deadline = Date.now() + FORK_WAIT_MS;
+        while (Date.now() < deadline) {
+            const born = [...listJsonls(projectDir)]
+                .filter((n) => !baseline.has(n) && !claimed.has(n.replace(/\.jsonl$/, "")))
+                .map((n) => ({ n, path: join(projectDir, n) }))
+                // 种子化的 fork 一落地就带着父亲的 user 行 —— 空文件 (刚 touch 出来的)
+                // 还不能认, 认早了 tail 会从一个还没写完的复制过程中间开始读。
+                .filter((c) => firstUserUuid(c.path) !== undefined)
+                .sort((x, y) => mtimeOf(y.path) - mtimeOf(x.path));
+            const hit = born[0];
+            if (hit)
+                return { sessionId: hit.n.replace(/\.jsonl$/, ""), jsonlPath: hit.path };
+            await sleep(FORK_POLL_MS);
+        }
+        return undefined;
+    };
+    const cloneSession = async (args) => {
+        const p = byTarget.get(args.parent) ?? (await restoreFromStore(args.parent));
+        // 继承上下文要求父亲有一个活着的 transcript, 且分身必须待在同一个项目目录 ——
+        // `--resume` 是按项目目录寻址 session 的。调用方点名换目录 = 明确放弃继承。
+        const sameCwd = !args.cwd?.trim() || expandHome(args.cwd.trim()) === (p?.runningCwd ?? "");
+        const canInherit = args.inherit !== false && !!p?.sessionId && !!p.jsonlPath && existsSync(p.jsonlPath) && sameCwd;
+        if (!canInherit) {
+            const r = await newSession(args.target, args.windowName, args.cli, {
+                model: args.model, cwd: args.cwd, systemPrompt: args.systemPrompt, silent: true,
+            });
+            return { ...r, inherited: false };
+        }
+        const parent = p;
+        const projectDir = dirname(parent.jsonlPath);
+        const baseline = listJsonls(projectDir);
+        const lg = log.child({ sub: "clone", target: args.target });
+        const r = await spawnTmuxClaude({
+            cfg,
+            log: lg,
+            resumeSessionId: parent.sessionId,
+            forkSession: true,
+            windowName: args.windowName ?? args.target,
+            cwdOverride: parent.runningCwd,
+            cli: backendForPath(parent.jsonlPath).name,
+            model: args.model,
+            systemPrompt: args.systemPrompt,
+        });
+        if (!r.ok)
+            return { ok: false, reason: r.reason, inherited: false };
+        // 分叉文件不是开机就有的: CLI 在这个 pane **收到第一条消息**的那一刻才把父亲的
+        // transcript 复制成新文件。所以必须先说一句话, 分身才会有自己的 sid —— 这句话
+        // 顺便就是它的开场白 (「你是谁、继承了什么、准备接什么」), 群里看到的第一条也是它。
+        const hello = args.bootstrap?.trim()
+            || "（wezard 分身初始化）用一句话说明: 你是谁、从谁那里继承了哪些上下文、准备接什么活。不要复述这条指令。";
+        rememberInject(hello);
+        const boot = await inject({
+            text: hello, images: [], cfg, log: lg,
+            sessionId: parent.sessionId, jsonlPath: parent.jsonlPath,
+            tmuxTarget: r.tmuxPane, freshSpawn: true,
+        });
+        if (!boot.ok) {
+            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));
+        // 等不到分叉就必须收手: 此刻唯一已知的 sid 是父亲的, 认下去两个 target 会指向
+        // 同一个会话 (attach 也会正当地拒绝)。留一个孤儿 pane 比留一条错绑更好收拾 ——
+        // 所以连 pane 一起杀掉, 调用方拿到的是一个干净的失败。
+        if (!fork) {
+            await runTmux(["kill-pane", "-t", r.tmuxPane ?? ""]);
+            return { ok: false, reason: "分身没能在超时内分叉出自己的会话 (CLI 可能不支持 --fork-session)", inherited: false };
+        }
+        const att = attach({
+            sessionId: fork.sessionId,
+            jsonlPath: fork.jsonlPath,
+            target: args.target,
+            tmuxPane: r.tmuxPane,
+            tmuxSession: r.tmuxSession,
+            cwd: r.cwd,
+            pendingCwd: "",
+            model: args.model?.trim() ?? "",
+        });
+        if (!att.ok)
+            return { ok: false, reason: att.reason, inherited: false };
+        const spawned = byTarget.get(args.target);
+        if (spawned) {
+            // muteUntilInject 是给"全新 pane 的 greeting 噪音"准备的; 分身的开场白是正经
+            // 内容 (群里第一条就该是它), 所以这里不静音。
+            spawned.justSpawned = true;
+            spawned.keepaliveOff = true;
+            spawned.keepaliveOffAt = Date.now();
+            spawned.keepalive = undefined;
+            persistPause(spawned);
+        }
+        lg.info({ parent: args.parent, sessionId: fork.sessionId }, "clone: forked");
+        return { ok: true, sessionId: fork.sessionId, cwd: r.cwd, inherited: true };
+    };
+    /** 一个会话此刻的硬事实 —— whoami / 交接判断要用的那几个数。 */
+    const sessionInfo = (target) => {
+        const a = byTarget.get(target);
+        const rec = a ? undefined : deps.store.get(target);
+        const sessionId = a?.sessionId ?? rec?.sessionId ?? "";
+        const jsonlPath = a?.jsonlPath ?? (rec?.jsonlPath ? expandHome(rec.jsonlPath) : "");
+        if (!sessionId || !jsonlPath)
+            return undefined;
+        return {
+            sessionId,
+            jsonlPath,
+            cwd: a?.runningCwd || rec?.cwd || "",
+            cli: backendForPath(jsonlPath).name,
+            model: a?.model || rec?.model || "",
+            tmuxPane: a?.tmuxPane ?? rec?.tmuxPane ?? "",
+            contextTokens: lastContextTokens(jsonlPath),
+        };
+    };
     const getCwd = (target) => {
         // pendingCwd is chat-scoped — a `set_workspace` from any sibling session
         // queues the switch for the whole chat. runningCwd stays per-session (each
@@ -3960,7 +4134,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);
@@ -4018,8 +4192,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 出错时"我该写什么"比"你写错了"有用得多。
@@ -4052,21 +4226,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 })`,
-                candidates: allTargets().filter((k) => basePrincipalOf(k) === c.base),
+                // 候选给**地址**而不是裸 key —— 这份清单存在的意义就是让调用方照着改一个
+                // 能用的串; 隔壁两个分支早就这么做了, 只有这一条漏掉。
+                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) {
@@ -4077,7 +4253,7 @@ export const startMirror = (deps) => {
                 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)),
+                    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)` };
@@ -4093,14 +4269,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 || "";
@@ -4150,7 +4326,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)
@@ -4167,6 +4343,7 @@ export const startMirror = (deps) => {
             jsonlPath,
             cwd: a?.runningCwd || rec?.cwd || expandedDefaultCwd,
             cli: jsonlPath ? backendForPath(jsonlPath).name : (activeBackends()[0]?.name ?? "claude"),
+            model: a?.model || rec?.model || "",
             tmuxPane: pane,
             attached: !!a,
             paneAlive,
@@ -4183,8 +4360,8 @@ 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);
@@ -4289,7 +4466,7 @@ export const startMirror = (deps) => {
         if (!a.keepaliveTurnId) {
             const turnId = newTurnId();
             a.keepaliveTurnId = turnId;
-            recordTurnStart({ id: turnId, target: a.target, sessionId: a.sessionId, userQuery: text });
+            recordTurnStart({ id: turnId, target: a.target, sessionId: a.sessionId, cli: cliOf(a), userQuery: text });
         }
     };
     let keepaliveTicking = false;
@@ -4517,8 +4694,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" };
         }
@@ -4648,7 +4825,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");
@@ -4702,7 +4879,7 @@ export const startMirror = (deps) => {
                 // 队列内单条失败已在 sendStandalone 里 warn 过, 这里吞掉, 不阻塞发卡。
             }
         },
-        injectText: async (target, text, origin) => {
+        injectText: async (target, text, origin, opts) => {
             // 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
@@ -4712,10 +4889,17 @@ export const startMirror = (deps) => {
                 return { ok: false, reason: "no mirror attached for target" };
             if (!text.trim())
                 return { ok: false, reason: "empty text" };
+            // 出处改写要早于 inject: tail 可能在 promise resolve 之前就开出 turn。
+            if (opts?.fromChat)
+                a.turnFromChat = true;
+            // 名册增量搭这趟车进去 —— 同伴派活 / 定时任务 / graph 步骤都走这里, 所以
+            // 一个从不被人直接说话的分身也能知道群里多了谁、少了谁。人说的话那一条
+            // 路径在 inbound.send 上挂 (dispatch 有自己的 inject)。
+            const full = text + noticeSuffixFor(target, 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);
+            rememberInject(full);
             // 印章要早于 inject 落地 —— tail 是独立轮询的, 它可能在 inject 的 promise
             // resolve 之前就看到 user 行并开出 turn, 那时归因必须已经在位。
             if (origin)
@@ -4727,14 +4911,14 @@ 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 });
+                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;
                 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 });
+                deps.store.set(target, { sessionId: sid, jsonlPath: a.jsonlPath, tmuxSession: a.tmuxSession, tmuxPane: a.tmuxPane, cwd: a.runningCwd || undefined, model: a.model || undefined, pendingCwd: a.pendingCwd || undefined });
                 startMigrationWatcher(a, resumeBaseline, (p) => firstUserUuid(p) !== undefined);
             }
             // freshSpawn: true — the pane was just minted by /mirror/spawn, the TUI
@@ -4743,7 +4927,7 @@ export const startMirror = (deps) => {
             a.muteUntilInject = false;
             a.justSpawned = false;
             const r = await inject({
-                text, images: [], cfg, log: log.child({ principal: target, sessionId: sid, sub: "init-demo" }),
+                text: full, images: [], cfg, log: log.child({ principal: target, sessionId: sid, sub: "init-demo" }),
                 sessionId: sid, jsonlPath: a.jsonlPath, tmuxTarget: a.tmuxPane, freshSpawn: true,
             });
             return r;
@@ -4788,7 +4972,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}`;
@@ -4813,9 +4997,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}` };
             }
@@ -4838,7 +5022,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");
@@ -4856,9 +5040,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;
@@ -4867,7 +5051,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");
@@ -4887,7 +5071,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 没弹框(会话内已授权过 / 命中盲点判断失误)。无事可做。
@@ -4911,6 +5095,9 @@ export const startMirror = (deps) => {
         getCwd,
         setPendingCwd,
         newSession,
+        cloneSession,
+        sessionInfo,
+        setCharterProvider,
         shutdown: () => {
             clearInterval(paneDriftTimer);
             clearInterval(keepaliveTimer);
@@ -4937,7 +5124,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 */
@@ -4985,11 +5172,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 */ }
                 }
@@ -5047,7 +5234,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");
@@ -5092,7 +5279,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 });
+                    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;
@@ -5105,6 +5292,7 @@ export const startMirror = (deps) => {
                             tmuxSession: a.tmuxSession,
                             tmuxPane: a.tmuxPane,
                             cwd: a.runningCwd || undefined,
+                            model: a.model || undefined,
                             pendingCwd: a.pendingCwd || undefined,
                         });
                         log.info({ target: a.target, sessionId: sid, newPane: a.tmuxPane, newSession: a.tmuxSession }, "mirror: tmux respawned");
@@ -5161,7 +5349,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 */ }
                     }
@@ -5204,8 +5392,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");
                 }
@@ -5250,7 +5438,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) {