wezard 1.4.2 → 2.0.1

package/dist/daemon/mirror-bridge.js

@@ -20,20 +20,21 @@ 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 { bindCardChannel, 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, spawnTmuxClaude } from "./spawn-tmux.js";
+import { hasRegistry, markTranscript, probeOf, sessionOnPane, submittedSince } from "./cc-session.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";
+import { labelFor, tagOfKey, baseOfKey, keyOf, stripSigil, displayName, withTagHeader, withLinkedTagHeader, linkedTagHead, linkTags, parseTagHeader, MAX_BODY_LINKS } 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 { chatBaseOf, chatNameOf, listChatNames, 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
+// PATH augmentation: launchd / systemd start the daemon
 // with a stripped PATH that often lacks nvm / homebrew, breaking spawn(claudeBin).
 // Backend resolution is per-transcript, not global: `backendForPath` recovers
 // which CLI wrote a jsonl from its projects root, so claude / claude-internal /
@@ -44,7 +45,7 @@ import { stripAnsi, compactPane, paneIsBusy, paneIsStalled, transcriptStalled, s
 // jsonl line carries a `cwd` field; the encoded directory name is lossy (both
 // `/` and `.` collapse to `-`) so it can't be reversed — reading the file is
 // the only faithful path. Used as the middle tier in attach()'s cwd resolution
-// so /wrc-attached sessions reflect their real project in /pwd, /clear, /new,
+// so sessions attached without an explicit cwd (switch / restore) reflect their real project in /pwd, /clear, /new,
 // instead of falling back to the global cfg.wrc.cwd.
 const readCwdFromJsonl = (path) => {
     try {
@@ -678,9 +679,10 @@ 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.
-// 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;
+// Room reserved in every chunk for the `emoji \`#tag\` \`2/5\`` header line and
+// the chat-detail links linkTags hangs on it and on up to MAX_BODY_LINKS body
+// mentions — each `(url)` runs ~200-250 bytes.
+const TAG_HEADER_BUDGET = 256 * (1 + MAX_BODY_LINKS);
 export const startMirrorTail = (deps) => {
     const { log } = deps;
     // A single logical tail follows ONE sessionId whose transcript file may move
@@ -1171,12 +1173,80 @@ export const parseInputBox = (cap) => {
 };
 // 24 行足够容纳展开后的多行粘贴 (折叠态只占一行)。
 const readInputBox = async (target) => parseInputBox(await capturePaneTail(target, 24));
+// ── 注入门控的会话证人 (cc-session) ─────────────────────────────────
+// 能从会话自己写的 json 读到的判据, 就不读 pane: 就绪看注册表的 status, 提交看
+// 注册表的 busy 翻转或 jsonl 里新落的那一行。输入框里「贴进去没有」是唯一只有
+// pane 知道的事 (未提交的输入不落任何盘), 那一段仍旧 capture。
+const SHELL_RE = /^-?(zsh|bash|sh|fish|dash|ksh|tcsh|csh)$/;
+/** pane 前台是个 shell = 里面的 AI 会话已经退出 (或从没起来)。只读 tmux 元数据, 不读屏。 */
+const paneRunsShell = async (target) => {
+    const r = await runTmux(["display-message", "-p", "-t", target, "#{pane_current_command}"]);
+    return r.ok && SHELL_RE.test(r.stdout.trim());
+};
+/** pane 活着且里面住着 AI 会话。注册表认得它就是; 不认得时只在前台确是 shell 才判否 ——
+ *  注册表缺席 (codebuddy / 旧版 CC / 进程不在 tmux 里记的行) 不能被当成会话不在。 */
+const paneHostsSession = async (target, homeDir) => !hasRegistry(homeDir) || sessionOnPane(homeDir, target) !== undefined || !(await paneRunsShell(target));
+const SESSION_READY_TIMEOUT_MS = 15_000;
+/** 冷 pane 等注册表报 idle (会话建好、输入框等人); 热 pane 只核一次会话还在 —— 忙也照贴,
+ *  CC 会把它排进队列。等不到 idle 不算失败 (贴后校验会兜), 前台退回 shell 才算:
+ *  往 shell 里贴 = 把用户的话当命令执行。 */
+const awaitSession = async (target, homeDir, fresh, log) => {
+    if (!hasRegistry(homeDir))
+        return { ok: true };
+    const deadline = Date.now() + (fresh ? SESSION_READY_TIMEOUT_MS : 0);
+    const poll = async () => {
+        const s = sessionOnPane(homeDir, target);
+        if ((s && (!fresh || s.status === "idle")) || Date.now() >= deadline)
+            return s;
+        await sleep(200);
+        return poll();
+    };
+    const live = await poll();
+    if (live) {
+        if (fresh && live.status !== "idle")
+            log.warn({ target, status: live.status }, "mirror inject: 会话未报 idle, 按贴后校验兜底继续");
+        return { ok: true, live };
+    }
+    if (await paneRunsShell(target)) {
+        log.warn({ target }, "mirror inject: pane 前台是 shell, AI 会话不在, 拒绝注入");
+        return { ok: false, reason: "目标 pane 里的 AI 会话已退出 (前台是 shell), 消息未送达。重发即会在新 pane 里恢复该会话。" };
+    }
+    return { ok: true };
+};
+const NO_WITNESS = { status: "", submitted: () => false };
+/** 贴之前给会话可能落盘的 jsonl 打书签: 绑定的那份, 加上注册表报的当前 sid 那份
+ *  (resume / fork 会换 sid)。提交后 sid 若又变了, 新文件从 0 读 —— 时间门挡掉 fork 里的旧话。 */
+const witnessFor = (target, homeDir, jsonlPath, live) => {
+    if (!live)
+        return NO_WITNESS;
+    const dir = dirname(jsonlPath);
+    const marks = new Map([jsonlPath, join(dir, `${live.sessionId}.jsonl`)].map((p) => [p, markTranscript(p)]));
+    return {
+        status: live.status,
+        submitted: (probe, since, enterAt) => {
+            const now = sessionOnPane(homeDir, target);
+            if (now && live.status !== "busy" && now.status === "busy" && now.statusUpdatedAt >= enterAt)
+                return true;
+            const p = now && join(dir, `${now.sessionId}.jsonl`);
+            if (p && !marks.has(p))
+                marks.set(p, { path: p, offset: 0 });
+            return submittedSince([...marks.values()], probe, since);
+        },
+    };
+};
 // 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. 校验策略见 injectViaTmuxText —— 以输入框
 // 整块为判据, 粘贴只在「确凿看见框仍是空的」时才重来。
-const injectViaTmux = async (target, text, images, log, freshSpawn, backendName, bypassModalGuard = false) => {
+const injectViaTmux = async (target, text, images, log, freshSpawn, backend, jsonlPath, bypassModalGuard = false) => {
+    const backendName = backend.name;
     log.info({ target, len: text.length, images: images.length, freshSpawn, backendName }, "mirror inject (tmux)");
+    // 就绪门: pane 里得真有一个进入了交互态的 AI 会话, 才轮得到贴。先于 modal guard ——
+    // 这一步只读注册表, 会话都不在时也就不必去 capture pane 找对话框了。
+    const gate = await awaitSession(target, backend.homeDir, freshSpawn, log);
+    if (!gate.ok)
+        return gate;
+    const witness = witnessFor(target, backend.homeDir, jsonlPath, gate.live);
     // Never type into a modal picker (see detectModalPicker). Checked before the
     // image pump too — a C-v into a picker is just as destructive as a paste.
     // 必须在按后端分流之前: 每个后端都有自己的原生确认框, 往任何一个里打字都会
@@ -1209,7 +1279,7 @@ const injectViaTmux = async (target, text, images, log, freshSpawn, backendName,
     if (backendName === "codebuddy") {
         const refs = images.map((p) => `@${p}`);
         const textWithRefs = refs.length ? (text ? `${refs.join("\n")}\n${text}` : refs.join("\n")) : text;
-        return injectViaTmuxText(target, textWithRefs, log, freshSpawn);
+        return injectViaTmuxText(target, textWithRefs, log, freshSpawn, witness);
     }
     // Pump images first via clipboard+C-v so each one is attached as a separate
     // image content block. Each C-v needs a brief settle for Claude Code's TUI
@@ -1235,18 +1305,22 @@ const injectViaTmux = async (target, text, images, log, freshSpawn, backendName,
         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);
+    return injectViaTmuxText(target, text, log, freshSpawn, witness);
 };
 // 文本 paste + Enter 提交 + 自校验。从 injectViaTmux 抽出来，让 codebuddy
 // 后端的 @<path> 回退路径也能复用同样的 paste-verify 逻辑。
 //
-// 两个判据都以**输入框整块**为准 (parseInputBox), 指纹只是认不出布局时的退路:
-//   1. 贴完轮询「框变了」→ 粘贴已被 TUI 消化 (折叠成占位符也算)。这是个**正**
-//      信号, 只有确凿看见框仍是贴之前的样子才重贴 —— 存疑一律不重贴, 多贴一次
-//      的代价 (两份提示叠进同一个输入框) 远高于少贴一次。
-//   2. 回车后轮询「框回到贴之前的样子」→ 提交被吃下了。框认得出来时这条判据可
-//      信, 于是允许多补一次回车 (空框上的回车在 CLI 里是 no-op)。
-const injectViaTmuxText = async (target, text, log, freshSpawn) => {
+// 贴 —— 只有 pane 知道 (未提交的输入不落任何盘), 以**输入框整块**为准 (parseInputBox),
+// 指纹只是认不出布局时的退路:
+//   1. 框里已经躺着这段文本 (上一次注入回车被吞 / 被 watchdog 掐断) → 不再贴第二份, 直接提交。
+//   2. 贴完轮询「框变了」→ 粘贴已被 TUI 消化 (折叠成占位符也算)。这是个**正**信号,
+//      只有确凿看见框仍是贴之前的样子、且会话也没收到这段话, 才重贴 —— 存疑一律不重贴,
+//      多贴一次的代价 (两份提示叠进同一个输入框) 远高于少贴一次。
+// 交 —— 先问会话证人 (注册表 busy 翻转 / jsonl 新落的提交行), 确认了就完事, 不碰 pane;
+// 证人不作声 (忙时排队、slash 命令、无注册表的后端) 才看框回没回到贴之前的样子。
+// 框认得出来时这条判据可信, 于是允许多补回车 (空框上的回车在 CLI 里是 no-op);
+// 每次补之前再问一遍证人, 已提交就不补。
+const injectViaTmuxText = async (target, text, log, freshSpawn, witness = NO_WITNESS) => {
     // Warm pane: tight timings, low latency. Fresh spawn (claude --resume just
     // started, transcript still loading): extended timings — bracketed-paste
     // end can take 4-7s to be honored on a cold TUI. Only the fresh-spawn path
@@ -1256,17 +1330,30 @@ 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;
+    // 回车后先只问证人这么久: CC 提交即落盘, 通常 <200ms。证人注定不作声的场合
+    // (会话正忙 → 只是排队; slash 命令 → 不一定落 user 行) 不空等, 直接看框。
+    const witnessQuiet = witness.status === "" || witness.status === "busy" || text.trimStart().startsWith("/");
+    const WITNESS_ONLY_MS = witnessQuiet ? 0 : freshSpawn ? 2500 : 1000;
     const { headFp, tailFp } = fingerprints(text);
+    const probe = probeOf(text);
     const POLL_MS = 100;
     const stripWs = (s) => s.replace(/\s+/gu, "");
+    // 时间门往前放 1s: jsonl 的 timestamp 与本机时钟同源, 只差写盘的毫秒。
+    const since = Date.now() - 1000;
+    let enterAt = Number.POSITIVE_INFINITY;
+    const submitted = () => witness.submitted(probe, since, enterAt);
     // 贴之前框里是什么: 空框、幽灵提示 (`Try "how do I log an error?"`)、甚至用户
     // 自己敲了一半的字 —— 一律作为基线, 免得去维护一张「哪些文案算空」的清单。
     const preBox = await readInputBox(target);
     // 基线读不出来 (框被模态顶掉 / 正在重绘) 就整条退回指纹法: 没有基线,「框变了」
     // 无从谈起, 而把幽灵提示 (`Try "…"`) 误当成「贴进去了」会让这条消息静静消失。
     const boxVerify = preBox.known;
+    // 去重: 框里已经是这段文本 —— 上一次注入贴上了却没交出去。再贴就是两份。
+    const alreadyTyped = boxVerify && Boolean(probe) && stripWs(preBox.body).includes(probe);
+    // 提交后框该回到的样子: 正常是贴之前的基线; 文本本就在框里时基线就是它, 只能以「空」为准。
+    const baseBody = alreadyTyped ? "" : preBox.body;
     /** 框里还是贴之前那样 (或彻底空了) = 我们的文本不在框里。 */
-    const boxIntact = (b) => boxVerify && b.known && (b.body === "" || b.body === preBox.body);
+    const boxIntact = (b) => boxVerify && b.known && (b.body === "" || b.body === baseBody);
     const loadAndPaste = async () => {
         // stdin variant of the shared exec path — it carries the same hard timeout,
         // which a hand-rolled spawn here did not.
@@ -1278,9 +1365,6 @@ const injectViaTmuxText = async (target, text, log, freshSpawn) => {
             return { ok: false, reason: `tmux paste-buffer failed: ${pasted.stderr.slice(-200)}` };
         return { ok: true };
     };
-    let r = await loadAndPaste();
-    if (!r.ok)
-        return r;
     // 框认得出来 → 看它变没变; 认不出来 → 退回宽窗口找 headFp (长文本会换行,
     // 头部可能在框顶, 所以窗口要宽)。
     const sawLanded = async (timeoutMs) => {
@@ -1300,10 +1384,24 @@ const injectViaTmuxText = async (target, text, log, freshSpawn) => {
         const pane = await capturePaneTail(target, 5);
         return Boolean(tailFp) && stripWs(pane).includes(tailFp);
     };
-    let pasteSeen = await sawLanded(PASTE_VERIFY_MS);
+    let pasteSeen = alreadyTyped;
+    if (alreadyTyped) {
+        log.warn({ target, headFp }, "mirror inject: 输入框里已有这段文本 (上次未提交) — 不重贴, 直接提交");
+    }
+    else {
+        const r = await loadAndPaste();
+        if (!r.ok)
+            return r;
+        pasteSeen = await sawLanded(PASTE_VERIFY_MS);
+    }
     if (!pasteSeen) {
         const box = await readInputBox(target);
         const empty = boxVerify && box.known ? boxIntact(box) : !(await inputBoxStillHasTail());
+        if (submitted()) {
+            // 框看着空, 是因为粘贴连同某次回车一起被收下了 —— 再贴就是第二份。
+            log.info({ target }, "mirror inject: 会话已收到这段文本, 不重贴");
+            return { ok: true };
+        }
         if (!empty) {
             log.warn({ target, headFp, boxKnown: box.known }, "mirror inject: 粘贴未验证但输入框非空 — 首次粘贴已落地, 不重贴");
             pasteSeen = true;
@@ -1311,7 +1409,9 @@ const injectViaTmuxText = async (target, text, log, freshSpawn) => {
         else {
             log.warn({ target, headFp, boxKnown: box.known }, "mirror inject: 输入框确认为空, 重贴一次");
             await sleep(RETRY_SETTLE_MS);
-            r = await loadAndPaste();
+            if (submitted())
+                return { ok: true };
+            const r = await loadAndPaste();
             if (!r.ok)
                 return r;
             pasteSeen = await sawLanded(PASTE_VERIFY_MS);
@@ -1319,7 +1419,8 @@ const injectViaTmuxText = async (target, text, log, freshSpawn) => {
     }
     // Bracketed-paste end + TUI catch-up. Warm pane: 400ms is invisible.
     // Fresh respawn: 1500ms+ — claude --resume is still loading the transcript.
-    await sleep(pasteSeen ? POST_PASTE_SETTLE_MS : POST_PASTE_SETTLE_FALLBACK_MS);
+    if (!alreadyTyped)
+        await sleep(pasteSeen ? POST_PASTE_SETTLE_MS : POST_PASTE_SETTLE_FALLBACK_MS);
     const sendEnter = async () => {
         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)}` };
@@ -1328,11 +1429,15 @@ const injectViaTmuxText = async (target, text, log, freshSpawn) => {
         const box = await readInputBox(target);
         return boxVerify && box.known ? boxIntact(box) : !(await inputBoxStillHasTail());
     };
-    const waitForCleared = async (timeoutMs) => {
+    /** 证人先答; 它的窗口过了还不作声, 才每轮加看一眼框。 */
+    const waitForSubmit = async (timeoutMs) => {
         const t0 = Date.now();
-        while (Date.now() - t0 < timeoutMs) {
+        const budget = Math.max(timeoutMs, WITNESS_ONLY_MS + 500);
+        while (Date.now() - t0 < budget) {
             await sleep(POLL_MS);
-            if (await cleared())
+            if (submitted())
+                return true;
+            if (Date.now() - t0 >= WITNESS_ONLY_MS && (await cleared()))
                 return true;
         }
         return false;
@@ -1350,19 +1455,25 @@ const injectViaTmuxText = async (target, text, log, freshSpawn) => {
     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);
+            if (submitted())
+                return { ok: true }; // 迟到的确认 —— 补的这一下会落在空框上, 省了
+            log.warn({ target, tailFp, attempt: i + 1 }, "mirror inject: 回车后输入框未清空, 再补一次");
         }
+        if (i === 0)
+            enterAt = Date.now();
         const e = await sendEnter();
         if (!e.ok)
             return e;
-        if (await waitForCleared(CLEARED_TIMEOUT_MS))
+        if (await waitForSubmit(CLEARED_TIMEOUT_MS))
             return { ok: true };
     }
+    if (submitted())
+        return { ok: true };
     // 补到头还没清空。通常是渲染滞后 (回车其实落了), 但也可能是目标会话正忙 /
     // 上下文满了不消费输入 —— 那样用户这条消息会悄无声息地消失。不报硬失败 (用户
     // 多半已经被服务到了), 标 uncertain 让调用方按需提示。
-    log.warn({ target, tailFp, freshSpawn, boxTrusted }, "mirror inject: clear not observed, trusting submit");
+    log.warn({ target, tailFp, freshSpawn, boxTrusted, witness: witness.status }, "mirror inject: clear not observed, trusting submit");
     return { ok: true, uncertain: true, reason: "目标会话可能正忙或未消费输入(回车后输入框未清空)" };
 };
 const injectViaSpawn = (args) => {
@@ -1417,8 +1528,7 @@ const inject = (args) => {
     const target = (args.tmuxTarget ?? "").trim();
     if (!target)
         return injectViaSpawn(args);
-    const backendName = backendForPath(args.jsonlPath).name;
-    return injectViaTmux(target, args.text, args.images ?? [], args.log, args.freshSpawn ?? false, backendName, args.bypassModalGuard ?? false);
+    return injectViaTmux(target, args.text, args.images ?? [], args.log, args.freshSpawn ?? false, backendForPath(args.jsonlPath), args.jsonlPath, args.bypassModalGuard ?? false);
 };
 const queues = new Map();
 /** Ceiling for one whole inject job (respawn + paste + submit verification).
@@ -1581,8 +1691,8 @@ export const startMirror = (deps) => {
     const detailCardFor = (s, target) => {
         if (s.tools.length === 0)
             return undefined;
-        const tag = tagOfKey(target);
-        const titlePrefix = tag ? `${labelFor(tag)} #${tag} · ` : "";
+        const name = displayName(target);
+        const titlePrefix = name ? `${labelFor(name)} .${name} · ` : "";
         return {
             card_type: "button_interaction",
             main_title: { title: `${titlePrefix}本轮工具调用` },
@@ -1598,7 +1708,7 @@ export const startMirror = (deps) => {
         const content = s.acc;
         s.lastSent = content;
         try {
-            await client.replyStream(s.frame, s.streamId, withTagHeader(s.target, content || " "), false);
+            await client.replyStream(s.frame, s.streamId, withLinkedTagHeader(s.target, content || " ", chatTurnUrl(s.target, s.turnId)), false);
             log.debug({ turnId: s.turnId, len: content.length }, "stream flush ok");
         }
         catch (e) {
@@ -1679,32 +1789,26 @@ 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 withTagHeader when no turnId is available (no active turn to link).
-    const linkedTagPrefix = (target, turnId) => {
-        if (!turnId)
-            return "";
-        const url = buildChatUrl(cfg.daemon.detailPublicBase, cfg.daemon.host, cfg.daemon.port, turnId, stripPrincipalPrefix(target));
-        const tag = tagOfKey(target);
-        return tag ? `[${labelFor(tag)} #${tag}](${url})` : `[🧙](${url})`;
-    };
-    const withLinkedTag = (a, content, seq, turnId) => {
-        const prefix = linkedTagPrefix(a.target, turnId ?? a.briefTurnId);
-        if (prefix) {
-            const seqBit = seq ? ` ${seq}` : "";
-            return `${prefix}${seqBit}${headSep(content)}${content}`;
-        }
-        return withTagHeader(a.target, content, seq);
-    };
+    // 头挂 chat 详情页的票据: 本轮那条 turn。没有活 turn 可挂 → undefined, 头退回裸
+    // `emoji #tag` (withLinkedTagHeader 自己兜)。
+    const chatTurnUrl = (target, turnId) => turnId
+        ? buildChatUrl(cfg.daemon.detailPublicBase, cfg.daemon.host, cfg.daemon.port, turnId, stripPrincipalPrefix(target))
+        : undefined;
+    const withLinkedTag = (a, content, seq, turnId) => withLinkedTagHeader(a.target, content, chatTurnUrl(a.target, turnId ?? a.briefTurnId), seq);
     // 空正文一票否决 (近源拦截): 剥掉可能存在的路由头 (`🦊 #tag` / `[🧙](url)`)
     // 后没有可见内容就不发。中央 chat-gate (last-response 的 SDK 包装) 是最后一道
     // 防线; 这里拦在源头 —— 空内容不进 standalonePending FIFO、不占防抖 buf、
     // 不重置计时器, 免得"空 part 入队 → flush 时 join 出空串"的死角。
     const hasVisibleBody = (content) => parseTagHeader(content).body.length > 0;
+    // 推到本轮的频道 (人从别的群叫它 → 回那个群)。私聊轮的正文 brief 下在上游
+    // turnSilent 已被拦下; 非 brief 的逐条推送在这里兜一道 —— 只放 `[mirror]` /
+    // `[wezard]` 系统提示 (它们回 home)。
     const sendStandalone = (a, content) => {
         if (!hasVisibleBody(content))
             return;
-        const chatId = stripPrincipalPrefix(a.target);
+        if (isPrivate(a) && !/^\[(mirror|wezard)\]/.test(content.trim()))
+            return;
+        const chatId = replyChatId(a);
         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
@@ -1724,7 +1828,7 @@ export const startMirror = (deps) => {
     const sendRaw = (a, content) => {
         if (!hasVisibleBody(content))
             return;
-        const chatId = stripPrincipalPrefix(a.target);
+        const chatId = replyChatId(a);
         a.standalonePending = a.standalonePending
             .then(async () => {
             try {
@@ -2045,18 +2149,15 @@ export const startMirror = (deps) => {
     // 链接落到 chat 视图: 默认选中本 turn 所属的 #tag, 贴底显示整条会话。turnId 依旧
     // 是凭据 (不可枚举), 只是页面从"一个 turn"扩成"这个 chat 的全部会话"。
     // target 作为 ww_uniq 传下去, 让同 chat 的所有 turn 详情都复用一个 WeCom 窗口。
-    const briefDetailLink = (turnId, target) => {
-        const url = buildChatUrl(cfg.daemon.detailPublicBase, cfg.daemon.host, cfg.daemon.port, turnId, stripPrincipalPrefix(target));
-        const tag = tagOfKey(target);
-        return tag ? `[${labelFor(tag)} #${tag}](${url})` : `[🧙](${url})`;
-    };
+    const briefDetailLink = (turnId, target) => linkedTagHead(target, buildChatUrl(cfg.daemon.detailPublicBase, cfg.daemon.host, cfg.daemon.port, turnId, stripPrincipalPrefix(target)));
     // ── 出处门 (chatOriginOnly) ───────────────────────────────────────────
     // 人在 CLI 里手敲的一轮, 镜像只发生在两处: 他眼前的终端, 和 chat 详情页 (turn
     // store 全量记录 + SSE 实时刷新)。聊天里不再下发它的气泡 —— 那份内容他本来就
     // 在看。群里保留的是需要在群里发生的事: WeCom 发起的轮次、审批/提问卡、
     // `[mirror]` 系统提示 —— 它们都不走这道门。
     // 只在 brief 下生效: 抑制的前提是详情页兜得住内容, 而 turn store 只有 brief 在写。
-    const turnSilent = (a) => cfg.wrc.mirror.brief && cfg.wrc.mirror.chatOriginOnly && a.turnFromChat === false;
+    // 私聊轮 (wizard 之间, 非 public) 同理: 它的回复属于那场私聊, 只进双方的 rolepage。
+    const turnSilent = (a) => isPrivate(a) || (cfg.wrc.mirror.brief && cfg.wrc.mirror.chatOriginOnly && a.turnFromChat === false);
     // 收口一条 loading 气泡: finish=true 写入最终内容, 只生效一次。发送失败退回 standalone。
     // raw=true skips withTagHeader (used when content already contains the linked tag header).
     // WeCom 客户端收到 finish=true 后仍有打字机动画要播放, 如果紧接着就下发
@@ -2124,6 +2225,28 @@ export const startMirror = (deps) => {
         a.pendingFrom = undefined;
         return p && Date.now() - p.at <= ORIGIN_TTL_MS ? p.from : undefined;
     };
+    /** 频道印章: 有新印章就换频道; 没有则 `reset` (CLI 手敲 / 人从聊天发起) 回到
+     *  home, 其余续写 (收口后的补写) 沿用上一轮。 */
+    const consumeChannel = (a, reset) => {
+        const p = a.pendingChannel;
+        a.pendingChannel = undefined;
+        if (p && Date.now() - p.at <= ORIGIN_TTL_MS) {
+            a.channel = p.channel === baseOfKey(a.target) ? undefined : p.channel;
+            a.speaker = p.speaker;
+        }
+        else if (reset) {
+            a.channel = undefined;
+            a.speaker = undefined;
+        }
+    };
+    /** 本轮落 turn 记录的频道字段。 */
+    const channelFields = (a) => ({ channel: a.channel ?? baseOfKey(a.target), speaker: a.speaker });
+    /** 私聊轮: 回复只落 turn 记录。 */
+    const isPrivate = (a) => a.channel === "";
+    /** 本轮回复该推去的 chatId。 */
+    const replyChatId = (a) => stripPrincipalPrefix(a.channel || a.target);
+    // 审批/提问卡同样回本轮的频道; 私聊轮 ("") 的卡回 home —— 要点它的人总得在某个群里。
+    bindCardChannel((key) => byTarget.get(key)?.channel || "");
     // 详情页要按后端的名字称呼它 ("Claude 正在思考" / "CodeBuddy 正在思考") —— 后端
     // 由 transcript 落盘路径唯一确定, 所以每次开 turn 时现算, 不必额外记在 AttachState 上。
     const cliOf = (a) => a.jsonlPath ? backendForPath(a.jsonlPath).name : undefined;
@@ -2132,7 +2255,8 @@ 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), from: consumeFrom(a) });
+        consumeChannel(a, true);
+        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), ...channelFields(a) });
         // hardTimer 兜底: turn 若无终句 / turn_end 收口 (卡死/漏收), 到点仍收气泡。
         const bubble = { frame, streamId, hardTimer: undefined, done: false };
         const q = { turnId, bubble, isSlash };
@@ -2178,7 +2302,8 @@ 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), from: consumeFrom(a) });
+        consumeChannel(a, fromCli);
+        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), ...channelFields(a) });
         a.briefTurnId = turnId;
         a.briefBubble = undefined;
         a.briefIsSlash = false;
@@ -2187,7 +2312,7 @@ export const startMirror = (deps) => {
         a.briefLastText = undefined;
         clearCot(a);
         // 详情链接不在这里单独发 — 本轮的每条 standalone 都由 withLinkedTag 自带
-        // (linkedTagPrefix 读的正是 a.briefTurnId)。静默轮没有 standalone 可搭车, 那就
+        // (chatTurnUrl 读的正是 a.briefTurnId)。静默轮没有 standalone 可搭车, 那就
         // 一条都不发: 群里只该出现有正文的消息, 纯入口提示是噪音。
         log.info({ sessionId: a.sessionId, turnId, fromCli, silent: turnSilent(a) }, "brief: turn started (CLI-side, no bubble)");
     };
@@ -2232,7 +2357,7 @@ export const startMirror = (deps) => {
         a.lastConcludedEpoch = a.queryEpoch ?? 0;
         a.lastConcludedAt = Date.now();
         if (a.briefBubble && !a.briefBubble.done) {
-            void finishBriefBubble(a, `${briefDetailLink(turnId, a.target)} ${body}`, true);
+            void finishBriefBubble(a, `${briefDetailLink(turnId, a.target)} ${linkTags(a.target, body)}`, true);
         }
         else if (turnSilent(a)) {
             // CLI 手敲的一轮: 终稿只留在 turn store, 详情页照常实时可见。
@@ -2838,6 +2963,7 @@ export const startMirror = (deps) => {
                     && backendForPath(a.jsonlPath).name === "codebuddy"
                     && !hasMirrorPlan(a.sessionId)) {
                     void runMirrorPlanFlow({
+                        cfg,
                         log: log.child({ sessionId: a.sessionId }),
                         client,
                         sessionId: a.sessionId,
@@ -2864,6 +2990,7 @@ export const startMirror = (deps) => {
                     && backendForPath(a.jsonlPath).name === "codebuddy"
                     && !hasMirrorAskq(a.sessionId)) {
                     void runMirrorAskqFlow({
+                        cfg,
                         log: log.child({ sessionId: a.sessionId }),
                         client,
                         sessionId: a.sessionId,
@@ -3076,7 +3203,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, model, pendingCwd }) => {
+    const attach = ({ sessionId, jsonlPath, target: targetOverride, tmuxPane, tmuxSession, cwd, model, pendingCwd, keepaliveDisabled }) => {
         const target = resolveTarget(targetOverride);
         if (!target)
             return { ok: false, reason: "no target chat (set wrc.mirror.pushChat or defaultChat, or pass target)" };
@@ -3085,7 +3212,7 @@ export const startMirror = (deps) => {
         // missing file (existsSync gate at start, try/catch in drain) and the 1s
         // poll picks it up the moment claude writes the first line.
         // Replace any existing attach with the same sessionId or same target. The
-        // sessionId clash is the "/wrc again from same window" case; the target
+        // sessionId clash is the "same session attached again" case; the target
         // clash is "different window steals my WeCom chat" — both end the previous.
         // Guard: if a DIFFERENT principal already owns this sessionId, refuse rather
         // than detaching it — prevents cross-wire when concurrent restoreFromStore
@@ -3106,6 +3233,9 @@ export const startMirror = (deps) => {
         // 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 ?? "");
+        // Same carry rule again: an explicit spawn-time choice wins, otherwise this
+        // wizard's existing policy (in-memory, or on disk across a reload) sticks.
+        const carryKeepaliveDisabled = keepaliveDisabled !== undefined ? keepaliveDisabled : (prevByTarget?.keepaliveDisabled ?? deps.store.get(target)?.keepaliveDisabled ?? false);
         if (prevByTarget)
             detach(prevByTarget, "target reassigned");
         // Build the attachment first so the tail's onItem closure can capture it.
@@ -3116,11 +3246,12 @@ export const startMirror = (deps) => {
             tmuxPane: (tmuxPane ?? "").trim(),
             tmuxSession: (tmuxSession ?? "").trim(),
             // Explicit cwd (spawn path) wins; otherwise derive from jsonl head so
-            // /wrc attaches inherit the bound session's real project dir instead of
+            // cwd-less attaches inherit the bound session's real project dir instead of
             // collapsing to cfg.wrc.cwd (which would mislabel /pwd, /clear, /new).
             runningCwd: expandHome(((cwd ?? "").trim()) || readCwdFromJsonl(jsonlPath) || cfg.wrc.cwd),
             pendingCwd: carryPending,
             model: carryModel,
+            keepaliveDisabled: carryKeepaliveDisabled,
             tail: { stop: () => undefined, drain: () => undefined, livePath: () => undefined }, // placeholder; replaced below
             standalonePending: Promise.resolve(),
             recentToolSigs: new Map(),
@@ -3159,8 +3290,10 @@ export const startMirror = (deps) => {
             cwd: a.runningCwd || undefined,
             model: a.model || undefined,
             pendingCwd: a.pendingCwd || undefined,
+            cwdConfirmed: prevRec?.cwdConfirmed,
             keepaliveOff: prevRec?.keepaliveOff,
             keepaliveOffAt: prevRec?.keepaliveOffAt,
+            keepaliveDisabled: carryKeepaliveDisabled || undefined,
         });
         log.info({ sessionId, jsonlPath, target, tmuxSession: a.tmuxSession, runningCwd: a.runningCwd, pendingCwd: a.pendingCwd, mirrors: bySessionId.size }, "mirror attached");
         return { ok: true, sessionId, jsonlPath, target };
@@ -3172,13 +3305,17 @@ export const startMirror = (deps) => {
     // Verify a paneId still exists. `display-message -t <paneId>` succeeds iff
     // the pane is alive — and tmux pane ids monotonically increment within a
     // server lifetime, so a freed id will not be silently reused. We don't need
-    // the session name, which matters because /wrc attaches capture only $TMUX_PANE.
+    // the session name, which matters because some attaches carry only a pane id.
     const tmuxPaneAlive = async (paneId) => {
         if (!paneId)
             return false;
         const r = await runTmux(["display-message", "-p", "-t", paneId, "#{pane_id}"]);
         return r.code === 0 && r.stdout.trim() === paneId;
     };
+    // 注入前的存活判定要多问一句「里面还有 AI 会话吗」: pane 在、claude 却退回了 shell,
+    // 照旧往里贴就是把用户的话当 shell 命令跑。判否即走 respawn (旧 pane 不杀 —— 它可能是
+    // 用户自己的终端, 经 switch 绑进来的)。
+    const paneUsable = async (paneId, jsonlPath) => (await tmuxPaneAlive(paneId)) && (await paneHostsSession(paneId, backendForPath(jsonlPath).homeDir));
     // Re-attach a stored binding for `principal`. Returns the resulting state, or
     // undefined if the on-disk transcript is gone (in which case the entry is
     // dropped so the next inbound flows through /new auto-spawn).
@@ -3308,6 +3445,8 @@ export const startMirror = (deps) => {
         }
         // Re-hydrate the `/stop` pause so a reload doesn't resume pinging a quieted
         // session (attach preserved it on disk; this puts it back in memory).
+        // keepaliveDisabled is carried by attach() itself (same rule as `model`);
+        // only the transient `/stop` pause needs manual re-hydration here.
         const restored = byTarget.get(principal);
         if (restored && rec.keepaliveOff) {
             restored.keepaliveOff = true;
@@ -3321,7 +3460,7 @@ export const startMirror = (deps) => {
     const persistPause = (a) => {
         const rec = deps.store.get(a.target);
         if (rec)
-            deps.store.set(a.target, { ...rec, keepaliveOff: a.keepaliveOff, keepaliveOffAt: a.keepaliveOffAt });
+            deps.store.set(a.target, { ...rec, keepaliveOff: a.keepaliveOff, keepaliveOffAt: a.keepaliveOffAt, keepaliveDisabled: a.keepaliveDisabled });
     };
     // We re-attach lazily on demand too (see restoreFromStore in dispatch /
     // hasMirrorTarget), but eager boot-restore makes outbound (tail → push) work
@@ -3353,7 +3492,7 @@ export const startMirror = (deps) => {
         }
     }
     else {
-        log.info("mirror: no persisted attachments and no pinned sessionId — waiting for /new or /mirror/attach");
+        log.info("mirror: no persisted attachments and no pinned sessionId — waiting for the first inbound or /new");
     }
     // Render full tool details for a finalized turn into one-or-more markdown
     // chunks (split at chunkBytes boundaries).
@@ -3884,9 +4023,12 @@ export const startMirror = (deps) => {
     // 由 index.ts 在启动时装上 (注册表活在那边); 没装 = 退回无身份行为, 全链路无回归。
     let charterOf;
     const setCharterProvider = (fn) => { charterOf = fn; };
-    const charterFor = (target) => {
+    // `cwd` = 这个 pane 正要启动的目录。attach 在 spawn 之后才发生, 所以此刻 getCwd
+    // 给的还是上一个 pane 的目录 —— 换目录重开时照它渲染, 新 wizard 会以为自己还在
+    // 旧工作区里。
+    const charterFor = (target, ctx) => {
         try {
-            return charterOf?.(target);
+            return charterOf?.(target, ctx);
         }
         catch {
             return undefined;
@@ -3936,7 +4078,7 @@ export const startMirror = (deps) => {
             cwdOverride: eff,
             cli: effCli,
             model: opts?.model,
-            systemPrompt: opts?.systemPrompt ?? charterFor(target),
+            systemPrompt: opts?.systemPrompt ?? charterFor(target, { cwd: eff }),
         });
         if (!r.ok)
             return { ok: false, reason: r.reason };
@@ -3950,8 +4092,11 @@ export const startMirror = (deps) => {
             // 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() ?? "",
+            // means this CLI's default, not the dead pane's model. Store what
+            // spawnTmuxClaude actually confirmed via `/model` (r.model), not the
+            // raw request — a later respawn's fast path then matches on try one.
+            model: r.model ?? (opts?.model?.trim() ?? ""),
+            keepaliveDisabled: opts?.keepalive === undefined ? undefined : !opts.keepalive,
         });
         if (!att.ok)
             return { ok: false, reason: att.reason };
@@ -3961,7 +4106,7 @@ export const startMirror = (deps) => {
         if (spawned) {
             spawned.justSpawned = true;
             spawned.muteUntilInject = true;
-            // 只有换过 pane 才是断点 —— 首次 /wrc 建会话时 prev 为空, 那不是"不连续", 是开局。
+            // 只有换过 pane 才是断点 —— 首次建会话时 prev 为空, 那不是"不连续", 是开局。
             if (prev)
                 markCut(target, spawned.sessionId, "new");
             // A freshly spawned session is empty — nothing in the cache to keep warm.
@@ -3986,6 +4131,7 @@ export const startMirror = (deps) => {
                     tmuxSession: baseA.tmuxSession || undefined,
                     tmuxPane: baseA.tmuxPane || undefined,
                     cwd: baseA.runningCwd || undefined,
+                    cwdConfirmed: deps.store.get(base)?.cwdConfirmed,
                     pendingCwd: undefined,
                 });
             }
@@ -3997,7 +4143,7 @@ export const startMirror = (deps) => {
         }
         if (!opts?.silent)
             pushProjectInfo(target, "created");
-        return { ok: true, sessionId: r.sessionId, cwd: r.cwd };
+        return { ok: true, sessionId: r.sessionId, cwd: r.cwd, model: r.model, modelWarning: r.modelWarning };
     };
     // ── Clone ───────────────────────────────────────────────────────────
     // 分身 = `--resume <父 sid> --fork-session` 起的新 pane: CLI 把父亲的 transcript
@@ -4039,7 +4185,7 @@ export const startMirror = (deps) => {
         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,
+                model: args.model, cwd: args.cwd, systemPrompt: args.systemPrompt, silent: true, keepalive: args.keepalive,
             });
             return { ...r, inherited: false };
         }
@@ -4091,7 +4237,8 @@ export const startMirror = (deps) => {
             tmuxSession: r.tmuxSession,
             cwd: r.cwd,
             pendingCwd: "",
-            model: args.model?.trim() ?? "",
+            model: r.model ?? (args.model?.trim() ?? ""),
+            keepaliveDisabled: args.keepalive === undefined ? undefined : !args.keepalive,
         });
         if (!att.ok)
             return { ok: false, reason: att.reason, inherited: false };
@@ -4106,7 +4253,7 @@ export const startMirror = (deps) => {
             persistPause(spawned);
         }
         lg.info({ parent: args.parent, sessionId: fork.sessionId }, "clone: forked");
-        return { ok: true, sessionId: fork.sessionId, cwd: r.cwd, inherited: true };
+        return { ok: true, sessionId: fork.sessionId, cwd: r.cwd, inherited: true, model: r.model, modelWarning: r.modelWarning };
     };
     /** 一个会话此刻的硬事实 —— whoami / 交接判断要用的那几个数。 */
     const sessionInfo = (target) => {
@@ -4163,6 +4310,7 @@ export const startMirror = (deps) => {
                 tmuxSession: baseA.tmuxSession || undefined,
                 tmuxPane: baseA.tmuxPane || undefined,
                 cwd: baseA.runningCwd || undefined,
+                cwdConfirmed: deps.store.get(base)?.cwdConfirmed,
                 pendingCwd: baseA.pendingCwd || undefined,
             });
             log.info({ target, base, runningCwd: callerRunning, pendingCwd: expanded }, "setPendingCwd (chat-scoped, live base)");
@@ -4186,6 +4334,7 @@ export const startMirror = (deps) => {
                 tmuxSession: callerA.tmuxSession || undefined,
                 tmuxPane: callerA.tmuxPane || undefined,
                 cwd: callerA.runningCwd || undefined,
+                cwdConfirmed: deps.store.get(target)?.cwdConfirmed,
                 pendingCwd: callerA.pendingCwd || undefined,
             });
             log.info({ target, runningCwd: callerA.runningCwd, pendingCwd: callerA.pendingCwd }, "setPendingCwd (fallback: no base, wrote to caller)");
@@ -4199,6 +4348,32 @@ export const startMirror = (deps) => {
         }
         return { ok: false, reason: "no mirror binding for target — send a message in the WeCom chat first", runningCwd: "", pendingCwd: "" };
     };
+    // 「人说了就用这个目录」。一个新聊天的第一个 wizard 落在默认兜底目录里 —— 那不是
+    // 选择, 只是没人说过。所以默认按「还要换」办 (charter 让它开工前先问一句), 直到人
+    // 明说不用换。**只有这一个写入点**: 换去别的目录本身就是选择, 不必记一笔, 那时
+    // runningCwd 已经不等于默认目录, cwdUnconfirmed 自然为假。
+    // 寻址与 pendingCwd 同规 —— 写在 base 上 (聊天级), 没有 base 记录 (只有 tagged
+    // 会话的聊天) 就退回调用方自己的那条。
+    const confirmCwd = (target) => {
+        const base = baseOfKey(target);
+        const key = deps.store.get(base) ? base : deps.store.get(target) ? target : "";
+        const rec = key ? deps.store.get(key) : undefined;
+        if (!rec)
+            return { ok: false, reason: "no mirror binding for target — send a message in the WeCom chat first", cwd: "" };
+        deps.store.set(key, { ...rec, cwdConfirmed: true });
+        const cwd = getCwd(target).runningCwd;
+        log.info({ target, key, cwd }, "cwd confirmed by user");
+        return { ok: true, cwd };
+    };
+    /** 该不该问人「要在哪个项目下干活」: 还蹲在默认兜底目录里, 而且人没说过就用它。 */
+    const cwdUnconfirmed = (target, cwd) => {
+        const base = baseOfKey(target);
+        if (deps.store.get(base)?.cwdConfirmed || deps.store.get(target)?.cwdConfirmed)
+            return false;
+        // `cwd` 是调用方已经知道的「即将生效的目录」(spawn 前的宪章渲染)。没给就问现状。
+        const eff = cwd?.trim() ? expandHome(cwd.trim()) : getCwd(target).runningCwd;
+        return eff === expandedDefaultCwd;
+    };
     // ── Peer graph (sibling sessions of one chat) ────────────────────────
     // A chat's sessions are exactly the keys sharing its base principal: the
     // untagged default plus every `#tag`. Live attachments are the truth; the
@@ -4212,80 +4387,36 @@ export const startMirror = (deps) => {
         const base = baseOfKey(target);
         return allTargets().filter((k) => baseOfKey(k) === base);
     };
-    // 名字解析:`daily` / `chat:wrxxx` → base principal。认不出就把已知名字一并回给
-    // 调用方 —— 跨 chat 出错时"我该写什么"比"你写错了"有用得多。
-    const resolveChatRef = (ref) => {
-        const base = chatBaseOf(cfg, ref);
-        if (base)
-            return { ok: true, base };
-        const known = listChatNames(cfg).map((c) => c.name);
-        return {
-            ok: false,
-            reason: `unknown chat '${ref}' — give that chat a name first (\`/name ${normChatName(ref) || "<name>"}\` inside it)`,
-            candidates: known,
-        };
-    };
-    // peer 寻址。地址是两级的(见 chat-name.ts):
-    //   ""            本 chat 的 default —— 自身语义不变;
-    //   `fix`         本 chat 优先,本 chat 没有再全局兜底(全 host 唯一才认)——
-    //                 命名之前唯一的跨 chat 路子,老调用方不能因为引入命名而断掉;
-    //   `daily#fix`   daily 这个 chat 里的 `#fix`,精确到点,不问 tag 全不全局唯一;
-    //   `daily`       daily 这个聊天的 default 会话 —— 默认 wizard 的名字就是聊天名,
-    //                 所以裸聊天名就是它的地址 (`daily#` 这种老写法继续认);
-    //   `chat:wr…#fix` 全量 key 同理(list_peers 吐的就是它)。
-    // 裸 tag 的 0 命中 / ≥2 命中依旧拒绝,但出路从"回去改 tag 名"变成"用带 chat 名
-    // 的全称地址"——后者不需要动别人的会话。
+    // peer 寻址。地址就是 wizard 的**全局名字** (`.fix` / `fix`), 与它住在哪个聊天无关:
+    //   ""             本 chat 的默认 wizard —— 自身语义不变;
+    //   `fix` / `.fix` 名册里叫这个名字的 wizard, 全局唯一, 不分聊天;
+    //   `chat:wr…#k`   全量 key (调试 / 老调用方);
+    //   `daily#fix`    改名前的老写法 —— 名字取自 tag 迁移而来, 照旧认得。
     const resolvePeerTag = (self, ref) => {
-        const { chat, tag } = parsePeerRef(ref ?? "");
-        const t = tag.trim();
-        if (chat) {
-            const c = resolveChatRef(chat);
-            if (!c.ok)
-                return c;
-            const target = keyOf(c.base, t);
-            if (allTargets().includes(target)) {
-                return { ok: true, target, foreign: c.base !== 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) => baseOfKey(k) === c.base).map((k) => peerAddress(cfg, self, k)),
-            };
-        }
-        const local = keyOf(baseOfKey(self), t);
-        if (!t)
-            return { ok: true, target: local, foreign: false };
+        const raw = stripSigil(ref);
         const all = allTargets();
-        if (all.includes(local))
-            return { ok: true, target: local, foreign: false };
-        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) {
-            // 裸 token 正好是个 chat 名字 —— 用户/agent 想说的是"那个群",不是"那个 tag"。
-            // 直接给出它的会话地址,比让人再查一次 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: `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)` };
+        const hit = (target) => ({ ok: true, target, foreign: baseOfKey(target) !== baseOfKey(self) });
+        if (!raw)
+            return hit(baseOfKey(self));
+        if (/^(user|chat|group):/.test(raw)) {
+            return all.includes(raw) ? hit(raw) : { ok: false, reason: `no running session '${raw}'` };
+        }
+        const named = wizardStore()?.byName(raw)?.target;
+        if (named && all.includes(named))
+            return hit(named);
+        if (named)
+            return { ok: false, reason: `wizard '.${raw}' exists but its session is not running — respawn it (new_claude_session) or pick another` };
+        const { chat, tag } = parsePeerRef(raw);
+        if (chat) {
+            const base = chatBaseOf(cfg, chat);
+            const legacy = base ? keyOf(base, tag) : "";
+            if (legacy && all.includes(legacy))
+                return hit(legacy);
         }
         return {
             ok: false,
-            reason: `tag '#${t}' exists in ${foreignMatches.length} chats — address it in full as 'chatName#${t}' (list_chats shows the names)`,
-            candidates: foreignMatches.map((k) => peerAddress(cfg, self, k)),
+            reason: `no wizard named '.${raw}' — wizard_roster lists every name`,
+            candidates: all.map((k) => peerAddress(cfg, self, k)),
         };
     };
     /** 已知的每个 chat:命名的 + 有会话在跑的。`name` 为空即"还没起名",那就是
@@ -4351,6 +4482,7 @@ export const startMirror = (deps) => {
         const pane = paneOf(t);
         const paneAlive = pane ? await tmuxPaneAlive(pane) : false;
         const tag = tagOfKey(t);
+        const name = displayName(t);
         let lastActivity = 0;
         try {
             if (jsonlPath)
@@ -4362,7 +4494,7 @@ export const startMirror = (deps) => {
             tag,
             chat: chatNameOf(cfg, t),
             address: peerAddress(cfg, self, t),
-            label: tag ? labelFor(tag) : "🧙",
+            label: name ? labelFor(name) : "🧙",
             sessionId: a?.sessionId || rec?.sessionId || "",
             jsonlPath,
             cwd: a?.runningCwd || rec?.cwd || expandedDefaultCwd,
@@ -4379,16 +4511,13 @@ export const startMirror = (deps) => {
     };
     const byRecent = (x, y) => y.lastActivity - x.lastActivity;
     const peers = async (target) => (await Promise.all(chatTargets(target).map((t) => peerInfoOf(t, target)))).sort(byRecent);
-    // list_peers 的跨 chat 补充:其他 chat 里**当前调用方叫得动**的 session。两条
-    // 入选路径 —— tag 全局唯一(裸 tag 就能命中),或者它所在的 chat 有名字(全称
-    // `daily#fix` 命中)。后者是命名带来的新增量:同名 tag 不再互相遮蔽,想被找到
-    // 只要给群起个名,不必回去改别人的 tag。
+    // list_peers 的跨 chat 补充: 其他 chat 里的 wizard。名字全局唯一, 所以它们
+    // 全都叫得动 —— 地址就是 `.name`, 与住在哪个聊天无关。
     const foreignPeers = async (self) => {
         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);
+        // 只列活着的 / 有身份的 —— 冷绑定可能有几百个, 每个探活是两次 tmux。
+        const foreign = allTargets().filter((k) => baseOfKey(k) !== selfBase && (byTarget.has(k) || !!wizardStore()?.get(k)));
+        return (await Promise.all(foreign.map((t) => peerInfoOf(t, self)))).sort(byRecent);
     };
     // peerInfoOf 每个 target 要两次 tmux (pane 存活 + capture tail)。跑了几个月的
     // 机器上 allTargets() 是几百个 —— 一次全量探活就是上千次 spawn, 足够打穿 fd
@@ -4535,6 +4664,8 @@ export const startMirror = (deps) => {
             const pingSigs = [normAssistant(kc.ping).slice(0, 40), normAssistant(kc.resumePing).slice(0, 40)].filter((s) => s.length > 0);
             const now = Date.now();
             for (const a of byTarget.values()) {
+                if (a.keepaliveDisabled)
+                    continue; // sticky spawn-time opt-out — never pings, never auto-resumes
                 if (!a.tmuxPane)
                     continue; // spawn-mode: no live pane to warm
                 if (a.migrationWatcher)
@@ -4961,14 +5092,22 @@ export const startMirror = (deps) => {
                 a.pendingOrigin = { origin, at: Date.now() };
             if (opts?.from)
                 a.pendingFrom = { from: opts.from, at: Date.now() };
+            if (opts?.channel !== undefined)
+                a.pendingChannel = { channel: opts.channel, at: Date.now() };
+            // 注入的那一行会被 recentInjects 当回显吞掉, 走不到 user_text —— 本轮的 query
+            // (rolepage 上「谁对它说了什么」那一半) 只能在这里记。
+            a.pendingBriefQuery = text;
+            // 公开频道里说的话, 回复就该在群里看得见 —— 哪怕上一轮是人在 CLI 里敲的。
+            if (opts?.channel)
+                a.turnFromChat = true;
             const sid = a.sessionId;
-            const paneAlive = a.tmuxPane ? await tmuxPaneAlive(a.tmuxPane) : false;
+            const paneAlive = a.tmuxPane ? await paneUsable(a.tmuxPane, a.jsonlPath) : false;
             if (!paneAlive) {
                 log.warn({ target, sessionId: sid, oldPane: a.tmuxPane }, "injectText: pane not alive, respawning");
                 // Same resume-fork hazard as dispatch: snapshot before spawn, re-bind
                 // onto the forked jsonl once it appears (EOF offset — fork is seeded).
                 const resumeBaseline = listJsonls(dirname(a.jsonlPath));
-                const r = await spawnTmuxClaude({ cfg, log: log.child({ sub: "respawn-init", sessionId: sid }), resumeSessionId: sid, windowName: tagOfKey(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: displayName(target) || target, cwdOverride: a.runningCwd, cli: backendForPath(a.jsonlPath).name, model: a.model || undefined, systemPrompt: charterFor(target, { cwd: a.runningCwd }) });
                 if (!r.ok || !r.tmuxPane)
                     return { ok: false, reason: `respawn failed: ${r.reason ?? "unknown"}` };
                 a.tmuxPane = r.tmuxPane;
@@ -5070,6 +5209,61 @@ export const startMirror = (deps) => {
             log.info({ target, sessionId: a?.sessionId, pane }, "mirror /kill — pane killed, binding dropped");
             return { ok: true };
         },
+        reapIdle: async (ttlMs, skip) => {
+            const now = Date.now();
+            const reaped = [];
+            const skipped = {};
+            for (const target of allTargets()) {
+                const a = byTarget.get(target);
+                const sessionId = a?.sessionId || deps.store.get(target)?.sessionId || "";
+                // 便宜闸门先行: transcript mtime 一次 statSync, 不 spawn —— 跑了几个
+                // 月的机器上 allTargets 是几百个 key, 见 target 就问 tmux 会打穿 fd
+                // (同 worldPeers 的 WORLD_PROBE 取舍)。还没写过 transcript 的 spawn-mode
+                // 绑定没有活动证据, 不动它。
+                const jsonl = jsonlOf(target);
+                let mtime = 0;
+                try {
+                    if (jsonl)
+                        mtime = statSync(jsonl).mtimeMs;
+                }
+                catch { /* 文件没了 */ }
+                if (!mtime || now - mtime < ttlMs)
+                    continue;
+                const veto = skip?.(target, sessionId);
+                if (veto) {
+                    skipped[target] = veto;
+                    continue;
+                }
+                const pane = paneOf(target);
+                if (!pane || !(await tmuxPaneAlive(pane)))
+                    continue; // pane 已死, 没什么可收的
+                if (paneIsBusy(await capturePaneTail(pane, 12))) {
+                    skipped[target] = "busy";
+                    continue;
+                }
+                // 人正盯着这个 window —— 收掉他的视野比省下那点内存更讨嫌。
+                const w = await runTmux(["display-message", "-p", "-t", pane, "#{window_active}:#{session_attached}"]);
+                const [wActive, sAttached] = w.stdout.trim().split(":");
+                if (wActive === "1" && sAttached !== "0") {
+                    skipped[target] = "watched";
+                    continue;
+                }
+                // 与 killPane 同款前戏: Esc 给生成中的 CLI 一个收束落盘的机会。
+                await runTmux(["send-keys", "-t", pane, "Escape"]);
+                await sleep(250);
+                const r = await runTmux(["kill-pane", "-t", pane]);
+                if (r.code !== 0) {
+                    skipped[target] = `kill-pane failed: ${r.stdout.slice(-120) || r.code}`;
+                    continue;
+                }
+                if (a)
+                    detach(a, "idle reap");
+                // 不碰 store —— 绑定留着, 下一条 inbound 走 dead-pane `--resume` 复活。
+                reaped.push(target);
+                log.info({ target, sessionId, pane, idleHours: Math.round((now - mtime) / 3.6e6) }, "mirror idle reap — pane killed, binding kept");
+            }
+            return { reaped, skipped };
+        },
         submitPane: async (target) => {
             const a = byTarget.get(target);
             if (!a)
@@ -5151,6 +5345,8 @@ export const startMirror = (deps) => {
         },
         getCwd,
         setPendingCwd,
+        cwdUnconfirmed,
+        confirmCwd,
         newSession,
         cloneSession,
         sessionInfo,
@@ -5170,7 +5366,11 @@ export const startMirror = (deps) => {
             bySessionId.clear();
             byTarget.clear();
         },
-        dispatch: async ({ principal, text, images, frame, streamId }) => {
+        currentChannel: (target) => {
+            const a = byTarget.get(target);
+            return a?.channel ?? baseOfKey(target);
+        },
+        dispatch: async ({ principal, text, images, frame, streamId, channel, speaker }) => {
             // Route by inbound principal — the WeCom chat the user just messaged us
             // from is the same string we registered as `target` on attach. After a
             // daemon reload the in-memory map is empty; restore from the persisted
@@ -5181,7 +5381,7 @@ export const startMirror = (deps) => {
                 a = await restoreFromStore(principal);
             if (!a) {
                 try {
-                    await client.replyStream(frame, streamId, withTagHeader(principal, "[wezard] wecom remote control not attached — run `/wrc` inside the target Claude session"), true);
+                    await client.replyStream(frame, streamId, withTagHeader(principal, "[wezard] 本聊天还没有会话 — 发 `/new` 开一个"), true);
                 }
                 catch {
                     /* ignore */
@@ -5206,6 +5406,8 @@ export const startMirror = (deps) => {
                 }
             }
             persistPause(a); // persist the pause/resume too, else a reload would revert it
+            // 频道印章要早于任何开 turn 的路径 (startBriefTurn 同步消费)。
+            a.pendingChannel = { channel: channel ?? baseOfKey(principal), speaker, at: Date.now() };
             // Finalize prior live stream (if any) so this new turn renders into its
             // own message bubble. Then open a fresh stream tied to the new frame and
             // ack immediately so WeCom doesn't time out while inject queues.
@@ -5227,10 +5429,8 @@ export const startMirror = (deps) => {
                 if (a.liveStream && !a.liveStream.closed)
                     await finalizeStream(a, a.liveStream);
                 log.info({ target: a.target, runningCwd: a.runningCwd, pendingCwd: pending }, "/clear upgraded to /new (cwd switch)");
-                // Prefer the tag suffix as tmux window name when present (matches
-                // /new #tag behavior), fall back to the full target for untagged.
-                const tag = tagOfKey(a.target);
-                const r = await newSession(a.target, tag || a.target);
+                // The wizard's global name is the tmux window name (matches /new).
+                const r = await newSession(a.target, displayName(a.target) || a.target);
                 if (!r.ok) {
                     try {
                         await client.replyStream(frame, streamId, withTagHeader(a.target, `[mirror] 切换失败: ${r.reason ?? "unknown"}`), true);
@@ -5313,7 +5513,7 @@ export const startMirror = (deps) => {
                     return; // (eager path) superseded by a newer dispatch
                 // Always reincarnate when no live pane: covers (a) pane closed between
                 // turns, (b) daemon reload restored a binding without a live pane, AND
-                // (c) /wrc'd from a non-tmux context (no tmuxSession ever stored) —
+                // (c) a binding made from a non-tmux context (no tmuxSession ever stored) —
                 // that last case used to permanently lock the chat into spawn-mode.
                 // If respawn fails, fall through to spawn-mode inject for THIS turn
                 // but DON'T erase tmuxSession from store — next inbound will retry,
@@ -5321,7 +5521,7 @@ export const startMirror = (deps) => {
                 // First step of the job and the historical hang point — log BEFORE the
                 // probe so a stall is attributable to it next time, not invisible.
                 log.info({ target: a.target, sessionId: sid, pane: a.tmuxPane, gen: myGen }, "inject job start");
-                const paneAlive = a.tmuxPane ? await tmuxPaneAlive(a.tmuxPane) : false;
+                const paneAlive = a.tmuxPane ? await paneUsable(a.tmuxPane, a.jsonlPath) : false;
                 let freshSpawn = a.justSpawned === true;
                 a.justSpawned = false;
                 if (!paneAlive) {
@@ -5336,7 +5536,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: tagOfKey(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: displayName(a.target) || a.target, cwdOverride: a.runningCwd, cli: backendForPath(a.jsonlPath).name, model: a.model || undefined, systemPrompt: charterFor(a.target, { cwd: a.runningCwd }) });
                     if (r.ok && r.tmuxPane && r.tmuxSession) {
                         a.tmuxPane = r.tmuxPane;
                         a.tmuxSession = r.tmuxSession;