wezard 2.2.2 → 2.3.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, transcriptStalled, summarizeTail, lastAssistantText, lastReply, replyToPeer as replyToPeerIn, unwrapPasted, lastContextTokens, lastModel, 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).
@@ -472,6 +475,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 +506,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;
@@ -544,12 +558,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 +572,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 +687,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 +701,7 @@ const renderLine = (raw, deps) => {
             out.push({
                 kind: "turn_usage",
                 model,
+                effort,
                 messageId,
                 usage: {
                     input,
@@ -849,6 +866,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);
         }
@@ -1413,6 +1433,8 @@ const injectViaTmux = async (target, text, images, log, freshSpawn, backend, jso
 // 框认得出来时这条判据可信, 于是允许多补回车 (空框上的回车在 CLI 里是 no-op);
 // 每次补之前再问一遍证人, 已提交就不补。
 const injectViaTmuxText = async (target, text, log, freshSpawn, witness = NO_WITNESS) => {
+    /** 具名粘贴 buffer 的序号 (见 loadAndPaste)。 */
+    let pasteSeq = 0;
     // 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
@@ -1452,10 +1474,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 };
@@ -1760,7 +1786,9 @@ export const startMirror = (deps) => {
     // 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);
-    const isKeepalivePing = (text) => isKeepalivePingText(text, pingSigs);
+    // 行上只认保温那一句: 报错之后的续跑 (resumePing) 开出的是那一轮的接续, 整轮吞掉的话
+    // 续出来的结论既不进群也没有频道。续跑若只回了 pong, 回复侧的那道保险照样吞。
+    const isKeepalivePing = (text) => isKeepalivePingText(text, warmerSigs);
     // ── Typewriter stream lifecycle ────────────────────────────────────
     // WeCom spec: server polls us for stream refreshes for up to 6 min from the
     // original inbound. SDK queues replyStream calls per req_id, sends serially
@@ -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,20 @@ 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;
         }
+        return undefined;
     };
     /** 本轮落 turn 记录的频道字段。 */
     const channelFields = (a) => ({ channel: a.channel ?? baseOfKey(a.target), speaker: a.speaker });
@@ -2395,14 +2451,93 @@ 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 first = seals.find(hit);
+        if (first)
+            a.seals = seals.filter((x) => !hit(x));
+        return first;
+    };
+    /** 人在聊天里说的那一句接成活跃 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 +2548,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 +2576,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 +2612,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 +2957,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 +3159,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 +3172,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 +3223,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 +3566,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 +3596,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 +3615,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 +3633,7 @@ export const startMirror = (deps) => {
             isOwnAssistantSend,
             isKeepalivePing,
             onItem: (item) => onItem(a, item),
+            onCompact: () => contextCut(a.target, "compact"),
             detailUrlFor,
             sessionId,
             target,
@@ -3461,6 +3655,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 +3693,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 +3808,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 +4009,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 +4040,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 +4068,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 +4271,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 +4416,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 +4438,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 +4495,32 @@ 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);
+        const effEffort = opts?.effort ?? parseEffort(prev?.effort ?? deps.store.get(target)?.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,
+            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,
@@ -4272,8 +4535,10 @@ export const startMirror = (deps) => {
             // 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() ?? ""),
+            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 +4572,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 +4587,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 +4604,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 +4645,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 +4653,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,8 +4664,10 @@ 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)
@@ -4398,7 +4687,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,9 +4705,12 @@ 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);
@@ -4428,10 +4722,16 @@ export const startMirror = (deps) => {
             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;
+            }
         }
         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 +4747,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 +4906,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 +4935,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) => {
@@ -4668,6 +4979,10 @@ export const startMirror = (deps) => {
             const tick = setInterval(() => void check(), IDLE_SAFETY_POLL_MS);
             const timer = setTimeout(() => finish({ idle: false, reason: "idle wait timed out" }), timeoutMs);
             void check();
+            if (aborted()) {
+                finish({ idle: false, reason: "stopped" });
+                return;
+            }
         });
     };
     const lastText = (target) => {
@@ -4678,9 +4993,9 @@ export const startMirror = (deps) => {
         const p = jsonlOf(target);
         return p ? lastReply(p, sinceMs, warmerSigs) : "";
     };
-    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, warmerSigs, turn) : undefined;
     };
     /** 绑着的 pane 还能用 (存在、且不是别人的窗口) —— 不重生、不猜。 */
     const paneLiveOf = async (target) => {
@@ -4841,7 +5156,7 @@ 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), stallFree: 0 };
     };
     const fireKeepalive = async (a, stalled) => {
         const kc = cfg.wrc.mirror.keepalive;
@@ -4861,13 +5176,15 @@ export const startMirror = (deps) => {
         // the turn somehow never emits turn_end, so a later real turn is never muted;
         // it also closes the detail turn so it can't hang open in the chat timeline.
         rememberInject(text);
-        a.keepaliveQuiet = setTimeout(() => {
-            a.keepaliveQuiet = undefined;
-            if (a.keepaliveTurnId) {
-                recordTurnClose(a.keepaliveTurnId);
-                a.keepaliveTurnId = undefined;
-            }
-        }, 60_000);
+        // 续跑不是保温 (见 isKeepalivePing): 不开吞没窗口, 也不记成保温轮。
+        if (!stalled)
+            a.keepaliveQuiet = setTimeout(() => {
+                a.keepaliveQuiet = undefined;
+                if (a.keepaliveTurnId) {
+                    recordTurnClose(a.keepaliveTurnId);
+                    a.keepaliveTurnId = undefined;
+                }
+            }, 60_000);
         const r = await inject({
             text, images: [], cfg,
             log: log.child({ target: a.target, sessionId: a.sessionId, sub: "keepalive" }),
@@ -4889,7 +5206,7 @@ export const startMirror = (deps) => {
         // closed on the ping's turn_end (or the fail-safe). Kept out of chat.
         // The tail's keepalive_start (content match on the user line) may have
         // opened this turn already — only open when it hasn't.
-        if (!a.keepaliveTurnId) {
+        if (!stalled && !a.keepaliveTurnId) {
             const turnId = newTurnId();
             a.keepaliveTurnId = turnId;
             recordTurnStart({ id: turnId, target: a.target, sessionId: a.sessionId, cli: cliOf(a), userQuery: text });
@@ -4902,8 +5219,9 @@ export const startMirror = (deps) => {
             return;
         keepaliveTicking = true;
         try {
-            const idleTriggerMs = Math.max(30, kc.ttlSec - kc.marginSec) * 1000;
-            const ttlMs = kc.ttlSec * 1000;
+            // Stall recovery keeps the configured window: a turn that died on an API
+            // error should be resumed minutes later, whatever the cache tier.
+            const stallQuietMs = Math.max(30, kc.ttlSec - kc.marginSec) * 1000;
             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()) {
@@ -4942,6 +5260,7 @@ 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.seenMtime = mtime;
                 // Round reset / real-activity re-anchor keys off REAL turns only — a
@@ -4980,8 +5299,13 @@ 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)
-                    continue; // cache still comfortably warm
+                // 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 (idleSinceTouch < stallQuietMs)
+                    continue; // nothing due yet on either clock
                 if (idleSinceTouch >= ttlMs)
                     continue; // cache already cold — a ping would cold-rewrite for nothing
                 if (k.round >= kc.rounds)
@@ -4990,8 +5314,15 @@ export const startMirror = (deps) => {
                 // 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);
+                // instruction instead of the plain warmer. A transcript found un-stalled a
+                // minute past the quiet window stays so until a new turn lands (= lastMs
+                // moves) — remembered, so a 1h idle stretch reads it once, not every tick.
+                const stalled = kc.resumeOnStall && k.stallFree !== k.lastMs
+                    && transcriptStalled(a.jsonlPath, keepalivePingSigs(kc.ping, kc.resumePing), stallQuietMs, now);
+                if (!stalled && idleSinceTouch >= stallQuietMs + 60_000)
+                    k.stallFree = k.lastMs;
+                if (!stalled && idleSinceTouch < idleTriggerMs)
+                    continue; // cache still comfortably warm
                 k.pinging = true;
                 k.pingMtime = k.lastMs; // settles when a newer turn (the ping's own) appears
                 await fireKeepalive(a, stalled);
@@ -5150,6 +5481,7 @@ export const startMirror = (deps) => {
         peekTurns,
         isBusy,
         idleNow,
+        parkedNow,
         untilIdle,
         setModel: async (target, wanted, scope) => {
             const a = byTarget.get(target);
@@ -5164,6 +5496,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,15 +5713,8 @@ 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;
             if (!paneAlive) {
@@ -5384,15 +5722,15 @@ export const startMirror = (deps) => {
                 // Same resume-fork hazard as dispatch: snapshot before spawn, re-bind
                 // onto the forked jsonl once it appears (EOF offset — fork is seeded).
                 const resumeBaseline = listJsonls(dirname(a.jsonlPath));
-                const r = await spawnTmuxClaude({ cfg, log: log.child({ sub: "respawn-init", sessionId: sid }), resumeSessionId: sid, windowName: 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));
             }
             // freshSpawn: true — the pane was just minted by /mirror/spawn, the TUI
             // is still warming up so the verifier in injectViaTmux needs the slack.
@@ -5507,6 +5845,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 +5972,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 +6052,7 @@ export const startMirror = (deps) => {
         sessionInfo,
         setCharterProvider,
         onSpawn,
+        onContextCut,
         shutdown: () => {
             clearInterval(paneDriftTimer);
             clearInterval(keepaliveTimer);
@@ -5742,7 +6109,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 +6205,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 +6240,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 +6254,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 +6264,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