wezard 2.2.2 → 2.4.0

package/dist/daemon/mirror-bridge.js

@@ -13,29 +13,32 @@
 // Caveat: the user shouldn't be hammering the same session in their local TTY
 // while a `--resume` injection is in flight; Claude Code locks aren't strict.
 import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
 import { existsSync, readdirSync, readFileSync, statSync, watch, openSync, readSync, closeSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { expandHome, sanitizeId } from "../shared/paths.js";
 import { augmentedPath } from "../shared/exec-path.js";
 import { sleep, truncateWithCount, mapLimit } from "../shared/std.js";
-import { activeBackends, backendForPath, projectDirFor, projectDirsFor, } from "../shared/cli-backends.js";
+import { activeBackends, backendForPath, primaryBackend, projectDirFor, projectDirsFor, } from "../shared/cli-backends.js";
 import { isModalPane, isAskqSubmitPage, parseModalOptions, pickModalAnswer, pickAutoAllowAnswer, parseConfirmContext, looksLikePicker } from "../shared/modal-pane.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 { selectModel } from "./model-select.js";
+import { renameWindow, runTmux, spawnTmuxClaude } from "./spawn-tmux.js";
+import { selectEffort, selectModel } from "./model-select.js";
+import { parseEffort } from "../shared/effort.js";
 import { hasRegistry, markTranscript, probeOf, sessionOnPane, sessionPanes, submittedSince, watchRegistry } from "./cc-session.js";
 import { waitForIdle } from "./graph.js";
 import { wizardStore } from "./wizard.js";
 import { startSubagentWatch } from "./subagent-tail.js";
-import { knowsToolUse, recordTool, recordToolResult, recordMark, recordTurnStart, recordTurnQuery, recordTurnItem, recordTurnUsage, recordTurnClose, recordCloseOpenTurns, lastChannelOf, buildDetailUrl, buildChatUrl, roleUniq } from "./detail.js";
-import { labelFor, tagOfKey, baseOfKey, keyOf, stripSigil, displayName, withTagHeader, withLinkedTagHeader, linkedTagHead, linkTags, parseTagHeader, MAX_BODY_LINKS } from "../shared/session-label.js";
+import { knowsToolUse, recordTool, recordToolResult, recordMark, recordTurnStart, recordTurnQuery, recordTurnInject, recordTurnItem, recordTurnUsage, recordTurnClose, recordCloseOpenTurns, lastChannelOf, openTurnsOf, buildDetailUrl, buildChatUrl, roleUniq } from "./detail.js";
+import { errText } from "./last-response.js";
+import { labelFor, tagOfKey, baseOfKey, keyOf, stripSigil, displayName, withTagHeader, withLinkedTagHeader, linkedTagHead, linkTags, parseTagHeader, MAX_BODY_LINKS, isInternalKey } from "../shared/session-label.js";
 import { splitMarkdown } from "../shared/md-chunk.js";
 import { randomTip } from "./tips.js";
 import { chatBaseOf, chatNameOf, listChatNames, parsePeerRef, peerAddress } from "./chat-name.js";
-import { stripAnsi, paneIsBusy, transcriptStalled, summarizeTail, lastAssistantText, lastReply, replyToPeer as replyToPeerIn, unwrapPasted, lastContextTokens, keepaliveStamps, openKeepalivePing, talkRounds, openToolUses, renderDialog } from "./peers.js";
+import { stripAnsi, paneIsBusy, summarizeTail, lastAssistantText, lastReply, replyToPeer as replyToPeerIn, unwrapPasted, lastContextTokens, lastModel, cacheTouchMs, cacheTtlSec, keepaliveStamps, openKeepalivePing, lastUserTurn, talkRounds, openToolUses, renderDialog } from "./peers.js";
 import { keepalivePingSigs, isKeepalivePingText } from "../shared/keepalive.js";
 // PATH augmentation: launchd / systemd start the daemon
 // with a stripped PATH that often lacks nvm / homebrew, breaking spawn(claudeBin).
@@ -149,6 +152,9 @@ const findJsonlBySid = (sid, only) => {
 // codebuddy persists message/function_call records instead, so route every
 // parsed line through the owning backend's adapter first (identity for claude).
 const normalizeForPath = (path, raw) => backendForPath(path).normalizeTranscriptLine(raw);
+// /model、/effort 的本地回执 (spawn 兜底路径 / set_model 敲出来的) 是守护进程自己的
+// 操作痕迹, 不是聊天内容 —— 不镜像、不进详情页。
+const MODEL_RECEIPT_RE = /^(?:Set model to|Kept model as|Set effort level to|Kept effort|Switch model)\b/;
 // Local-command noise on user lines: Claude marks the caveat / command-stdout
 // records isMeta; codebuddy persists them as PLAIN user messages (no isMeta
 // field at all). Predicates looking for the first REAL user line must skip
@@ -472,6 +478,10 @@ const recoverToolUse = (toolUseId, deps) => {
     }
     return undefined;
 };
+const lineTs = (line) => {
+    const ts = Date.parse(line.timestamp ?? "");
+    return Number.isNaN(ts) ? undefined : ts;
+};
 // Render one transcript line into tagged items. Caller decides batching.
 const renderLine = (raw, deps) => {
     let line;
@@ -499,6 +509,13 @@ const renderLine = (raw, deps) => {
         const goal = line.type === "user" ? goalStartOf(line.message?.content) : undefined;
         return goal ? [goal] : [];
     }
+    // 插话: 正在跑的这一轮中途吃进去的那句, CLI 只落这一行 attachment, 没有 user 行 ——
+    // 不报到的话, 它的印章没人认领, 这句话在详情里就不存在。
+    if (line.type === "attachment" && line.attachment?.type === "queued_command" && typeof line.attachment.prompt === "string") {
+        const said = cleanUserText(line.attachment.prompt);
+        const ts = Date.parse(line.timestamp ?? "");
+        return said ? [{ kind: "user_inject", said, ts: Number.isNaN(ts) ? Date.now() : ts }] : [];
+    }
     const out = [];
     if (line.type === "user") {
         const c = line.message?.content;
@@ -511,6 +528,8 @@ const renderLine = (raw, deps) => {
             const stdoutMatch = c.match(/<local-command-stdout>([\s\S]*?)<\/local-command-stdout>/);
             if (stdoutMatch && stdoutMatch[1]) {
                 const skillOutput = stdoutMatch[1].replace(/\[[0-9;]*m/g, "").trim();
+                if (MODEL_RECEIPT_RE.test(skillOutput))
+                    return out;
                 if (skillOutput) {
                     out.push({ kind: "skill_output", body: `⚙️ ${skillOutput}` });
                 }
@@ -544,12 +563,13 @@ const renderLine = (raw, deps) => {
             // cover reloads or replays; the user message itself always can.
             if (deps.isKeepalivePing?.(text))
                 return [{ kind: "keepalive_start", body: text }];
+            // 自己注入的那一行不回显, 但要报个到: 它的印章 (谁说的、回复去哪) 在这一刻认领。
             if (deps.isOwnInject(text))
-                return []; // dedupe WeCom→CLI echo
+                return [{ kind: "user_query", body: unwrapPasted(c).trim(), said: text, ts: lineTs(line) }];
             const quoted = text.split("\n").map((l) => `> ${l}`).join("\n");
             // includeUser 只决定"渲不渲染", 不决定"算不算边界" —— quiet 的这一条照样发出,
             // onItem 消费完边界语义后自己丢掉。
-            out.push({ kind: "user_text", body: quoted, quiet: !deps.includeUser });
+            out.push({ kind: "user_text", body: quoted, quiet: !deps.includeUser, ts: lineTs(line) });
         }
         else if (Array.isArray(c) && hasImages(c) && !c.some((b) => b?.type === "tool_result")) {
             // 带图的一句话: [text "[Image #1]…", image, …]。去掉占位符才与注入时记下的原文同形,
@@ -557,10 +577,10 @@ const renderLine = (raw, deps) => {
             const raw = c.filter((b) => b?.type === "text").map((b) => b.text ?? "").join("\n");
             const text = cleanUserText(raw.replace(IMAGE_REF_RE, ""));
             if (text && !deps.isOwnInject(text)) {
-                out.push({ kind: "user_text", body: cleanUserText(raw).split("\n").map((l) => `> ${l}`).join("\n"), quiet: !deps.includeUser });
+                out.push({ kind: "user_text", body: cleanUserText(raw).split("\n").map((l) => `> ${l}`).join("\n"), quiet: !deps.includeUser, ts: lineTs(line) });
             }
             else {
-                out.push({ kind: "user_query", body: unwrapPasted(raw).trim(), said: text });
+                out.push({ kind: "user_query", body: unwrapPasted(raw).trim(), said: text, ts: lineTs(line) });
             }
         }
         else if (Array.isArray(c)) {
@@ -672,6 +692,7 @@ const renderLine = (raw, deps) => {
         const u = line.message?.usage;
         if (u) {
             const model = typeof line.message?.model === "string" ? line.message.model : undefined;
+            const effort = typeof line.effort === "string" && line.effort ? line.effort : undefined;
             const messageId = typeof line.message?.id === "string" ? line.message.id : undefined;
             const rawIn = u.input_tokens ?? 0;
             const cr = u.cache_read_input_tokens ?? 0;
@@ -685,6 +706,7 @@ const renderLine = (raw, deps) => {
             out.push({
                 kind: "turn_usage",
                 model,
+                effort,
                 messageId,
                 usage: {
                     input,
@@ -849,6 +871,9 @@ export const startMirrorTail = (deps) => {
             buffer = buffer.slice(nl + 1);
             if (!line.trim())
                 continue;
+            // 压缩边界: 对话被摘要替换, 系统提示 (宪章) 不变 —— 同 /clear 一样要补记忆。
+            if (deps.onCompact && line.includes('"compact_boundary"'))
+                deps.onCompact();
             for (const item of renderLine(line, deps))
                 deps.onItem(item);
         }
@@ -1412,6 +1437,8 @@ const injectViaTmux = async (target, text, images, log, freshSpawn, backend, jso
 // 证人不作声 (忙时排队、slash 命令、无注册表的后端) 才看框回没回到贴之前的样子。
 // 框认得出来时这条判据可信, 于是允许多补回车 (空框上的回车在 CLI 里是 no-op);
 // 每次补之前再问一遍证人, 已提交就不补。
+/** 具名粘贴 buffer 的序号 (见 loadAndPaste)。 */
+let pasteSeq = 0;
 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
@@ -1452,10 +1479,14 @@ const injectViaTmuxText = async (target, text, log, freshSpawn, witness = NO_WIT
     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 runTmux(["load-buffer", "-"], { stdin: text });
+        // 每次注入用自己的具名 buffer: 不同 pane 的注入并发时, 共用 tmux 的默认 buffer 会让
+        // 一方 load 之后、paste 之前被另一方覆盖 —— 两段文本互换 pane (实测: 同一毫秒投的两份
+        // 回执, 发给 A 的进了 B)。同一 pane 的串行管不到跨 pane。
+        const buf = `wezard-${process.pid}-${++pasteSeq}`;
+        const loaded = await runTmux(["load-buffer", "-b", buf, "-"], { stdin: text });
         if (!loaded.ok)
             return { ok: false, reason: `tmux load-buffer failed: ${loaded.stderr.slice(-200) || loaded.code}` };
-        const pasted = await runTmux(["paste-buffer", "-p", "-d", "-t", target]);
+        const pasted = await runTmux(["paste-buffer", "-b", buf, "-p", "-d", "-t", target]);
         if (!pasted.ok)
             return { ok: false, reason: `tmux paste-buffer failed: ${pasted.stderr.slice(-200)}` };
         return { ok: true };
@@ -1751,15 +1782,12 @@ export const startMirror = (deps) => {
         return true;
     };
     // Keepalive ping detector for the tail's user-line judgment — the SAME
-    // normalized-prefix signature set keepaliveTick feeds keepaliveStamps
-    // (every configured form + the bare "ping" legacy streak form), so
-    // renderLine, the tick and the transcript parser all agree on what counts
-    // as a ping. Content is the source of truth for the swallow: timers and
-    // echo-TTLs lose it across reloads/replays.
-    const pingSigs = keepalivePingSigs(cfg.wrc.mirror.keepalive.ping, cfg.wrc.mirror.keepalive.resumePing);
-    // The warmer alone — what the peer readers (peek / wait / roster summary) strip.
-    // `resumePing` is excluded on purpose: the turn it opens is real work resumed.
-    const warmerSigs = keepalivePingSigs(cfg.wrc.mirror.keepalive.ping);
+    // normalized-prefix signature set keepaliveTick feeds keepaliveStamps (the
+    // configured ping + the bare "ping" legacy streak form), so renderLine, the
+    // tick, the peer readers (peek / wait / roster summary) and the transcript
+    // parser all agree on what counts as a ping. Content is the source of truth
+    // for the swallow: timers and echo-TTLs lose it across reloads/replays.
+    const pingSigs = keepalivePingSigs(cfg.wrc.mirror.keepalive.ping);
     const isKeepalivePing = (text) => isKeepalivePingText(text, pingSigs);
     // ── Typewriter stream lifecycle ────────────────────────────────────
     // WeCom spec: server polls us for stream refreshes for up to 6 min from the
@@ -1932,16 +1960,18 @@ export const startMirror = (deps) => {
         if (isPrivate(a) && !/^\[(mirror|wezard)\]/.test(content.trim()))
             return;
         const chatId = replyChatId(a);
+        const turnId = a.briefTurnId; // 推送是排队异步的, 到发出时 turn 早已收口
         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 () => {
             for (const c of chunks) {
                 try {
-                    await client.sendMessage(chatId, { msgtype: "markdown", markdown: { content: c } });
+                    const ack = await client.sendMessage(chatId, { msgtype: "markdown", markdown: { content: c } });
+                    log.info({ sessionId: a.sessionId, turnId, chatId, len: c.length, ack: JSON.stringify(ack ?? null).slice(0, 300) }, "standalone pushed");
                 }
                 catch (e) {
-                    log.warn({ sessionId: a.sessionId, err: e.message }, "standalone push failed");
+                    log.warn({ sessionId: a.sessionId, chatId, err: errText(e) }, "standalone push failed");
                 }
             }
         })
@@ -1952,13 +1982,15 @@ export const startMirror = (deps) => {
         if (!hasVisibleBody(content))
             return;
         const chatId = replyChatId(a);
+        const turnId = a.briefTurnId;
         a.standalonePending = a.standalonePending
             .then(async () => {
             try {
                 await client.sendMessage(chatId, { msgtype: "markdown", markdown: { content } });
+                log.info({ sessionId: a.sessionId, turnId, chatId, len: content.length }, "raw pushed");
             }
             catch (e) {
-                log.warn({ sessionId: a.sessionId, err: e.message }, "raw push failed");
+                log.warn({ sessionId: a.sessionId, chatId, err: errText(e) }, "raw push failed");
             }
         })
             .catch(() => undefined);
@@ -2350,8 +2382,27 @@ export const startMirror = (deps) => {
     };
     /** 公开派活的那个同伴 —— 回复的头要标给它 (见 AttachState.replyTo)。 */
     const publicPeer = (from) => from?.kind === "peer" && from.public ? from.from : undefined;
+    /** reload 后 tail 从 EOF 接上: 正在跑的这一轮的开头那句已在身后, 它的印章随旧进程没了。
+     *  那句话自己挂着信封 (谁说的、私聊还是哪个群) —— 读回来就是这一轮的出处。没挂信封 = undefined。 */
+    const openingOf = (a) => {
+        const t = a.jsonlPath ? lastUserTurn(a.jsonlPath) : undefined;
+        const env = t?.env;
+        if (!env)
+            return undefined;
+        const home = baseOfKey(a.target);
+        const from = env.kind === "peer" ? { kind: "peer", from: wizardStore()?.byName(stripSigil(env.from))?.target, ...(env.private ? {} : { public: true }), ...(env.receipt ? { receipt: true } : {}), ...(env.status ? { status: env.status } : {}), ...(env.turn ? { turn: env.turn } : {}) }
+            : env.kind === "task" ? { kind: "task", taskId: env.from.replace(/^定时 /, "") }
+                : undefined;
+        return {
+            channel: env.private ? "" : (env.chat && chatBaseOf(cfg, env.chat)) || home,
+            speaker: env.kind === "human" ? `user:${env.from}` : undefined,
+            from,
+            query: t.text,
+        };
+    };
     /** 频道印章: 有新印章就换频道; 没有则 `reset` (CLI 手敲 / 人从聊天发起) 回到
-     *  home, 其余续写 (收口后的补写) 沿用上一轮。`from` = 本轮的出处, 答给谁跟着频道走。 */
+     *  home, 其余续写 (收口后的补写) 沿用上一轮。`from` = 本轮的出处, 答给谁跟着频道走。
+     *  返回 reload 后从 transcript 读回的开头那句 (见 openingOf), 没读到 = undefined。 */
     const consumeChannel = (a, reset, from) => {
         const p = a.pendingChannel;
         a.pendingChannel = undefined;
@@ -2374,15 +2425,27 @@ export const startMirror = (deps) => {
         }
         else if (!seeded) {
             // reload 后的第一轮续写: 内存里的频道随进程没了, 缺省 = home 会把一段私聊的
-            // 后续记成群里公开说的 (rolepage 上私聊窗口从此不再更新)。接回最近一轮的印章。
-            const last = lastChannelOf(a.target);
+            // 后续记成群里公开说的 (rolepage 上私聊窗口从此不再更新), 私聊的终句还会推进群。
+            // 先信这一轮开头那句自带的信封; 没有 (人在 home / CLI 里说的) 才接回最近一轮的印章 ——
+            // 刚出生的分身没有「最近一轮」, 只能靠信封。
+            const opening = openingOf(a);
+            const last = opening ?? lastChannelOf(a.target);
             if (last) {
                 a.channel = last.channel === baseOfKey(a.target) ? undefined : last.channel;
                 a.speaker = last.speaker;
                 a.replyTo = publicPeer(last.from);
                 a.convFrom = last.from;
             }
+            return opening?.query;
+        }
+        // 私聊派来的活 (不是回执) 这一轮必是私聊, 不论印章带没带频道: 进群的只能是人问的事的
+        // 交代与显式公开。带 task 的 fork 分身就只有出处、没有频道印章, 退回 home 就把私聊派的活答进了群。
+        if (from?.kind === "peer" && !from.public && !from.receipt) {
+            a.channel = "";
+            a.speaker = undefined;
+            a.replyTo = undefined;
         }
+        return undefined;
     };
     /** 本轮落 turn 记录的频道字段。 */
     const channelFields = (a) => ({ channel: a.channel ?? baseOfKey(a.target), speaker: a.speaker });
@@ -2395,14 +2458,103 @@ export const startMirror = (deps) => {
     // 详情页要按后端的名字称呼它 ("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();
+    // ── 印章 (见 Seal) ──────────────────────────────────────────────
+    // 盖在行上而不是格子里: 注入时记下, 行在 transcript 里露面时认领。比回显去重的 60s 活得久 ——
+    // 排在长轮后面的那一行露面时早过了 60s, 认不出就会被当成人在 CLI 里敲的。
+    const SEAL_TTL_MS = 2 * 3600_000;
+    const sealKeys = (text) => {
+        const t = cleanUserText(text);
+        if (!t.startsWith("/"))
+            return t ? [t] : [];
+        const head = t.split(/\s+/, 1)[0] ?? t;
+        const args = t.slice(head.length).trim();
+        return [t, `\`${head}${args ? ` ${args}` : ""}\``];
+    };
+    const pushSeal = (a, s) => {
+        const now = Date.now();
+        a.seals = [...(a.seals ?? []).filter((x) => now - x.at <= SEAL_TTL_MS), s];
+    };
+    /** 露面的这一行认领它的印章, 先注入的先认。CLI 把排队的几句并成一行时, 包含在里面的都算
+     *  露过面, 出处取第一枚。认不出 = undefined。 */
+    const takeSeal = (a, said, pick = () => true) => {
+        const t = said.trim();
+        const hit = (x) => pick(x) && x.keys.some((k) => k === t || (k.length >= 8 && t.includes(k)));
+        const seals = a.seals ?? [];
+        const hits = seals.filter(hit);
+        // CLI 把排队的几句并成一行, 这一轮只能有一个去向: 里面有私聊的那句就是私聊 —— 它的答复不能
+        // 跟着人的话进群; 没有才轮到人从聊天说的那句 (它的轮次与气泡早已建好)。
+        const first = hits.find((x) => x.channel === "") ?? hits.find((x) => !!x.turn) ?? hits[0];
+        if (!first)
+            return undefined;
+        a.seals = seals.filter((x) => !hit(x));
+        hits.filter((x) => x !== first && x.turn && !x.activated).forEach((x) => mergedAway(a, x.turn));
+        return first;
+    };
+    /** 人那句被并进了一轮私聊: 它预建的气泡与轮次收口成一个链接 —— 答复不进群, 也不让气泡挂到超时。 */
+    const mergedAway = (a, q) => {
+        void finishBubble(a, q.bubble, `${briefDetailLink(q.turnId, a.target)} （这句和一段私聊并成了一轮, 答复只在 rolepage）`, true);
+        recordTurnClose(q.turnId);
+    };
+    /** 人在聊天里说的那一句接成活跃 turn: 收掉在跑的那一轮, 频道与发话人取它自己的印章。
+     *  `at` = 那一行落盘的时刻: 排队的那句从这一刻才开始被处理, 轮次的起点以它为准; 闲时当场接上就是投递那一刻。 */
+    const activateDispatch = (a, s, at = s.at) => {
+        const q = s.turn;
+        s.activated = true;
         a.queryEpoch = (a.queryEpoch ?? 0) + 1; // WeCom 侧的新一轮同样是 query 边界
         a.turnFromChat = true; // 出处确凿: 这一轮有 frame, 群里就是它的主场
         a.pendingFromCli = false; // 人改从聊天里说话了, 之前那条 CLI 输入不再是出处
-        const from = consumeFrom(a);
-        consumeChannel(a, true, from);
-        recordTurnStart({ id: turnId, target: a.target, sessionId: a.sessionId, cli: cliOf(a), cwd: a.runningCwd || undefined, userQuery: userQuery.trim() || undefined, origin: consumeOrigin(a), from, ...channelFields(a) });
+        // 人说的这一轮没有同伴出处: 别的行认领了、还没开出轮的印章被这一句接管, 一并作废。
+        a.pendingFrom = undefined;
+        a.pendingOrigin = undefined;
+        a.pendingBriefQuery = undefined;
+        a.pendingChannel = { channel: s.channel ?? baseOfKey(a.target), speaker: s.speaker, at: Date.now() };
+        consumeChannel(a, true, undefined);
+        recordTurnStart({ id: q.turnId, target: a.target, sessionId: a.sessionId, cli: cliOf(a), cwd: a.runningCwd || undefined, userQuery: s.query.trim() || undefined, createdAt: at, ...channelFields(a) });
+        if (a.briefTurnId)
+            closeBriefTurn(a);
+        openBriefTurn(a, q);
+    };
+    /** 一句插话记进它插进的那一轮: 出处、频道、发话人都取它自己的印章 (没写频道 = 在 home 里开口)。 */
+    const injectInto = (turnId, a, s, ts) => recordTurnInject(turnId, { ts, body: s.query.trim(), ...(s.from ? { from: s.from } : {}), channel: s.channel ?? baseOfKey(a.target), ...(s.speaker ? { speaker: s.speaker } : {}) });
+    /** `attachment.queued_command` 露面: 那句被正在跑的这一轮中途吃进去了。认领它的印章记成插话。
+     *  人从聊天里说的那句 (印章带预建的轮) 不在这里认: 它已有自己的轮次记录。认不出 (人在 CLI 里
+     *  忙时敲的) 不记 —— 说不清是谁、在哪个频道说的。 */
+    const interject = (a, said, ts) => {
+        if (!a.briefTurnId)
+            return;
+        const s = takeSeal(a, said, (x) => !x.turn);
+        if (s)
+            injectInto(a.briefTurnId, a, s, ts);
+    };
+    /** 一行注入露面了: 把它的印章落成下一轮的出处 / 频道。返回认领到的印章。`ts` = 那一行落盘的时刻。 */
+    const bindLine = (a, said, ts) => {
+        const s = takeSeal(a, said);
+        if (!s)
+            return undefined;
+        if (s.turn) {
+            if (!s.activated)
+                activateDispatch(a, s, ts);
+            return s;
+        }
+        // 忙时贴进去、正在跑的那一轮还没出终句: 它是插进那一轮的话 (priority now), 那一轮的
+        // 回复仍归原来那一方, 这句记成那一轮的一条插话。闲时贴进去的、或上一轮已经说完的, 才是新一轮的开头。
+        if (a.briefTurnId && !a.briefConcluded && !s.fresh) {
+            injectInto(a.briefTurnId, a, s, Date.now());
+            return s;
+        }
+        if (a.briefTurnId)
+            closeBriefTurn(a);
+        const now = Date.now();
+        a.pendingFrom = s.from ? { from: s.from, at: now } : undefined;
+        a.pendingOrigin = s.origin ? { origin: s.origin, at: now } : undefined;
+        // 没写频道的注入 (graph 步骤 / 手动 inject) 等同在 home 里开口: 印章就是全部出处, 不沿用上一轮的。
+        a.pendingChannel = { channel: s.channel ?? baseOfKey(a.target), at: now };
+        a.pendingBriefQuery = s.query;
+        a.pendingBriefAt = ts;
+        return s;
+    };
+    const startBriefTurn = async (a, frame, streamId, isSlash = false, userQuery = "", channel, speaker) => {
+        const turnId = newTurnId();
         // hardTimer 兜底: turn 若无终句 / turn_end 收口 (卡死/漏收), 到点仍收气泡。
         const bubble = { frame, streamId, hardTimer: undefined, done: false };
         const q = { turnId, bubble, isSlash };
@@ -2413,15 +2565,23 @@ export const startMirror = (deps) => {
             const live = a.briefBubble === bubble && !a.briefConcluded;
             void finishBubble(a, bubble, `${briefDetailLink(turnId, a.target)}${live ? ` ${STILL_WORKING}` : ""}`, true);
         }, HARD_TIMEOUT_MS);
+        const seal = { keys: sealKeys(userQuery), at: Date.now(), query: userQuery, channel, speaker, fresh: true, turn: q };
+        // 对方闲着 → 这一句就是下一轮, 当场接上。正忙 (在跑别人的回执 / 派活 / 上一句) 就先排着:
+        // 那一轮的回复不能流进这一句的气泡, 等它在 transcript 里露面再接 (bindLine)。turn 记录
+        // 先建好, ack 里的链接点得开。斜杠命令的行未必露面, 当场接。
+        const queued = !isSlash && idleVerdict(a.target) === false;
+        pushSeal(a, seal);
+        if (queued)
+            recordTurnStart({ id: turnId, target: a.target, sessionId: a.sessionId, cli: cliOf(a), cwd: a.runningCwd || undefined, userQuery: userQuery.trim() || undefined, channel: channel ?? baseOfKey(a.target), speaker });
+        else
+            activateDispatch(a, seal);
         // 新消息 = 对话边界: 立刻收掉上一 turn, 新 turn 直接激活、不排队。收口语义见
         // closeBriefTurn: 有正文收入旧气泡, 没正文不写一个字 (绝不因边界结束凭空新发/
         // 覆盖消息)。旧 turn 在 CLI 侧的剩余产出自然流入新气泡 —— "新回复走最新气泡"
         // 正是这个语义。代价是旧 turn 页提前标完、尾部 item 记到新 turn 名下, 但远小于
         // 排队的代价: 排队 turn 的 frame 在前一个长 turn 期间 (可达数分钟) 过期, 激活后
-        // replyStream 全被 WeCom 拒收 (#stream 事故的静默根因)。
-        if (a.briefTurnId)
-            closeBriefTurn(a);
-        openBriefTurn(a, q);
+        // replyStream 全被 WeCom 拒收 (#stream 事故的静默根因)。所以只在前面真有别人的行排着时
+        // 才排 (见上): 接上时气泡若已过期, 正文走 standalone (concludeBriefTurn)。
         // ack 即详情链接。URL 的三个入参 (turnId / target / host) 在收消息这一刻全部已知 ——
         // turnId 是本地生成的, 详情页记录也已在 recordTurnStart 建好, 所以不必等 CLI 产出,
         // 也不必猜后端: codebuddy 那种几十秒后才落盘的轮, 入口从第一秒就在。
@@ -2433,6 +2593,35 @@ export const startMirror = (deps) => {
             log.warn({ sessionId: a.sessionId, turnId, err: e.message }, "brief: turn ack failed");
         }
     };
+    /** reload 后的第一笔产出: 那一轮多半还是旧进程开的那条记录 (内存里的 briefTurnId 随进程没了) ——
+     *  另开一轮就把一件活切成几段、每段都带着开头那句。只在 transcript 最后那句问话正是它的问话时接回,
+     *  频道与出处取它自己记下的; 对不上 (旧进程收口前就有了新问话) 照常开新的。 */
+    const resumeOpenTurn = (a) => {
+        if (a.channelSeeded)
+            return false;
+        const head = (t) => (t ?? "").replace(/\s+/g, " ").trim().slice(0, 60);
+        const said = head(a.jsonlPath ? lastUserTurn(a.jsonlPath)?.text : undefined);
+        const r = said ? openTurnsOf(a.target, a.sessionId).find((t) => head(t.userQuery) === said) : undefined;
+        if (!r)
+            return false;
+        a.channelSeeded = true;
+        a.pendingFrom = undefined;
+        a.pendingOrigin = undefined;
+        a.pendingChannel = undefined;
+        a.channel = r.channel === undefined || r.channel === baseOfKey(a.target) ? undefined : r.channel;
+        a.speaker = r.speaker;
+        a.convFrom = r.from;
+        a.replyTo = publicPeer(r.from);
+        a.turnFromChat = a.turnFromChat ?? true;
+        a.briefTurnId = r.id;
+        a.briefBubble = undefined;
+        a.briefIsSlash = false;
+        a.briefHadTool = r.items.some((it) => it.t === "tool_use");
+        a.briefConcluded = false;
+        a.briefLastText = undefined;
+        log.info({ sessionId: a.sessionId, turnId: r.id }, "brief: turn resumed after reload");
+        return true;
+    };
     // 无气泡 turn。CLI 侧自己开的一轮 (WeCom 从没发过消息, 拿不到 frame/streamId), 以及
     // 收口后仍有 item 补写进来的情况, 都要有一个 turn 承接 —— 否则每条 tool/text 都掉进
     // fallback standalone, 一轮工具密集的对话能在群里刷出几十条散装气泡。这里只推一条
@@ -2440,18 +2629,22 @@ export const startMirror = (deps) => {
     const ensureBriefTurn = (a) => {
         if (a.briefTurnId)
             return;
-        const turnId = newTurnId();
         const query = a.pendingBriefQuery?.replace(/^> ?/gm, "").trim();
+        const at = a.pendingBriefAt;
         a.pendingBriefQuery = undefined;
+        a.pendingBriefAt = undefined;
+        if (!query && a.pendingFromCli !== true && resumeOpenTurn(a))
+            return;
+        const turnId = newTurnId();
         // 出处继承: 有真人 CLI 输入行开头 → CLI 轮; 否则 (收口后的补写、peer/graph 注入
         // 开出的轮) 沿用上一轮 —— 那些续写属于同一场对话, 不该改变可见性。
         const fromCli = a.pendingFromCli === true;
         a.pendingFromCli = false;
         a.turnFromChat = fromCli ? false : a.turnFromChat ?? true;
         const fresh = consumeFrom(a);
-        consumeChannel(a, fromCli, fresh);
+        const opened = consumeChannel(a, fromCli, fresh);
         const from = fresh ?? a.convFrom;
-        recordTurnStart({ id: turnId, target: a.target, sessionId: a.sessionId, cli: cliOf(a), cwd: a.runningCwd || undefined, userQuery: query || undefined, origin: consumeOrigin(a), from, ...channelFields(a) });
+        recordTurnStart({ id: turnId, target: a.target, sessionId: a.sessionId, cli: cliOf(a), cwd: a.runningCwd || undefined, userQuery: query || opened || undefined, origin: consumeOrigin(a), from, ...channelFields(a), ...(query && at ? { createdAt: at } : {}) });
         a.briefTurnId = turnId;
         a.briefBubble = undefined;
         a.briefIsSlash = false;
@@ -2781,7 +2974,7 @@ export const startMirror = (deps) => {
             return;
         }
         if (item.kind === "turn_usage") {
-            recordTurnUsage(turnId, { model: item.model, messageId: item.messageId, usage: item.usage });
+            recordTurnUsage(turnId, { model: item.model, effort: item.effort, messageId: item.messageId, usage: item.usage });
             return;
         }
         if (item.kind === "skill_output") {
@@ -2983,6 +3176,10 @@ export const startMirror = (deps) => {
         // (crashed reply). Release BEFORE the swallow gate so this real line (and
         // its reply) mirror normally instead of being eaten by the stale swallow.
         if (item.kind === "user_text") {
+            // 回显去重只认 60s 内的注入: 排在长轮后面的那一行露面时已经过期, 会被当成人在 CLI 里敲的。
+            // 印章认得出就仍是那次注入 —— 不回显, 也不算 CLI 轮。
+            if (bindLine(a, item.body.replace(/^> ?/gm, ""), item.ts))
+                return;
             endKeepaliveSwallow(a);
             // 对话边界 = 旧 turn 清算。上一 turn 派发而未返回的前台 Agent/Task 到此作废,
             // 清掉防残留阻塞新 turn 的软收口 (guard 的 defer 判断依据)。
@@ -2992,13 +3189,24 @@ export const startMirror = (deps) => {
             // quiet (includeUser=false, 默认) 同样记: includeUser 只决定气泡渲不渲染,
             // 不决定详情页记不记 —— 聊天不再下发 CLI 轮之后, 详情页是唯一的落点。
             a.pendingBriefQuery = item.body;
+            a.pendingBriefAt = item.ts;
             a.pendingFromCli = true;
         }
+        if (item.kind === "user_inject") {
+            interject(a, item.said, item.ts);
+            return;
+        }
         // 还有一轮等着懒建 (peer / graph 注入先记了 pendingBriefQuery) 就换掉它; 否则这句话
         // 就是已开好的那一轮 (IM 侧说的, startBriefTurn 在注入前建好)。
         if (item.kind === "user_query") {
-            if (a.pendingBriefQuery !== undefined || !a.briefTurnId)
+            // 同伴 / 定时 / graph 注入的那一行: 问话就是印章里的原话 (不带信封)。
+            const sealed = bindLine(a, item.said, item.ts);
+            if (sealed && !sealed.turn)
+                return;
+            if (a.pendingBriefQuery !== undefined || !a.briefTurnId) {
                 a.pendingBriefQuery = item.body;
+                a.pendingBriefAt = item.ts;
+            }
             // 只认同一句话: 轮次中途 CLI 里又粘了一张图, 不能改写正在跑的这一轮的问话。
             else
                 recordTurnQuery(a.briefTurnId, item.body, (prev) => cleanUserText(prev ?? "") === item.said);
@@ -3032,7 +3240,7 @@ export const startMirror = (deps) => {
                     recordTurnItem(id, { t: "tool_result", toolUseId: item.toolUseId, body: item.full, ts: now });
                 }
                 else if (item.kind === "turn_usage") {
-                    recordTurnUsage(id, { model: item.model, messageId: item.messageId, usage: item.usage });
+                    recordTurnUsage(id, { model: item.model, effort: item.effort, messageId: item.messageId, usage: item.usage });
                 }
                 else if (item.kind === "turn_end") {
                     recordTurnClose(id);
@@ -3375,7 +3583,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, keepaliveDisabled }) => {
+    const attach = ({ sessionId, jsonlPath, target: targetOverride, tmuxPane, tmuxSession, cwd, model, effort, pendingCwd, keepaliveDisabled }) => {
         const target = resolveTarget(targetOverride);
         if (!target)
             return { ok: false, reason: "no target chat (set wrc.mirror.pushChat or defaultChat, or pass target)" };
@@ -3405,6 +3613,7 @@ 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 ?? "");
+        const carryEffort = effort !== undefined ? effort.trim() : (prevByTarget?.effort ?? deps.store.get(target)?.effort ?? "");
         // 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);
@@ -3423,6 +3632,7 @@ export const startMirror = (deps) => {
             runningCwd: expandHome(((cwd ?? "").trim()) || readCwdFromJsonl(jsonlPath) || cfg.wrc.cwd),
             pendingCwd: carryPending,
             model: carryModel,
+            effort: carryEffort,
             keepaliveDisabled: carryKeepaliveDisabled,
             tail: { stop: () => undefined, drain: () => undefined, livePath: () => undefined }, // placeholder; replaced below
             standalonePending: Promise.resolve(),
@@ -3440,6 +3650,7 @@ export const startMirror = (deps) => {
             isOwnAssistantSend,
             isKeepalivePing,
             onItem: (item) => onItem(a, item),
+            onCompact: () => contextCut(a.target, "compact"),
             detailUrlFor,
             sessionId,
             target,
@@ -3461,6 +3672,7 @@ export const startMirror = (deps) => {
             tmuxPane: a.tmuxPane || undefined,
             cwd: a.runningCwd || undefined,
             model: a.model || undefined,
+            effort: a.effort || undefined,
             pendingCwd: a.pendingCwd || undefined,
             cwdConfirmed: prevRec?.cwdConfirmed,
             keepaliveOff: prevRec?.keepaliveOff,
@@ -3498,8 +3710,12 @@ export const startMirror = (deps) => {
     // it collapses N distinct peers onto one sessionId (attach() then dedupes by
     // sid and silently detaches all-but-one). Excluding claimed sids keeps each
     // peer on its own session.
+    // 正在出生、还没 attach 的会话 sid: 新会话 (spawn 时 jsonl 就预建了) 与认下了的分叉
+    // 文件。同一个 cwd 下别的 target 的迁移 / 自愈 / 分叉跟随也在扫这个目录里「新出现的
+    // jsonl」, 不挡住的话它会先一步把别人的新会话认走, 正主 attach 时反撞 "already bound"。
+    const inFlightSids = new Set();
     const sidsClaimedByOthers = (principal) => {
-        const s = new Set();
+        const s = new Set(inFlightSids);
         for (const [k, v] of Object.entries(deps.store.all()))
             if (k !== principal && v.sessionId)
                 s.add(v.sessionId);
@@ -3609,6 +3825,7 @@ export const startMirror = (deps) => {
             tmuxSession: rec.tmuxSession ?? "",
             cwd: rec.cwd,
             model: rec.model,
+            effort: rec.effort,
             pendingCwd: rec.pendingCwd,
         });
         if (!r.ok) {
@@ -3809,6 +4026,17 @@ export const startMirror = (deps) => {
         catch { /* unreadable */ }
         return undefined;
     };
+    // A resume / --fork-session copy is seeded with the origin's history, uuids
+    // intact — so "its first user line is ours" is pane-certain evidence that a
+    // new jsonl is OUR fork. "Has any user content" is not: a sibling spawned in
+    // the same cwd a moment earlier also has some, and its sid isn't claimed yet
+    // (attach lands after the spawn) — that is how a respawned .evolve got bound
+    // to a haiku sibling's fresh transcript and read empty from then on.
+    const forkOf = (origin) => {
+        const seed = firstUserUuid(origin);
+        // origin 还没有 user 行 (没说过话就死了 / 刚开的父亲): 没有可比的种子, 退回旧判据。
+        return seed === undefined ? (path) => firstUserUuid(path) !== undefined : (path) => firstUserUuid(path) === seed;
+    };
     // startOffset semantics differ by caller: /clear passes 0 to replay the
     // freshly-rotated jsonl (only holds the /clear line + new content); resume
     // migration omits it (→ tail from EOF) because the fork file is seeded with
@@ -3829,6 +4057,8 @@ export const startMirror = (deps) => {
         // drift 上下文是延续的, 画中性的 "switch"。
         const cleared = jsonlIsPostClearChild(newJsonlPath);
         markCut(a.target, newSessionId, cleared ? "clear" : "switch");
+        if (cleared)
+            contextCut(a.target, "clear");
         if (cleared) {
             // 真清空 = 缓存里已无任何值得保温的内容。像 /stop 一样暂停保活 —— 与
             // dispatch 里 WeCom 注入 /clear 的暂停对齐;TUI 手打 /clear 只走这个漏斗,
@@ -3855,6 +4085,7 @@ export const startMirror = (deps) => {
             isOwnAssistantSend,
             isKeepalivePing,
             onItem: (item) => onItem(a, item),
+            onCompact: () => contextCut(a.target, "compact"),
             detailUrlFor,
             sessionId: newSessionId,
             target: a.target,
@@ -4057,6 +4288,9 @@ export const startMirror = (deps) => {
                 // Post-/clear: only transcripts that didn't exist before the rotation
                 // can be ours, which is what licenses the shorter fingerprint above.
                 .filter((n) => !pendingClear || !pendingClear.baseline.has(n))
+                // 别人的 (含还在出生、没 attach 的新会话与分叉 —— 分叉文件带着父亲注进去的原话,
+                // 指纹会撞上) 不认。
+                .filter((n) => !sidsClaimedByOthers(a.target).has(n.replace(/\.jsonl$/, "")))
                 .map((n) => ({ n, m: (() => { try {
                     return statSync(join(dir, n)).mtimeMs;
                 }
@@ -4199,6 +4433,17 @@ export const startMirror = (deps) => {
     // 新 pane 落地后的钩子 —— pane 上限在这里数 (由 index.ts 装上; 没装 = 不数)。
     let afterSpawn = () => { };
     const onSpawn = (fn) => { afterSpawn = fn; };
+    let afterCut = () => { };
+    const onContextCut = (fn) => { afterCut = fn; };
+    const contextCut = (target, cut) => {
+        log.info({ target, cut }, "context cut");
+        try {
+            afterCut(target, cut);
+        }
+        catch (e) {
+            log.warn({ target, cut, err: e.message }, "onContextCut hook threw");
+        }
+    };
     // `cwd` = 这个 pane 正要启动的目录。attach 在 spawn 之后才发生, 所以此刻 getCwd
     // 给的还是上一个 pane 的目录 —— 换目录重开时照它渲染, 新 wizard 会以为自己还在
     // 旧工作区里。
@@ -4210,6 +4455,32 @@ export const startMirror = (deps) => {
             return undefined;
         }
     };
+    // 确切模型名的证据 (见 exactModelId): transcript 里 API 真答过的 model id, 只认同一个
+    // CLI 的。先问最可能的那几个会话 (自己、被克隆者), 再按新近扫其余 —— 惰性的,
+    // 第一个对上就停, 绝大多数时候只读一两个 transcript 的尾巴。
+    function* modelSightings(cli, likely) {
+        const name = cli ?? primaryBackend().name;
+        const pathOf = (t) => byTarget.get(t)?.jsonlPath ?? expandHome(deps.store.get(t)?.jsonlPath ?? "");
+        const head = likely.map(pathOf).filter(Boolean);
+        // 生成器体到第一次取值才跑: 前几个就对上时, 其余几百个 stat 一个也不做。
+        const paths = function* () {
+            yield* head;
+            yield* Object.values(deps.store.all())
+                .map((r) => expandHome(r.jsonlPath))
+                .filter((p) => !head.includes(p))
+                .map((p) => ({ p, m: mtimeOf(p) }))
+                .filter((x) => x.m > 0)
+                .sort((x, y) => y.m - x.m)
+                .map((x) => x.p);
+        };
+        for (const path of paths()) {
+            if (!existsSync(path) || backendForPath(path).name !== name)
+                continue;
+            const id = lastModel(path);
+            if (id)
+                yield id;
+        }
+    }
     const newSession = async (target, windowName, cli, opts) => {
         const prev = byTarget.get(target);
         // Resolution precedence (all chat-scoped except the running-cwd fallback):
@@ -4241,23 +4512,36 @@ export const startMirror = (deps) => {
         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);
+        // 群的默认会话 (管家) 没点名模型 / 档位时用 models.router。只管这里新起的 —— 死 pane
+        // 重生走绑定里记下的模型, 不经过这里; 已在跑的管家也不动 (换模型会让缓存整份重读)。
+        const router = !tagOfKey(target) && !isInternalKey(target) ? cfg.models.router : undefined;
+        const effModel = opts?.model?.trim() || router?.model || undefined;
+        const effEffort = opts?.effort ?? parseEffort(prev?.effort ?? deps.store.get(target)?.effort) ?? router?.effort;
         if (prev?.tmuxPane) {
             // Best-effort kill; ignore errors (pane may already be dead).
             void runTmux(["kill-pane", "-t", prev.tmuxPane]);
         }
         if (prev)
             detach(prev, "/new respawn");
+        // sid 由这里先定, 出生到 attach 之间挂在 inFlightSids 上 (见那里)。
+        const freshSid = randomUUID();
+        inFlightSids.add(freshSid);
         const r = await spawnTmuxClaude({
             cfg,
             log: log.child({ sub: "new-session", target }),
+            sessionId: freshSid,
             windowName: windowName ?? target,
             cwdOverride: eff,
             cli: effCli,
-            model: opts?.model,
+            model: effModel,
+            knownModels: modelSightings(effCli, [target, base]),
+            effort: effEffort,
             systemPrompt: opts?.systemPrompt ?? charterFor(target, { cwd: eff }),
-        });
-        if (!r.ok)
+        }).catch((e) => { inFlightSids.delete(freshSid); throw e; });
+        if (!r.ok) {
+            inFlightSids.delete(freshSid);
             return { ok: false, reason: r.reason };
+        }
         const att = attach({
             sessionId: r.sessionId,
             jsonlPath: r.jsonlPath,
@@ -4271,9 +4555,11 @@ export const startMirror = (deps) => {
             // 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() ?? ""),
+            model: r.model ?? effModel ?? "",
+            effort: r.effort ?? "",
             keepaliveDisabled: opts?.keepalive === undefined ? undefined : !opts.keepalive,
         });
+        inFlightSids.delete(freshSid);
         if (!att.ok)
             return { ok: false, reason: att.reason };
         // 首条注入吃冷时序(injectText 走 /mirror/spawn 时已经硬编码 freshSpawn:true,
@@ -4307,6 +4593,8 @@ export const startMirror = (deps) => {
                     tmuxSession: baseA.tmuxSession || undefined,
                     tmuxPane: baseA.tmuxPane || undefined,
                     cwd: baseA.runningCwd || undefined,
+                    model: baseA.model || undefined,
+                    effort: baseA.effort || undefined,
                     cwdConfirmed: deps.store.get(base)?.cwdConfirmed,
                     pendingCwd: undefined,
                 });
@@ -4320,7 +4608,7 @@ export const startMirror = (deps) => {
         if (!opts?.silent)
             pushProjectInfo(target, "created");
         afterSpawn();
-        return { ok: true, sessionId: r.sessionId, cwd: r.cwd, model: r.model, modelWarning: r.modelWarning };
+        return { ok: true, sessionId: r.sessionId, cwd: r.cwd, model: r.model, modelWarning: r.modelWarning, effort: r.effort };
     };
     // ── Clone ───────────────────────────────────────────────────────────
     // 分身 = `--resume <父 sid> --fork-session` 起的新 pane: CLI 把父亲的 transcript
@@ -4337,19 +4625,35 @@ export const startMirror = (deps) => {
     //     (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;
+    // 认下的分叉文件同样记进 inFlightSids: 同一个父亲并发克隆出几个分身时, 每个分叉的首行
+    // 都与父亲相同, 不预留的话两个 awaitFork 会认下同一个文件。
+    const awaitFork = async (projectDir, baseline, claimed, origin, probe) => {
+        const ours = forkOf(origin);
+        const take = (sessionId, jsonlPath) => (inFlightSids.add(sessionId), { sessionId, jsonlPath });
+        const start = Date.now();
+        const deadline = start + FORK_WAIT_MS;
         while (Date.now() < deadline) {
+            // 首选会话注册表: 它按 pane 报这个进程此刻的 sid —— 并发分叉时唯一不靠猜的来源。
+            const live = probe.pane ? sessionOnPane(probe.homeDir, probe.pane) : undefined;
+            if (live && live.sessionId !== probe.parentSid && !claimed.has(live.sessionId)) {
+                const path = join(projectDir, `${live.sessionId}.jsonl`);
+                if (existsSync(path) && ours(path))
+                    return take(live.sessionId, path);
+            }
             const born = [...listJsonls(projectDir)]
-                .filter((n) => !baseline.has(n) && !claimed.has(n.replace(/\.jsonl$/, "")))
+                .filter((n) => !baseline.has(n) && !claimed.has(n.replace(/\.jsonl$/, "")) && !inFlightSids.has(n.replace(/\.jsonl$/, "")))
                 .map((n) => ({ n, path: join(projectDir, n) }))
                 // 种子化的 fork 一落地就带着父亲的 user 行 —— 空文件 (刚 touch 出来的)
-                // 还不能认, 认早了 tail 会从一个还没写完的复制过程中间开始读。
-                .filter((c) => firstUserUuid(c.path) !== undefined)
+                // 还不能认, 认早了 tail 会从一个还没写完的复制过程中间开始读; 别的 pane
+                // 同时新开的会话也有 user 行, 只认首行 uuid 与父亲相同的那个。
+                .filter((c) => ours(c.path))
                 .sort((x, y) => mtimeOf(y.path) - mtimeOf(x.path));
-            const hit = born[0];
+            // 注册表报不出 (没有注册表的后端 / 这个 pane 没登记 / 一阵子了还报着父亲的 sid)
+            // 才按「新出现、首行同父」去猜, 认下即预留。
+            const guess = !hasRegistry(probe.homeDir) || !live || Date.now() - start > FORK_WAIT_MS / 3;
+            const hit = guess ? born[0] : undefined;
             if (hit)
-                return { sessionId: hit.n.replace(/\.jsonl$/, ""), jsonlPath: hit.path };
+                return take(hit.n.replace(/\.jsonl$/, ""), hit.path);
             await sleep(FORK_POLL_MS);
         }
         return undefined;
@@ -4362,7 +4666,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, keepalive: args.keepalive,
+                model: args.model, effort: args.effort, cwd: args.cwd, systemPrompt: args.systemPrompt, silent: true, keepalive: args.keepalive,
             });
             return { ...r, inherited: false };
         }
@@ -4370,6 +4674,10 @@ export const startMirror = (deps) => {
         const projectDir = dirname(parent.jsonlPath);
         const baseline = listJsonls(projectDir);
         const lg = log.child({ sub: "clone", target: args.target });
+        // 分身默认跑被克隆者此刻真在跑的那个: 记下的模型, 没记 (CLI 默认) 就取它 transcript 里的 id。
+        const parentCli = backendForPath(parent.jsonlPath).name;
+        const model = args.model?.trim() || parent.model || lastModel(parent.jsonlPath);
+        const effort = args.effort ?? parseEffort(parent.effort);
         const r = await spawnTmuxClaude({
             cfg,
             log: lg,
@@ -4377,15 +4685,17 @@ export const startMirror = (deps) => {
             forkSession: true,
             windowName: args.windowName ?? args.target,
             cwdOverride: parent.runningCwd,
-            cli: backendForPath(parent.jsonlPath).name,
-            model: args.model,
+            cli: parentCli,
+            model,
+            knownModels: modelSightings(parentCli, [args.parent]),
+            effort,
             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);
@@ -4398,7 +4708,9 @@ export const startMirror = (deps) => {
             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));
+        const fork = await awaitFork(projectDir, baseline, sidsClaimedByOthers(args.target), parent.jsonlPath, {
+            homeDir: backendForPath(parent.jsonlPath).homeDir, pane: r.tmuxPane ?? "", parentSid: parent.sessionId,
+        });
         // 等不到分叉就必须收手: 此刻唯一已知的 sid 是父亲的, 认下去两个 target 会指向
         // 同一个会话 (attach 也会正当地拒绝)。留一个孤儿 pane 比留一条错绑更好收拾 ——
         // 所以连 pane 一起杀掉, 调用方拿到的是一个干净的失败。
@@ -4414,24 +4726,35 @@ export const startMirror = (deps) => {
             tmuxSession: r.tmuxSession,
             cwd: r.cwd,
             pendingCwd: "",
-            model: r.model ?? (args.model?.trim() ?? ""),
+            model: r.model ?? model,
+            effort: r.effort ?? "",
             keepaliveDisabled: args.keepalive === undefined ? undefined : !args.keepalive,
         });
+        // 绑上 (或没绑上) 之后预留就没用了: 绑上的 sid 由 sidsClaimedByOthers 挡住别人。
+        inFlightSids.delete(fork.sessionId);
         if (!att.ok)
             return { ok: false, reason: att.reason, inherited: false };
         const spawned = byTarget.get(args.target);
         if (spawned) {
             // muteUntilInject 是给"全新 pane 的 greeting 噪音"准备的; 分身的开场白是正经
-            // 内容 (群里第一条就该是它), 所以这里不静音。
+            // 内容 (rolepage 上它的第一轮), 所以这里不静音 —— 进不进群由下面的频道印章定。
             spawned.justSpawned = true;
             spawned.keepaliveOff = true;
             spawned.keepaliveOffAt = Date.now();
             spawned.keepalive = undefined;
             persistPause(spawned);
+            // 开场白早在 attach 之前就落进分叉文件了 (tail 从 EOF 起, 读不到那一行): 第一轮懒建时
+            // 才认得出它是谁派的活。印章赶在 tail 第一次 drain 之前盖上。
+            if (args.bootstrapFrom) {
+                spawned.pendingFrom = { from: args.bootstrapFrom.from, at: Date.now() };
+                spawned.pendingBriefQuery = args.bootstrapFrom.query;
+            }
+            // 开场白不是谁在群里问的: 带活的是私聊派活, 不带的是守护进程让它自报家门 —— 都只进 rolepage。
+            spawned.pendingChannel = { channel: "", at: Date.now() };
         }
         lg.info({ parent: args.parent, sessionId: fork.sessionId }, "clone: forked");
         afterSpawn();
-        return { ok: true, sessionId: fork.sessionId, cwd: r.cwd, inherited: true, model: r.model, modelWarning: r.modelWarning };
+        return { ok: true, sessionId: fork.sessionId, cwd: r.cwd, inherited: true, model: r.model, modelWarning: r.modelWarning, effort: r.effort };
     };
     /** 一个会话此刻的硬事实 —— whoami / 交接判断要用的那几个数。 */
     const sessionInfo = (target) => {
@@ -4447,6 +4770,7 @@ export const startMirror = (deps) => {
             cwd: a?.runningCwd || rec?.cwd || "",
             cli: backendForPath(jsonlPath).name,
             model: a?.model || rec?.model || "",
+            effort: a?.effort || rec?.effort || "",
             tmuxPane: a?.tmuxPane ?? rec?.tmuxPane ?? "",
             contextTokens: lastContextTokens(jsonlPath),
         };
@@ -4605,7 +4929,8 @@ export const startMirror = (deps) => {
             ...allTargets().map(baseOfKey),
             baseOfKey(self),
         ]);
-        return [...bases].filter(Boolean).sort().map((base) => ({
+        // 内部会话 (记忆整理者) 的 home 不是聊天: 不列、不补名。
+        return [...bases].filter((b) => b && !isInternalKey(b)).sort().map((base) => ({
             base,
             name: chatNameOf(cfg, base),
             self: base === baseOfKey(self),
@@ -4633,18 +4958,27 @@ export const startMirror = (deps) => {
             return false;
         if (live.status !== "idle")
             return undefined;
+        return !hanging(target, live.sessionId);
+    };
+    /** 闲着却悬着工具调用 = 停在审批卡 / 本地弹窗上。resume / fork 会换 sid: 悬着的
+     *  调用记在注册表报的当前那份 transcript 里。 */
+    const hanging = (target, sid) => {
         const bound = jsonlOf(target);
-        // resume / fork 会换 sid: 悬着的工具调用记在注册表报的当前那份 transcript 里。
-        const jsonl = bound ? join(dirname(bound), `${live.sessionId}.jsonl`) : "";
-        return !(jsonl && existsSync(jsonl) && openToolUses(jsonl).length > 0);
+        const jsonl = bound ? join(dirname(bound), `${sid}.jsonl`) : "";
+        return !!jsonl && existsSync(jsonl) && openToolUses(jsonl).length > 0;
+    };
+    const parkedNow = (target) => {
+        const pane = paneOf(target);
+        const live = pane ? activeBackends().map((b) => sessionOnPane(b.homeDir, pane)).find(Boolean) : undefined;
+        return live?.status === "idle" && hanging(target, live.sessionId);
     };
     const idleNow = async (target) => idleVerdict(target) ?? !(await isBusy(target));
     // 等到它闲下来, 事件驱动: 注册表目录一有写入就重判, 翻成 idle 的那一刻即返回。
     // 兜底轮询只防 watch 漏事件 (以及悬着的审批被点掉后 status 没再动的边角)。
     const IDLE_SAFETY_POLL_MS = 1000;
-    const untilIdle = (target, timeoutMs) => {
+    const untilIdle = (target, timeoutMs, { aborted = () => false, confirm = 2 } = {}) => {
         if (idleVerdict(target) === undefined)
-            return waitForIdle(target, isBusy, timeoutMs, () => false, { rampMs: 0, confirm: 2 });
+            return waitForIdle(target, isBusy, timeoutMs, aborted, { rampMs: 0, confirm });
         return new Promise((resolve) => {
             let done = false;
             const finish = (r) => {
@@ -4660,6 +4994,10 @@ export const startMirror = (deps) => {
             const check = async () => {
                 if (done)
                     return;
+                if (aborted()) {
+                    finish({ idle: false, reason: "stopped" });
+                    return;
+                }
                 const v = idleVerdict(target);
                 if (v ?? !(await isBusy(target)))
                     finish({ idle: true });
@@ -4672,15 +5010,15 @@ export const startMirror = (deps) => {
     };
     const lastText = (target) => {
         const p = jsonlOf(target);
-        return p ? lastAssistantText(p, 4000, warmerSigs) : "";
+        return p ? lastAssistantText(p, 4000, pingSigs) : "";
     };
     const replySince = (target, sinceMs = 0) => {
         const p = jsonlOf(target);
-        return p ? lastReply(p, sinceMs, warmerSigs) : "";
+        return p ? lastReply(p, sinceMs, pingSigs) : "";
     };
-    const replyToPeerSince = (target, fromName, sinceMs = 0) => {
+    const replyToPeerSince = (target, fromName, sinceMs = 0, turn) => {
         const p = jsonlOf(target);
-        return p ? replyToPeerIn(p, fromName, sinceMs, warmerSigs) : undefined;
+        return p ? replyToPeerIn(p, fromName, sinceMs, pingSigs, turn) : undefined;
     };
     /** 绑着的 pane 还能用 (存在、且不是别人的窗口) —— 不重生、不猜。 */
     const paneLiveOf = async (target) => {
@@ -4747,7 +5085,7 @@ export const startMirror = (deps) => {
             paneAlive,
             busy: paneAlive ? paneIsBusy(await capturePaneTail(pane, 12)) : false,
             lastActivity,
-            summary: jsonlPath ? summarizeTail(jsonlPath, 3, 80, warmerSigs) : "(未绑定会话)",
+            summary: jsonlPath ? summarizeTail(jsonlPath, 3, 80, pingSigs) : "(未绑定会话)",
             self: t === self,
         };
     };
@@ -4804,24 +5142,27 @@ export const startMirror = (deps) => {
             return { ok: false, reason: "它还没有 transcript (没接过第一句话) —— send_peer 跟它说一句就有了", busy };
         // `n` 数的是来回: 每个来回给问话和它最新的一句 (跑完的是终句, 还在跑的是途中
         // 最近说的那句) —— 途中的其余叙述不给, 那是过程不是结论。
-        const rounds = talkRounds(jsonl, n, warmerSigs).slice(-n);
+        const rounds = talkRounds(jsonl, n, pingSigs).slice(-n);
         const dialog = renderDialog(rounds.flatMap((r) => (r.length > 1 ? [r[0], r.at(-1)] : r)), 800, 4000);
         const waiting = busy ? [] : openToolUses(jsonl);
         return dialog ? { ok: true, dialog, busy, waiting } : { ok: false, reason: "transcript 里还没有对话", busy, waiting };
     };
     // ── Prompt-cache keepalive ──────────────────────────────────────────
-    // Anthropic's prompt cache expires ~5min after the last request. A pane that
-    // goes idle (agent parked on a peer, background task running) lets the whole
-    // context fall out of cache — the next real turn then re-writes it at 1.25x.
-    // We inject a tiny ping just before expiry so the model makes one cheap
-    // request (cache-read 0.1x) that slides the TTL forward. The whole schedule is
-    // anchored to the last REAL (non-ping) activity, NOT to our own pings — so a
-    // dead session is never kept warm forever, and once real work is older than
-    // `maxIdleSec` we stop and let the cache die.
+    // Anthropic's prompt cache expires a TTL (5min API default, 1h on a Claude Code
+    // subscription) after the start of the last request. A pane that goes idle
+    // (agent parked on a peer, background task running) lets the whole context fall
+    // out of cache — the next real turn then re-writes it. We inject a tiny ping just
+    // before expiry so the model makes one cheap request (cache-read) that slides the
+    // TTL forward. The budget is anchored to the last REAL (non-ping) activity, NOT to
+    // our own pings — so a dead session is never kept warm forever.
     // After `/stop`, ignore pane-busy as a resume signal for this long — long
     // enough for an in-flight ping (interrupted by the same /stop's Esc) to settle,
     // so it can't self-resume the pause. A genuine new turn after this window does.
     const RESUME_GRACE_MS = 30_000;
+    // A cache untouched this long is not kept warm: on a 1h entry the ping would come
+    // ~59min into the idle stretch, re-reading the whole context to cover a gap the
+    // TTL already covered — warming only pays on short (5min) entries.
+    const KEEPALIVE_MAX_IDLE_MS = 10 * 60_000;
     // Seed the keepalive clocks from message-turn timestamps (keepaliveStamps), never
     // from file mtime — non-message lines (file-history-snapshot / ai-title / mode)
     // bump mtime without being a model turn, which would fake a long-dead session
@@ -4841,21 +5182,18 @@ export const startMirror = (deps) => {
             round = s.streak;
         }
         catch { /* unreadable tail */ }
-        return { lastMs, lastRealMs, seenMtime: mtime, pinging: false, pingMtime: 0, round, settledAt: 0 };
+        return { lastMs, lastRealMs, seenMtime: mtime, pinging: false, pingMtime: 0, round, settledAt: 0, ttlSec: cacheTtlSec(jsonlPath), cacheAt: cacheTouchMs(jsonlPath) };
     };
-    const fireKeepalive = async (a, stalled) => {
+    const fireKeepalive = async (a) => {
         const kc = cfg.wrc.mirror.keepalive;
-        // Stalled (error/limit banner + idle pane): send the full resume instruction
-        // — inviting the model to finish genuinely-unfinished work, or to reply
-        // "pong" if it was legitimately parked. Otherwise the plain warmer, the SAME
-        // full instruction every round: a bare "ping" used to be sent from round 2 on
+        // The SAME full instruction every round: a bare "ping" used to be sent from round 2 on
         // (the instruction was already in context), but the model reads a bare "ping"
         // as an open turn and answers it however it likes — anything other than
         // "pong" un-swallows the heartbeat into chat and re-anchors the clocks as
         // real activity. Restating the instruction is a few tokens of cache-write and
         // buys a deterministic reply. keepaliveStamps matches every form, so none
         // reads as real activity. (round is incremented below, after the inject lands.)
-        const text = stalled ? kc.resumePing : kc.ping;
+        const text = kc.ping;
         // Suppress the pane→WeCom echo of the ping user line, then swallow the whole
         // ping turn (reply included). The 60s fail-safe clears the quiet window if
         // the turn somehow never emits turn_end, so a later real turn is never muted;
@@ -4902,13 +5240,11 @@ export const startMirror = (deps) => {
             return;
         keepaliveTicking = true;
         try {
-            const idleTriggerMs = Math.max(30, kc.ttlSec - kc.marginSec) * 1000;
-            const ttlMs = kc.ttlSec * 1000;
-            const pingSigs = [normAssistant(kc.ping).slice(0, 40), normAssistant(kc.resumePing).slice(0, 40)].filter((s) => s.length > 0);
+            const pingSigs = [normAssistant(kc.ping).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
+                    continue; // sticky spawn-time opt-out — never pings
                 if (!a.tmuxPane)
                     continue; // spawn-mode: no live pane to warm
                 if (a.migrationWatcher)
@@ -4942,6 +5278,8 @@ export const startMirror = (deps) => {
                         k.lastMs = mtime;
                         k.lastRealMs = mtime;
                     } // backend without timestamps → fall back to mtime
+                    k.ttlSec = cacheTtlSec(a.jsonlPath) || k.ttlSec;
+                    k.cacheAt = cacheTouchMs(a.jsonlPath) || k.cacheAt;
                 }
                 k.seenMtime = mtime;
                 // Round reset / real-activity re-anchor keys off REAL turns only — a
@@ -4979,22 +5317,25 @@ export const startMirror = (deps) => {
                 }
                 if (a.keepaliveOff)
                     continue; // paused by /stop until real activity returns
-                const idleSinceTouch = k.lastMs ? now - k.lastMs : now - mtime; // last model turn = cache touch
-                if (idleSinceTouch < idleTriggerMs)
+                // Cache clock = start of the newest answered request (TTL runs from there),
+                // not the last turn's write time; no request on record → the turn clock.
+                const sinceCache = now - (k.cacheAt || k.lastMs || mtime);
+                // The TTL the session's cache entries were actually written with (1h on a
+                // Claude Code subscription), not a guess: pinging at the 5min cadence
+                // against a 1h entry re-reads the whole context ~14x per hour for nothing.
+                const ttlMs = (k.ttlSec || kc.ttlSec) * 1000;
+                const idleTriggerMs = Math.max(30_000, ttlMs - kc.marginSec * 1000);
+                if (sinceCache < idleTriggerMs)
                     continue; // cache still comfortably warm
-                if (idleSinceTouch >= ttlMs)
+                if (sinceCache >= ttlMs)
                     continue; // cache already cold — a ping would cold-rewrite for nothing
+                if (sinceCache > KEEPALIVE_MAX_IDLE_MS)
+                    continue; // idle past 10min (a long-TTL entry) — not worth warming
                 if (k.round >= kc.rounds)
                     continue; // budget spent — let it go cold
-                // Stall recovery, decided by RULE only (no model self-judgment) and from
-                // the transcript's structure only — never the screen: the turn is still
-                // unfinished (died on a synthetic API error, or a tool result nobody
-                // answered) and has been quiet for the whole idle window. Send the resume
-                // instruction instead of the plain warmer.
-                const stalled = kc.resumeOnStall && transcriptStalled(a.jsonlPath, keepalivePingSigs(kc.ping, kc.resumePing), idleTriggerMs, now);
                 k.pinging = true;
                 k.pingMtime = k.lastMs; // settles when a newer turn (the ping's own) appears
-                await fireKeepalive(a, stalled);
+                await fireKeepalive(a);
             }
         }
         catch (e) {
@@ -5150,6 +5491,7 @@ export const startMirror = (deps) => {
         peekTurns,
         isBusy,
         idleNow,
+        parkedNow,
         untilIdle,
         setModel: async (target, wanted, scope) => {
             const a = byTarget.get(target);
@@ -5164,6 +5506,19 @@ export const startMirror = (deps) => {
             }
             return r;
         },
+        setEffort: async (target, effort) => {
+            const a = byTarget.get(target);
+            if (!a?.tmuxPane || !(await tmuxPaneAlive(a.tmuxPane)))
+                return { ok: false, reason: "它没有活着的 pane —— 档位是在 pane 里切的, 先叫醒它" };
+            const r = await selectEffort(a.tmuxPane, effort, log.child({ sub: "set-effort", target }));
+            if (r.ok && r.applied) {
+                a.effort = r.applied;
+                const rec = deps.store.get(target);
+                if (rec)
+                    deps.store.set(target, { ...rec, effort: r.applied });
+            }
+            return r;
+        },
         transcripts: () => allTargets().flatMap((target) => {
             const jsonlPath = jsonlOf(target);
             if (!jsonlPath)
@@ -5368,34 +5723,29 @@ export const startMirror = (deps) => {
             rememberInject(full);
             // 印章要早于 inject 落地 —— tail 是独立轮询的, 它可能在 inject 的 promise
             // resolve 之前就看到 user 行并开出 turn, 那时归因必须已经在位。
-            if (origin)
-                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;
+            // 印章随这一行走 (见 Seal): 行露面时才落成那一轮的出处 / 频道 / 问话。
+            pushSeal(a, { keys: sealKeys(full), at: Date.now(), query: text, from: opts?.from, channel: opts?.channel, origin, fresh: idleVerdict(target) === true });
             const sid = a.sessionId;
             const paneAlive = a.tmuxPane ? await paneUsable(a.tmuxPane, a.jsonlPath) : false;
+            // 同 dispatch: 只有刚生 / 刚重生的 pane 才要冷启动的宽限 —— 对一个热着、正忙的 pane 贴 `now`
+            // 也按冷启动等 idle 至多 15s, 「不等不打断」就成了「晚 15–20s 才进」(handoff-owe 的竞态即此)。
+            let fresh = a.justSpawned === true;
             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: displayName(target) || target, cwdOverride: a.runningCwd, cli: backendForPath(a.jsonlPath).name, model: a.model || undefined, systemPrompt: charterFor(target, { cwd: a.runningCwd }) });
+                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, knownModels: modelSightings(backendForPath(a.jsonlPath).name, [target]), effort: parseEffort(a.effort), systemPrompt: charterFor(target, { cwd: a.runningCwd }) });
                 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, model: a.model || undefined, pendingCwd: a.pendingCwd || undefined });
-                startMigrationWatcher(a, resumeBaseline, (p) => firstUserUuid(p) !== undefined);
+                deps.store.set(target, { sessionId: sid, jsonlPath: a.jsonlPath, tmuxSession: a.tmuxSession, tmuxPane: a.tmuxPane, cwd: a.runningCwd || undefined, model: a.model || undefined, effort: a.effort || undefined, pendingCwd: a.pendingCwd || undefined });
+                startMigrationWatcher(a, resumeBaseline, forkOf(a.jsonlPath));
+                fresh = true;
             }
-            // freshSpawn: true — the pane was just minted by /mirror/spawn, the TUI
-            // is still warming up so the verifier in injectViaTmux needs the slack.
             // 同 dispatch: 在 inject 之前解除静默, 防止验证循环中 LLM 回复被永久吞掉。
             a.muteUntilInject = false;
             a.justSpawned = false;
@@ -5405,7 +5755,7 @@ export const startMirror = (deps) => {
             const preClearBaseline = clearing ? listJsonls(dirname(a.jsonlPath)) : undefined;
             const r = await inject({
                 text: full, images: [], cfg, log: log.child({ principal: target, sessionId: sid, sub: "init-demo" }),
-                sessionId: sid, jsonlPath: a.jsonlPath, tmuxTarget: a.tmuxPane, freshSpawn: true,
+                sessionId: sid, jsonlPath: a.jsonlPath, tmuxTarget: a.tmuxPane, freshSpawn: fresh,
             });
             if (r.ok && a.tmuxPane) {
                 if (preClearBaseline) {
@@ -5507,6 +5857,27 @@ export const startMirror = (deps) => {
                 return 0;
             }
         },
+        reapUnborn: async (names) => {
+            const want = new Set(names.flatMap((n) => [n, `.${n}`]));
+            if (!want.size)
+                return [];
+            const snap = await runTmux(["list-panes", "-a", "-F", "#{pane_id}\t#{session_name}\t#{window_name}"]);
+            if (snap.code !== 0)
+                return [];
+            const bound = new Set(allTargets().map(paneOf).filter(Boolean));
+            const doomed = snap.stdout.split("\n").filter(Boolean).map((l) => l.split("\t"))
+                .filter(([pane = "", session, win = ""]) => session === cfg.wrc.tmuxPrefix && want.has(win) && !bound.has(pane))
+                .map(([pane = ""]) => pane);
+            const killed = [];
+            for (const pane of doomed) {
+                // 与 killPane 同款前戏: Esc 给可能已起来的 CLI 一个收束落盘的机会。
+                await runTmux(["send-keys", "-t", pane, "Escape"]);
+                await sleep(250);
+                if ((await runTmux(["kill-pane", "-t", pane])).code === 0)
+                    killed.push(pane);
+            }
+            return killed;
+        },
         reapOverflow: async (max, skip) => {
             const now = Date.now();
             const reaped = [];
@@ -5613,6 +5984,13 @@ export const startMirror = (deps) => {
             log.info({ target, sessionId: a.sessionId, pane: a.tmuxPane }, "mirror /n — Enter sent to pane");
             return { ok: true };
         },
+        retitlePane: async (target) => {
+            const pane = paneOf(target);
+            if (!pane)
+                return { ok: false, reason: "no tmux pane bound for target" };
+            const r = await renameWindow(pane, displayName(target) || target);
+            return r.code === 0 ? { ok: true } : { ok: false, reason: `rename-window failed: ${r.stderr.trim() || r.code}` };
+        },
         revealPane: async (target) => {
             // paneOf (not byTarget.get) so a cold binding surviving only in the
             // persisted store can still be revealed after a daemon reload.
@@ -5686,6 +6064,7 @@ export const startMirror = (deps) => {
         sessionInfo,
         setCharterProvider,
         onSpawn,
+        onContextCut,
         shutdown: () => {
             clearInterval(paneDriftTimer);
             clearInterval(keepaliveTimer);
@@ -5742,7 +6121,9 @@ 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() };
+            // brief 模式下频道随这一句的印章走 (startBriefTurn); 其余路径仍是开 turn 时消费的格子。
+            if (!cfg.wrc.mirror.brief || isClearCommand(text))
+                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.
@@ -5836,7 +6217,7 @@ export const startMirror = (deps) => {
                 // 挂 loading 气泡并起新 turn —— 上一 turn 若还在跑, startBriefTurn 内部
                 // 会立刻把它收掉 (对话边界策略), 本轮直接成为活跃 turn。
                 // 后续 onItem 走 handleBriefItem, 不再走 stream / defer 路径。
-                await startBriefTurn(a, frame, streamId, isSlash, text);
+                await startBriefTurn(a, frame, streamId, isSlash, text, channel ?? baseOfKey(principal), speaker);
             }
             else if (!armMigration && !eagerOpen) {
                 enterDeferred(a, frame, streamId);
@@ -5871,7 +6252,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: displayName(a.target) || a.target, cwdOverride: a.runningCwd, cli: backendForPath(a.jsonlPath).name, model: a.model || undefined, systemPrompt: charterFor(a.target, { cwd: a.runningCwd }) });
+                    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, knownModels: modelSightings(backendForPath(a.jsonlPath).name, [a.target]), effort: parseEffort(a.effort), systemPrompt: charterFor(a.target, { cwd: a.runningCwd }) });
                     if (r.ok && r.tmuxPane && r.tmuxSession) {
                         a.tmuxPane = r.tmuxPane;
                         a.tmuxSession = r.tmuxSession;
@@ -5885,6 +6266,7 @@ export const startMirror = (deps) => {
                             tmuxPane: a.tmuxPane,
                             cwd: a.runningCwd || undefined,
                             model: a.model || undefined,
+                            effort: a.effort || undefined,
                             pendingCwd: a.pendingCwd || undefined,
                         });
                         log.info({ target: a.target, sessionId: sid, newPane: a.tmuxPane, newSession: a.tmuxSession }, "mirror: tmux respawned");
@@ -5894,7 +6276,7 @@ export const startMirror = (deps) => {
                         // file appears, the watcher times out harmlessly, and the existing
                         // tail keeps working — safe under either behavior.
                         if (resumeBaseline)
-                            startMigrationWatcher(a, resumeBaseline, (p) => firstUserUuid(p) !== undefined);
+                            startMigrationWatcher(a, resumeBaseline, forkOf(a.jsonlPath));
                     }
                     else {
                         // Drop only the stale pane id; keep tmuxSession (if any) so the