wezard 2.6.4 → 2.7.0

package/dist/daemon/mirror-bridge.js

@@ -1,5 +1,5 @@
 import { finalId } from "./message-events.js";
-import { parseEnvelope } from "../shared/reminder.js";
+import { parseEnvelope, renderTail } from "../shared/reminder.js";
 import { codexSessions, codexSessionForPane } from "../shared/codex.js";
 import { codexHookLaunchArgs, codexHookCommand } from "../shared/codex-hooks.js";
 import { fileURLToPath } from "node:url";
@@ -21,7 +21,7 @@ import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { pasteTmuxBuffer } from "./tmux-buffer.js";
 import { existsSync, readdirSync, readFileSync, statSync, watch, openSync, readSync, closeSync } from "node:fs";
-import { join, dirname } from "node:path";
+import { basename, join, dirname } from "node:path";
 import { newStewardSpec, resumedStewardSpec } from "./steward-model.js";
 import { expandHome, sanitizeId } from "../shared/paths.js";
 import { augmentedPath } from "../shared/exec-path.js";
@@ -38,18 +38,17 @@ import { dispatchPickerPolicy, pickerPolicy } from "./picker-policy.js";
 import { renameWindow, runTmux, spawnTmuxClaude } from "./spawn-tmux.js";
 import { selectEffort, selectModel } from "./model-select.js";
 import { parseEffort } from "../shared/effort.js";
-import { hasRegistry, liveSessionPids, markTranscript, probeOf, sessionOnPane, submittedSince, watchRegistry } from "./cc-session.js";
+import { hasRegistry, liveSessionPids, markTranscript, probeOf, sessionOfPid, sessionOnPane, submittedSince, submittedEventSince, watchRegistry } from "./wezard-session.js";
 import { waitForIdle } from "./graph.js";
 import { wizardStore } from "./wizard.js";
 import { startSubagentWatch } from "./subagent-tail.js";
-import { getDetail, knowsToolUse, recordTool, recordToolResult, recordMark, recordTurnStart, recordTurnQuery, recordTurnInject, recordTurnItem, recordTurnUsage, recordTurnClose, recordCloseOpenTurns, lastChannelOf, openTurnsOf, buildDetailUrl, buildChatUrl, roleUniq } from "./detail.js";
+import { getDetail, knowsToolUse, recordTool, recordToolResult, recordMark, recordTurnStart, recordTurnQuery, recordTurnInject, recordTurnItem, recordTurnUsage, recordTurnClose, recordCloseOpenTurns, lastChannelOf, openTurnsOf, buildDetailUrl, buildChatUrl, roleUniq, markTurnTextFinal } from "./detail.js";
 import { errText } from "./last-response.js";
-import { labelFor, tagOfKey, baseOfKey, keyOf, stripSigil, displayName, withTagHeader, withLinkedTagHeader, chatHead, headed, tagBadge, parseTagHeader, MAX_BODY_LINKS, isInternalKey, sameBot } from "../shared/session-label.js";
+import { labelFor, tagOfKey, baseOfKey, keyOf, stripSigil, displayName, windowLabel, withTagHeader, withLinkedTagHeader, chatHead, headed, tagBadge, parseTagHeader, MAX_BODY_LINKS, isInternalKey, sameBot } from "../shared/session-label.js";
 import { splitMarkdown } from "../shared/md-chunk.js";
 import { isWxFrame } from "../shared/wx-text.js";
 import { chatBaseOf, chatNameOf, listChatNames, parsePeerRef, peerAddress } from "./chat-name.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";
+import { stripAnsi, paneIsBusy, codexTurnBusy, summarizeTail, lastAssistantText, lastReply, replyToPeer as replyToPeerIn, unwrapPasted, lastContextTokens, lastModel, lastUserTurn, talkRounds, openToolUses, turnClosed, renderDialog, stripForChat } from "./peers.js";
 // PATH augmentation: launchd / systemd start the daemon
 // with a stripped PATH that often lacks nvm / homebrew, breaking spawn(claudeBin).
 // Backend resolution is per-transcript, not global: `backendForPath` recovers
@@ -571,14 +570,9 @@ const renderLine = (raw, deps) => {
             const text = cleanUserText(c);
             if (!text)
                 return []; // pure slash-command meta / stdout — drop
-            // Keepalive ping user line: judged by CONTENT, before every other gate
-            // (includeUser / isOwnInject's 60s TTL) — the ping never echoes, and
-            // the reply turn is swallowed by content in onItem. Timer windows can't
-            // cover reloads or replays; the user message itself always can.
-            if (deps.isKeepalivePing?.(text))
-                return [{ kind: "keepalive_start", body: text }];
             // 自己注入的那一行不回显, 但要报个到: 它的印章 (谁说的、回复去哪) 在这一刻认领。
-            const eventId = c.includes('wezard="message-event"') ? parseEnvelope(c)?.eventId : undefined;
+            // 注入事件 id: 信封的 `msg` (老形状是信封外的 message-event 块) —— 认得出就是守护进程投的。
+            const eventId = parseEnvelope(c)?.eventId;
             if (eventId || deps.isOwnInject(text))
                 return [{ kind: "user_query", eventId, body: unwrapPasted(c).trim(), said: text, ts: lineTs(line) }];
             const quoted = text.split("\n").map((l) => `> ${l}`).join("\n");
@@ -1339,6 +1333,22 @@ export const parseInputBox = (cap, styledLayout = cap) => {
     const body = [rows[0].replace(BOX_PROMPT_RE, ""), ...rows.slice(1)].join("\n").replace(/[\s\u200b\ufeff]+/gu, " ").trim();
     return { known: true, body };
 };
+// CodeBuddy 忙时回车不落盘: 那句挂进输入框上方的待发队列, 一条一行
+//   Messages to be submitted after next tool call (…)
+//    ↳ <整段压成一行, 过长以 … 截断>
+// 直到出队才写进 transcript —— 这期间「框清空了、transcript 里没有」是正常的排队态, 不是丢了。
+const QUEUED_ROW_RE = /^\s*↳\s?(.+)$/u;
+const QUEUED_HEAD_CHARS = 24;
+/** 队列里有几行是这段文本 (按去空白后的开头比对; 截断的行只比它露出的那截)。 */
+export const queuedCopies = (cap, text) => {
+    const head = text.replace(/\s+/gu, "").slice(0, QUEUED_HEAD_CHARS);
+    if (!head)
+        return 0;
+    return cap.split("\n")
+        .map((l) => QUEUED_ROW_RE.exec(l)?.[1]?.replace(/\s+/gu, "").replace(/…$/u, "") ?? "")
+        .filter((row) => row.length >= Math.min(8, head.length) && (row.startsWith(head) || head.startsWith(row)))
+        .length;
+};
 // 空框里的灰字不是输入: 幽灵提示 (`Try "…"`) 和 CC 预测的下一句 (prompt suggestion,
 // 回车不采纳) 都以 SGR 2 (dim) 渲染。纯文本 capture 看不出区别 —— 预测句
 // `commit 这次改动…` 曾让一条 `commit` 被判成「已在框里」, 于是没贴, 只按了三下
@@ -1375,7 +1385,7 @@ const readPaneInput = async (target) => {
     return { cap, box: parseInputBox(cap, raw) };
 };
 const readInputBox = async (target) => (await readPaneInput(target)).box;
-// ── 注入门控的会话证人 (cc-session) ─────────────────────────────────
+// ── 注入门控的会话证人 (wezard-session) ──────────────────────────────
 // 能从会话自己写的 json 读到的判据, 就不读 pane: 就绪看注册表的 status, 提交看
 // 注册表的 busy 翻转或 jsonl 里新落的那一行。输入框里「贴进去没有」是唯一只有
 // pane 知道的事 (未提交的输入不落任何盘), 那一段仍旧 capture。
@@ -1385,9 +1395,89 @@ const paneRunsShell = async (target) => {
     const r = await runTmux(["display-message", "-p", "-t", target, "#{pane_current_command}"]);
     return r.ok && SHELL_RE.test(r.stdout.trim());
 };
-/** pane 活着且里面住着 AI 会话。注册表认得它就是; 不认得时只在前台确是 shell 才判否 ——
- *  注册表缺席 (codebuddy / 旧版 CC / 进程不在 tmux 里记的行) 不能被当成会话不在。 */
-const paneHostsSession = async (target, homeDir) => !hasRegistry(homeDir) || sessionOnPane(homeDir, target) !== undefined || !(await paneRunsShell(target));
+const paneLiveness = async (paneId) => {
+    if (!paneId)
+        return "gone";
+    const r = await runTmux(["display-message", "-p", "-t", paneId, "#{pane_id}"]);
+    if (r.timedOut || r.code === null)
+        return "unknown";
+    if (r.code === 0)
+        return r.stdout.trim() === paneId ? "alive" : "unknown";
+    return "gone"; // "can't find pane: %N" / "no server running" —— 两条都等于它没了
+};
+/** 沿 ps 快照从某个 pid 往下找「会话注册表登记过、进程还活着」的那个 pid。注册表没有
+ *  `tmux` 字段的后端 (codebuddy) 只能这样把 pane 和进程对上: pane_pid 是 shell, CLI 是
+ *  它的子孙。认不出返回 undefined。 */
+const registeredPidUnder = (root, livePids, kids) => {
+    const stack = [root];
+    const seen = new Set();
+    while (stack.length) {
+        const p = stack.pop() ?? 0;
+        if (!p || seen.has(p))
+            continue;
+        if (livePids.has(p))
+            return p;
+        seen.add(p);
+        for (const k of kids.get(p) ?? [])
+            stack.push(k);
+    }
+    return undefined;
+};
+const panePidOf = async (paneId) => {
+    const r = await runTmux(["display-message", "-p", "-t", paneId, "#{pane_pid}"]);
+    return r.ok ? Number(r.stdout.trim()) || 0 : 0;
+};
+/** pane 里有没有活着的 CLI 会话进程。注册表带 `tmux` 字段的后端按 pane 直接认; codebuddy
+ *  不写那个字段, 只能沿 pane 的进程树找到注册表登记过的 pid。
+ *  **它只证明「里面有活的 CLI」, 不证明「里面是哪份转录」** —— codebuddy 的注册行里
+ *  sessionId 是续接链的根, 会话换过 sid 之后不更新 (2026-10-14 实测: pid 84679 报
+ *  3d51b76b, 而那个进程实际在写 01a13ae5)。要认会话得另找权威来源, 别拿这个 sid 用。 */
+const paneHasLiveSession = async (paneId, homeDir, panePid, ps) => {
+    if (sessionOnPane(homeDir, paneId))
+        return true;
+    const root = panePid ?? (await panePidOf(paneId));
+    if (!root)
+        return false;
+    const { kids } = ps ?? (await psSnap());
+    return registeredPidUnder(root, liveSessionPids(homeDir), kids) !== undefined;
+};
+/** 注入前问 pane 一句话: 还在吗 / 里面还有 AI 会话吗。
+ *  `unknown` 必须由调用方按「不知道」处理 —— 不许当 pane 死了去重生。 */
+const probePane = async (paneId, jsonlPath) => {
+    const live = await paneLiveness(paneId);
+    if (live !== "alive")
+        return { state: live };
+    if (await paneHasLiveSession(paneId, backendForPath(jsonlPath).homeDir))
+        return { state: "session" };
+    // 认不出会话进程 (注册表缺席 / 进程不在 tmux 里记的行) 不能被当成会话不在: 只有前台确实
+    // 退回 shell 才判否。而这一次探问自己也可能是超时 —— 那仍旧只能算 unknown。
+    const cmd = await runTmux(["display-message", "-p", "-t", paneId, "#{pane_current_command}"]);
+    if (cmd.timedOut || !cmd.ok)
+        return { state: "unknown" };
+    return SHELL_RE.test(cmd.stdout.trim()) ? { state: "shell" } : { state: "session" };
+};
+/** 注册表没有 tmux 字段的后端 (codebuddy): pane 里住着谁只能沿 pane 的进程树往下找
+ *  注册表登记过、还活着的 pid。冷 pane 的注册行晚于进程出生, `waitMs` 内轮询。 */
+const hostPidOnPane = async (target, homeDir, waitMs) => {
+    const deadline = Date.now() + waitMs;
+    const probe = async () => {
+        const r = await runTmux(["display-message", "-p", "-t", target, "#{pane_pid}"]);
+        const root = r.ok ? Number(r.stdout.trim()) : 0;
+        if (!root)
+            return undefined;
+        const reg = liveSessionPids(homeDir);
+        const { kids } = await psSnap();
+        return registeredPidUnder(root, reg, kids);
+    };
+    const poll = async () => {
+        const pid = await probe();
+        if (pid || Date.now() >= deadline)
+            return pid;
+        await sleep(300);
+        return poll();
+    };
+    return poll();
+};
 const SESSION_READY_TIMEOUT_MS = 15_000;
 /** 冷 pane 等注册表报 idle (会话建好、输入框等人); 热 pane 只核一次会话还在 —— 忙也照贴,
  *  CC 会把它排进队列。等不到 idle 不算失败 (贴后校验会兜), 前台退回 shell 才算:
@@ -1415,32 +1505,32 @@ const awaitSession = async (target, homeDir, fresh, log) => {
     }
     return { ok: true };
 };
-const NO_WITNESS = { status: "", submitted: () => false };
+const NO_WITNESS = { status: "", submitted: () => false, submittedEvent: () => false };
 /** 贴之前给会话可能落盘的 jsonl 打书签: 绑定的那份, 加上注册表报的当前 sid 那份
  *  (resume / fork 会换 sid)。提交后 sid 若又变了, 新文件从 0 读 —— 时间门挡掉 fork 里的旧话。 */
-const witnessFor = (target, homeDir, jsonlPath, live) => {
-    if (!live)
-        return NO_WITNESS;
+const witnessFor = (target, homeDir, jsonlPath, live, actualTranscript) => {
     const dir = dirname(jsonlPath);
-    const marks = new Map([jsonlPath, join(dir, `${live.sessionId}.jsonl`)].map((p) => [p, markTranscript(p)]));
+    const marks = new Map([...new Set([jsonlPath, actualTranscript, ...(live ? [join(dir, `${live.sessionId}.jsonl`)] : [])].filter((p) => !!p))]
+        .map((p) => [p, markTranscript(p)]));
     return {
-        status: live.status,
+        status: live?.status ?? "",
         submitted: (probe, since, enterAt) => {
             const now = sessionOnPane(homeDir, target);
-            if (now && live.status !== "busy" && now.status === "busy" && now.statusUpdatedAt >= enterAt)
+            if (live && now && live.status !== "busy" && now.status === "busy" && now.statusUpdatedAt >= enterAt)
                 return true;
             const p = now && join(dir, `${now.sessionId}.jsonl`);
             if (p && !marks.has(p))
                 marks.set(p, { path: p, offset: 0 });
             return submittedSince([...marks.values()], probe, since);
         },
+        submittedEvent: (eventId, since) => submittedEventSince([...marks.values()], eventId, since),
     };
 };
 // Self-verifying inject. The cold-spawn race we guard against: paste lands
 // but the trailing Enter is eaten while the TUI is still initializing, so
 // the prompt sits typed-but-unsent. 校验策略见 injectViaTmuxText —— 以输入框
 // 整块为判据, 粘贴只在「确凿看见框仍是空的」时才重来。
-const injectViaTmux = async (target, text, images, log, freshSpawn, backend, jsonlPath, bypassModalGuard = false, guard) => {
+const injectViaTmux = async (target, text, images, log, freshSpawn, backend, jsonlPath, bypassModalGuard = false, guard, eventId, expectedSessionId) => {
     const backendName = backend.name;
     log.info({ target, len: text.length, images: images.length, freshSpawn, backendName }, "mirror inject (tmux)");
     // 就绪门: pane 里得真有一个进入了交互态的 AI 会话, 才轮得到贴。先于 modal guard ——
@@ -1448,7 +1538,74 @@ const injectViaTmux = async (target, text, images, log, freshSpawn, backend, jso
     const gate = await awaitSession(target, backend.homeDir, freshSpawn, log);
     if (!gate.ok)
         return gate;
-    const witness = witnessFor(target, backend.homeDir, jsonlPath, gate.live);
+    const tmuxRegistry = hasRegistry(backend.homeDir);
+    const eventNeedsIdentity = !!eventId && !text.trimStart().startsWith("/");
+    // codebuddy 的注册行有 pid/sessionId 却没有 tmux, 而且 sessionId 在会话内换 sid
+    // (handoff / 续接) 后不更新 —— 只能证明「pane 里住着一个活的 CLI 进程」, 收件的
+    // 会话以 mirror 自己绑定的那份为准 (expectedSessionId / jsonlPath)。
+    const hostPid = !tmuxRegistry && backendName !== "codex" && eventNeedsIdentity
+        ? await hostPidOnPane(target, backend.homeDir, freshSpawn ? SESSION_READY_TIMEOUT_MS : 0)
+        : undefined;
+    const paneIdentity = () => {
+        // A readable live-session registry is the physical pane authority. Codex's
+        // SessionStart map is the fallback on installations without that registry.
+        if (tmuxRegistry) {
+            const session = sessionOnPane(backend.homeDir, target);
+            return session ? { sessionId: session.sessionId, transcript: join(dirname(jsonlPath), `${session.sessionId}.jsonl`) } : undefined;
+        }
+        if (backendName === "codex") {
+            const session = codexSessionForPane(target);
+            return session ? { sessionId: session.sessionId, transcript: session.jsonlPath } : undefined;
+        }
+        if (hostPid && sessionOfPid(backend.homeDir, hostPid)) {
+            const sessionId = expectedSessionId || basename(jsonlPath, ".jsonl");
+            return { sessionId, transcript: jsonlPath };
+        }
+        return undefined;
+    };
+    const observedIdentity = paneIdentity();
+    if (eventNeedsIdentity && (!observedIdentity?.sessionId || !observedIdentity.transcript)) {
+        const reason = backendName === "codebuddy"
+            ? "CodeBuddy pane hosts no live registered CLI process; refusing event injection before input exposure"
+            : backendName === "codex"
+                ? "Codex SessionStart pane identity is unavailable; refusing event injection before input exposure"
+                : "Claude pane session identity is unavailable; refusing event injection before input exposure because the receiving session/transcript cannot be verified";
+        return { ok: false, retryable: true, reason };
+    }
+    const initialIdentity = observedIdentity ?? (gate.live
+        ? { sessionId: gate.live.sessionId, transcript: join(dirname(jsonlPath), `${gate.live.sessionId}.jsonl`) }
+        : { transcript: jsonlPath });
+    const witness = witnessFor(target, backend.homeDir, jsonlPath, gate.live, initialIdentity.transcript);
+    let guardFailureReason = "dispatch guard rejected input";
+    let inputGuardRejected = false;
+    const boundGuard = (phase) => {
+        // Resolve again at each physical paste/submit boundary. The mapping can
+        // change after awaitSession or while an image is being staged.
+        const current = paneIdentity();
+        if (eventNeedsIdentity && (!current?.sessionId || !current.transcript)) {
+            guardFailureReason = "receiving pane session identity became unavailable before input";
+            inputGuardRejected = true;
+            return false;
+        }
+        if (!current)
+            return !eventNeedsIdentity && (!guard || guard(phase, { transcript: jsonlPath }));
+        if (current.sessionId !== initialIdentity.sessionId || current.transcript !== initialIdentity.transcript) {
+            guardFailureReason = "receiving pane session changed before input; refusing to attach event to a different session";
+            inputGuardRejected = true;
+            return false;
+        }
+        if (expectedSessionId && current.sessionId && current.sessionId !== expectedSessionId) {
+            guardFailureReason = "receiving pane session no longer matches the queued event target";
+            inputGuardRejected = true;
+            return false;
+        }
+        const allowed = !guard || guard(phase, current);
+        if (!allowed) {
+            guardFailureReason = "dispatch guard withdrew permission before input";
+            inputGuardRejected = true;
+        }
+        return allowed;
+    };
     // Never type into a modal picker (see detectModalPicker). Checked before the
     // image pump too — a C-v into a picker is just as destructive as a paste.
     // 必须在按后端分流之前: 每个后端都有自己的原生确认框, 往任何一个里打字都会
@@ -1481,27 +1638,31 @@ const injectViaTmux = async (target, text, images, log, freshSpawn, backend, jso
     // dispatch 已对 codebuddy 把 refs 合进 text (images 传空), 这里的
     // withImageRefs 是其它调用方直传 images 时的兜底 —— 幂等, 不会贴两份。
     if (backendName === "codebuddy") {
-        return injectViaTmuxText(target, withImageRefs(text, images), log, freshSpawn, witness, guard);
+        return injectViaTmuxText(target, withImageRefs(text, images), log, freshSpawn, witness, boundGuard, eventId);
     }
     // Pump images first via clipboard+C-v so each one is attached as a separate
     // image content block. Each C-v needs a brief settle for Claude Code's TUI
     // to read the clipboard before the next overwrite. Fresh spawn extends.
     const IMG_SETTLE_MS = freshSpawn ? 700 : 350;
+    let imagePasteMayHaveExposed = false;
     const pumped = images.length ? await withImageClipboard(async () => {
         for (const imgPath of images) {
             const paste = async () => {
                 const cb = await setMacClipboardImage(imgPath);
                 if (!cb.ok)
                     return cb;
-                if (guard && !guard("paste"))
-                    return { ok: false, reason: "image paste canceled by dispatch guard" };
+                if (!boundGuard("paste"))
+                    return { ok: false, reason: guardFailureReason };
+                // Once send-keys starts, a failed client result cannot prove C-v was
+                // not delivered; preserve uncertainty to prevent duplicate attachments.
+                imagePasteMayHaveExposed = true;
                 const cv = await runTmux(["send-keys", "-t", target, "C-v"]);
                 return cv.ok ? { ok: true } : { ok: false, reason: `tmux send-keys C-v failed: ${cv.stderr.slice(-200)}` };
             };
             // Cold Codex can ignore C-v before its composer exists. Do not submit
             // the text until the composer proves this attachment has landed.
             const result = backendName === "codex"
-                ? await pasteVerifiedImage({ read: () => readInputBox(target), paste, valid: () => !guard || guard("paste") })
+                ? await pasteVerifiedImage({ read: () => readInputBox(target), paste, valid: () => boundGuard("paste") })
                 : await paste();
             if (!result.ok) {
                 log.warn({ target, imgPath, reason: result.reason }, "mirror inject: image not confirmed, refusing text submission");
@@ -1515,19 +1676,21 @@ const injectViaTmux = async (target, text, images, log, freshSpawn, backend, jso
         return { ok: true };
     }) : { ok: true };
     if (!pumped.ok)
-        return { ...pumped, uncertain: true };
+        return imagePasteMayHaveExposed
+            ? { ...pumped, ...(inputGuardRejected ? { reason: guardFailureReason } : {}), uncertain: true, retryable: false }
+            : { ...pumped, ...(inputGuardRejected ? { reason: guardFailureReason } : {}), uncertain: false, retryable: true };
     // Image-only message: TUI input box now holds the attached images; press
     // Enter and we're done. No fingerprint to verify (the input itself is binary
     // image refs, not text).
     if (!text) {
         if (images.length === 0)
             return { ok: true };
-        if (guard && !guard("submit"))
+        if (!boundGuard("submit"))
             return { ok: false, reason: "submit canceled by dispatch guard" };
         const e = await runTmux(["send-keys", "-t", target, "Enter"]);
         return e.ok ? { ok: true } : { ok: false, reason: `tmux send-keys Enter failed: ${e.stderr.slice(-200)}` };
     }
-    return injectViaTmuxText(target, text, log, freshSpawn, witness, guard);
+    return injectViaTmuxText(target, text, log, freshSpawn, witness, boundGuard, eventId);
 };
 // 图片以 @<path> 文本提及的形式进会话 (codebuddy 的 tmux 路径、一切 spawn 路径)。
 // 提升为共享 helper: dispatch 侧的印章 / 回显去重 / turn 记录必须拿到与 inject
@@ -1549,7 +1712,7 @@ const withImageRefs = (text, images) => {
 // 证人不作声 (忙时排队、slash 命令、无注册表的后端) 才看框回没回到贴之前的样子。
 // 框认得出来时这条判据可信, 于是允许多补回车 (空框上的回车在 CLI 里是 no-op);
 // 每次补之前再问一遍证人, 已提交就不补。
-const injectViaTmuxText = async (target, text, log, freshSpawn, witness = NO_WITNESS, guard) => {
+const injectViaTmuxText = async (target, text, log, freshSpawn, witness = NO_WITNESS, guard, eventId) => {
     // 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
@@ -1566,6 +1729,10 @@ const injectViaTmuxText = async (target, text, log, freshSpawn, witness = NO_WIT
     // (会话正忙 → 只是排队; slash 命令 → 不一定落 user 行) 不空等, 直接看框。
     const witnessQuiet = witness.status === "" || witness.status === "busy" || text.trimStart().startsWith("/");
     const WITNESS_ONLY_MS = witnessQuiet ? 0 : freshSpawn ? 2500 : 1000;
+    const requireEventEvidence = !!eventId && !text.trimStart().startsWith("/");
+    // 粘贴迟到的追加观察窗: 只走在「本来就要判 uncertain」的那条路上, 正常注入不付这笔。
+    const LATE_LAND_MS = 15_000;
+    const LATE_POLL_MS = 250;
     const { headFp, tailFp } = fingerprints(text);
     const probe = probeOf(text);
     const POLL_MS = 100;
@@ -1573,10 +1740,14 @@ const injectViaTmuxText = async (target, text, log, freshSpawn, witness = NO_WIT
     // 时间门往前放 1s: jsonl 的 timestamp 与本机时钟同源, 只差写盘的毫秒。
     const since = Date.now() - 1000;
     let enterAt = Number.POSITIVE_INFINITY;
-    const submitted = () => witness.submitted(probe, since, enterAt);
+    const submitted = () => requireEventEvidence
+        ? witness.submittedEvent(eventId, since) : witness.submitted(probe, since, enterAt);
     // 贴之前框里是什么: 空框、幽灵提示 (`Try "how do I log an error?"`)、甚至用户
     // 自己敲了一半的字 —— 一律作为基线, 免得去维护一张「哪些文案算空」的清单。
-    const preBox = await readInputBox(target);
+    const pre = await readPaneInput(target);
+    const preBox = pre.box;
+    // 贴之前队列里已有几份同样开头的 (同一段文本上次排进去了 / 兄弟回执同开头): 只认新增的。
+    const preQueued = queuedCopies(pre.cap, text);
     // 基线读不出来 (框被模态顶掉 / 正在重绘) 就整条退回指纹法: 没有基线,「框变了」
     // 无从谈起, 而把幽灵提示 (`Try "…"`) 误当成「贴进去了」会让这条消息静静消失。
     const boxVerify = preBox.known;
@@ -1601,6 +1772,21 @@ const injectViaTmuxText = async (target, text, log, freshSpawn, witness = NO_WIT
         }
         return false;
     };
+    /** 粘贴过了 PASTE_VERIFY_MS 还没露面, 再盯一阵, 直到四者之一: 会话已收下 / 框变了 (迟到落地) /
+     *  到点时框认得出且原样 (确实没进框) / 到点时框仍认不出 (无从判断)。 */
+    const lateLanding = async (timeoutMs, t0 = Date.now()) => {
+        if (submitted())
+            return "submitted";
+        const { cap, box } = await readPaneInput(target);
+        if (box.known ? (boxVerify ? !boxIntact(box) : box.body !== "") : Boolean(headFp) && stripWs(cap).includes(headFp))
+            return "landed";
+        if (Date.now() - t0 >= timeoutMs)
+            return box.known ? "intact" : "unknown";
+        await sleep(LATE_POLL_MS);
+        return lateLanding(timeoutMs, t0);
+    };
+    /** 回车后它进了 CodeBuddy 的待发队列 (见 queuedCopies) —— 提交已确凿, 只是还没落盘。 */
+    const queued = async () => queuedCopies((await readPaneInput(target)).cap, text) > preQueued;
     // 窄窗口 = 只有输入框本身。tailFp 紧挨光标, 提交前必在窗内、提交后消失。
     // 仅用于 parseInputBox 认不出布局的后端。
     const inputBoxStillHasTail = async () => {
@@ -1625,7 +1811,22 @@ const injectViaTmuxText = async (target, text, log, freshSpawn, witness = NO_WIT
         // and then sleeping another 2.5s before the first Enter.
         pasteSeen = await sawLanded(boxVerify ? PASTE_VERIFY_MS : POST_PASTE_SETTLE_FALLBACK_MS);
     }
-    if (!pasteSeen) {
+    if (!pasteSeen && requireEventEvidence) {
+        // 事件注入不重贴, 但也绝不能把一份可能已进框的粘贴撂下不交: CodeBuddy 在轮次交接 (提交 /
+        // 收尾的 hook、摘要) 时会把粘贴的渲染拖过 PASTE_VERIFY_MS, 撂下的那份等 TUI 缓过来才冒出,
+        // 被下一次注入接在后面一起回车 —— 两件事并成一行提交 (2026-10-14 两起: 人话 + 回执)。
+        // 所以先多等它一阵; 认不出框 ≠ 框是空的, 那种情况照样回车, 交给证人判。
+        const late = await lateLanding(LATE_LAND_MS);
+        if (late === "submitted")
+            return { ok: true };
+        if (late === "intact") {
+            log.warn({ target, headFp, waitedMs: Date.now() - pastedAt }, "mirror inject: 粘贴始终没进框, 事件不重贴");
+            return { ok: false, uncertain: true, reason: "composer is empty but this event is absent from the transcript; delivery remains uncertain and will not be pasted again" };
+        }
+        pasteSeen = late === "landed";
+        log.warn({ target, headFp, late, waitedMs: Date.now() - pastedAt }, "mirror inject: 粘贴迟到, 按迟到结果继续提交");
+    }
+    else if (!pasteSeen) {
         const box = await readInputBox(target);
         const empty = boxVerify && box.known ? boxIntact(box) : !(await inputBoxStillHasTail());
         if (submitted()) {
@@ -1694,13 +1895,19 @@ const injectViaTmuxText = async (target, text, log, freshSpawn, witness = NO_WIT
             await sleep(POLL_MS);
             if (submitted())
                 return true;
-            if (Date.now() - t0 >= WITNESS_ONLY_MS && (await cleared()))
+            if (Date.now() - t0 < WITNESS_ONLY_MS)
+                continue;
+            if (await queued())
+                return true;
+            // An unchanged empty composer proves submission only after we actually
+            // saw this paste land. Otherwise a swallowed paste produces a false ACK.
+            if (!requireEventEvidence && pasteSeen && (await cleared()))
                 return true;
         }
         return false;
     };
     if (!pasteSeen)
-        log.warn({ target }, "mirror inject: submitted without paste verification (capture-pane lag)");
+        log.warn({ target }, "mirror inject: paste unverified, requiring session submission evidence");
     if (!tailFp) {
         // empty/whitespace text — nothing to verify, fire once and go.
         const e = await sendEnter();
@@ -1709,7 +1916,7 @@ const injectViaTmuxText = async (target, text, log, freshSpawn, witness = NO_WIT
     // 回车可能被冷启动中的 TUI 吞掉 (框里躺着没提交的提示)。框认得出来时判据可信,
     // 多补一次; 认不出来时维持原来的「只补一次」, 免得判据出错往真实对话里灌回车。
     const boxTrusted = boxVerify && (await readInputBox(target)).known;
-    const attempts = boxTrusted ? 3 : 2;
+    const attempts = requireEventEvidence ? 1 : boxTrusted ? 3 : 2;
     for (let i = 0; i < attempts; i++) {
         if (i > 0) {
             await sleep(RETRY_SETTLE_MS);
@@ -1726,9 +1933,13 @@ const injectViaTmuxText = async (target, text, log, freshSpawn, witness = NO_WIT
             return e;
         if (await waitForSubmit(CLEARED_TIMEOUT_MS))
             return { ok: true };
+        if (requireEventEvidence && await cleared())
+            return await queued() ? { ok: true } : { ok: false, uncertain: true, reason: "composer cleared without this event's transcript marker; delivery remains uncertain and will not be resubmitted" };
     }
-    if (submitted())
+    if (submitted() || await queued())
         return { ok: true };
+    if (requireEventEvidence && await cleared())
+        return { ok: false, uncertain: true, reason: "composer cleared without this event's transcript marker; delivery remains uncertain and will not be resubmitted" };
     // 补到头还没清空。通常是渲染滞后 (回车其实落了), 但也可能是目标会话正忙 /
     // 上下文满了不消费输入 —— 那样用户这条消息会悄无声息地消失。不报硬失败 (用户
     // 多半已经被服务到了), 标 uncertain 让调用方按需提示。
@@ -1768,6 +1979,8 @@ const injectViaSpawn = async (args) => {
     // which Claude parses at submit time and inlines as image content blocks
     // without a model-decided Read tool turn.
     const finalText = withImageRefs(text, images);
+    const eventMark = args.eventId && !text.trimStart().startsWith("/") ? markTranscript(jsonlPath) : undefined;
+    const eventSince = Date.now() - 1000;
     const cliArgs = backend.name === "codex" ? ["exec", "resume", "--json", ...codexArgs,
         ...cfg.wrc.extraArgs.filter((arg) => !arg.startsWith("--disallowedTools")),
         ...images.flatMap((path) => ["--image", path]), sessionId, text] : [
@@ -1781,7 +1994,7 @@ const injectViaSpawn = async (args) => {
         ...cfg.wrc.extraArgs,
     ];
     log.info({ sessionId, bin, len: text.length }, "mirror inject");
-    if (args.guard && !args.guard("submit"))
+    if (args.guard && !args.guard("submit", { sessionId, transcript: jsonlPath }))
         return { ok: false, reason: "spawn canceled by dispatch guard" };
     return new Promise((resolve) => {
         const proc = spawn(bin, cliArgs, {
@@ -1808,6 +2021,10 @@ const injectViaSpawn = async (args) => {
                 resolve({ ok: false, reason: `${bin} exited ${code}: ${stderrTail.slice(-300)}` });
                 return;
             }
+            if (eventMark && args.eventId && !submittedEventSince([eventMark], args.eventId, eventSince)) {
+                resolve({ ok: false, uncertain: true, reason: "CLI exited successfully but this event's transcript marker is absent; delivery remains uncertain" });
+                return;
+            }
             resolve({ ok: true });
         });
     });
@@ -1822,8 +2039,8 @@ const inject = async (args) => {
                 return { ok: false, retryable: true, reason: "spawn permission withdrawn" };
             const text = args.prepareText?.() ?? args.text;
             let activated = false;
-            const result = await injectViaSpawn({ ...args, text, guard: (phase) => {
-                    if (args.guard && !args.guard(phase))
+            const result = await injectViaSpawn({ ...args, text, guard: (phase, identity) => {
+                    if (args.guard && !args.guard(phase, identity))
                         return false;
                     if (phase && !activated) {
                         activated = true;
@@ -1849,8 +2066,8 @@ const inject = async (args) => {
             if (!idleApproved)
                 return { ok: false, reason: "target has no confirmed idle evidence" };
             const text = args.prepareText?.() ?? args.text;
-            const guard = (phase) => {
-                if (!live() || (!exposed && !idleApproved) || (args.guard && !args.guard(phase)))
+            const guard = (phase, identity) => {
+                if (!live() || (!exposed && !idleApproved) || (args.guard && !args.guard(phase, identity)))
                     return false;
                 if (phase && !exposed) {
                     exposed = true;
@@ -1858,7 +2075,7 @@ const inject = async (args) => {
                 }
                 return true;
             };
-            return injectViaTmux(target, text, args.images ?? [], args.log, args.freshSpawn ?? false, backendForPath(args.jsonlPath), args.jsonlPath, args.bypassModalGuard ?? false, guard);
+            return injectViaTmux(target, text, args.images ?? [], args.log, args.freshSpawn ?? false, backendForPath(args.jsonlPath), args.jsonlPath, args.bypassModalGuard ?? false, guard, args.eventId, args.sessionId);
         }, { guard: args.guard }));
     }
     catch (error) {
@@ -1877,15 +2094,24 @@ const INJECT_JOB_TIMEOUT_MS = 90_000;
 /** 没有绑定的 pane 静默多久才算孤儿。刚 spawn、还没 attach 的 pane (并发 fan-out 时
  *  别人的 sweep 会撞见它) 在这段时间里一直有输出, 远大于一次 spawn → attach 的耗时。 */
 const ORPHAN_GRACE_MS = 10 * 60_000;
+/** ps 的 `etime` ([[dd-]hh:]mm:ss) → 秒; 认不出 = NaN。 */
+const etimeSec = (s) => {
+    const m = /^(?:(\d+)-)?(?:(\d+):)?(\d+):(\d+)$/.exec(s);
+    if (!m)
+        return Number.NaN;
+    const [d = 0, h = 0, mi = 0, se = 0] = m.slice(1).map((x) => Number(x ?? 0));
+    return ((d * 24 + h) * 60 + mi) * 60 + se;
+};
 const psSnap = () => new Promise((resolve) => {
-    const p = spawn("ps", ["-axo", "pid=,ppid=,etimes="], { env: { ...process.env, PATH: augmentedPath(process.env.PATH) }, stdio: ["ignore", "pipe", "ignore"] });
+    const p = spawn("ps", ["-axo", "pid=,ppid=,etime="], { env: { ...process.env, PATH: augmentedPath(process.env.PATH) }, stdio: ["ignore", "pipe", "ignore"] });
     let out = "";
     p.stdout?.on("data", (c) => (out += c.toString("utf8")));
     const done = () => {
         const kids = new Map();
         const etimes = new Map();
         for (const line of out.split("\n")) {
-            const [pid, ppid, et] = line.trim().split(/\s+/).map(Number);
+            const [pidS = "", ppidS = "", etS = ""] = line.trim().split(/\s+/);
+            const pid = Number(pidS), ppid = Number(ppidS), et = etimeSec(etS);
             if (!pid || !ppid)
                 continue;
             const arr = kids.get(ppid);
@@ -1893,7 +2119,7 @@ const psSnap = () => new Promise((resolve) => {
                 arr.push(pid);
             else
                 kids.set(ppid, [pid]);
-            if (et !== undefined && !Number.isNaN(et))
+            if (!Number.isNaN(et))
                 etimes.set(pid, et);
         }
         resolve({ kids, etimes });
@@ -1996,14 +2222,6 @@ export const startMirror = (deps) => {
         recentAssistantSends.splice(i, 1); // one-shot: a genuine later re-say still streams
         return true;
     };
-    // Keepalive ping detector for the tail's user-line judgment — the SAME
-    // 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
     // original inbound. SDK queues replyStream calls per req_id, sends serially
@@ -2181,8 +2399,6 @@ export const startMirror = (deps) => {
     const sendStandalone = (a, content) => {
         if (!hasVisibleBody(content))
             return;
-        if (answerSilent(a))
-            return;
         if (isPrivate(a) && !/^\[(mirror|wezard)\]/.test(content.trim()))
             return;
         const chatId = replyChatId(a);
@@ -2191,11 +2407,7 @@ export const startMirror = (deps) => {
         const chunks = pieces.map((p, i) => withLinkedTag(a, p, pieces.length > 1 ? `${i + 1}/${pieces.length}` : undefined));
         a.standalonePending = a.standalonePending
             .then(async () => {
-            if (silenceAnswer(a.target, turnId ?? ""))
-                return;
             for (const c of chunks) {
-                if (silenceAnswer(a.target, turnId ?? ""))
-                    return;
                 try {
                     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");
@@ -2215,8 +2427,6 @@ export const startMirror = (deps) => {
         const turnId = a.briefTurnId ?? a.liveStream?.turnId;
         a.standalonePending = a.standalonePending
             .then(async () => {
-            if (silenceAnswer(a.target, turnId ?? ""))
-                return;
             try {
                 await client.sendMessage(chatId, { msgtype: "markdown", markdown: { content } });
                 log.info({ sessionId: a.sessionId, turnId, chatId, len: content.length }, "raw pushed");
@@ -2488,9 +2698,9 @@ export const startMirror = (deps) => {
     //   • 节流 —— 气泡刷新是整条内容重发, 高频 thinking 不能 1:1 打到 stream 上。
     const COT_MAX_CHARS = 100;
     const COT_FLUSH_MS = 1500;
-    // 压成一行的进度片段。safeForMarkdown 必须先于截断: thinking 里一个裸反引号就能提前
-    // 闭合代码段, 让后面的正文裸奔在链接旁边。尾随的省略号 = "还在进行中"; 截断与进行中
-    // 共用同一个 …, 不叠加两个。
+    // 压成一行的进度片段, 纯文本上气泡 (不包代码段)。safeForMarkdown 必须先于截断:
+    // 进度行与链接头同行, thinking 里的 `[]`<>` 会戳破链接与排版。尾随的省略号 =
+    // "还在进行中"; 截断与进行中共用同一个 …, 不叠加两个。
     const cotLine = (s) => {
         const flat = safeForMarkdown(s.replace(/\s+/g, " ").trim());
         return flat ? `${flat.slice(0, COT_MAX_CHARS)}…` : "";
@@ -2502,22 +2712,25 @@ export const startMirror = (deps) => {
             a.cotTimer = undefined;
         }
         a.cotText = undefined;
+        a.cotTool = undefined;
     };
     const flushCot = async (a) => {
         a.cotTimer = undefined;
-        const text = a.cotText;
+        // 展示选取: assistant text (含 thinking) 优先; 没有新 text 时才落最新 tool_use。
+        const text = a.cotText ?? a.cotTool;
         a.cotText = undefined;
+        a.cotTool = undefined;
         const b = a.briefBubble;
         const turnId = a.briefTurnId;
         // 收口后这一路全部失效: 气泡要么已 done, 要么 turn 已经换人/清空。
-        if (!text || !b || b.done || !turnId || a.briefConcluded || answerSilent(a))
+        if (!text || !b || b.done || !turnId || a.briefConcluded)
             return;
         a.cotLastSent = text;
         try {
             await (b.pending = (b.pending ?? Promise.resolve()).catch(() => undefined).then(async () => {
-                if (b.done || a.briefBubble !== b || a.briefTurnId !== turnId || answerSilent(a))
+                if (b.done || a.briefBubble !== b || a.briefTurnId !== turnId)
                     return;
-                await client.replyStream(b.frame, b.streamId, briefLine(a, turnId, `\`${text}\``), false);
+                await client.replyStream(b.frame, b.streamId, briefLine(a, turnId, text), false);
             }));
         }
         catch (e) {
@@ -2537,11 +2750,25 @@ export const startMirror = (deps) => {
             return;
         a.cotTimer = setTimeout(() => void flushCot(a), COT_FLUSH_MS);
     };
+    /** tool_use 进度进 tool 槽 (不顶掉待发的 assistant text): flush 时 text 优先,
+     *  只有没有新 text 的窗口才把最新 tool 行刷上气泡。节流与 text 共用一个计时器。 */
+    const updateBriefToolProgress = (a, raw) => {
+        const b = a.briefBubble;
+        if (!b || b.done || a.briefConcluded)
+            return;
+        const line = cotLine(raw);
+        if (!line)
+            return;
+        a.cotTool = line;
+        if (a.cotTimer)
+            return;
+        a.cotTimer = setTimeout(() => void flushCot(a), COT_FLUSH_MS);
+    };
     // 链接落到 chat 视图: 默认选中本 turn 所属的 #tag, 贴底显示整条会话。turnId 依旧
     // 是凭据 (不可枚举), 只是页面从"一个 turn"扩成"这个 chat 的全部会话"。
     // wizard 名字作为 ww_uniq 传下去, 让同一个 wizard 的所有 turn 详情都复用一个 WeCom 窗口。
     // 头怎么写归 chatHead (默认 wizard 在 home 群: 企微只留名字链接, 微信不写头); 头与正文都空时留 `…`, 不发空气泡。
-    const briefLine = (a, turnId, rest, dest = a.channel) => headed(chatHead(a.target, buildChatUrl(cfg.daemon.detailPublicBase, cfg.daemon.host, cfg.daemon.port, turnId, roleUniq(a.target)), undefined, dest || undefined), rest) || "…";
+    const briefLine = (a, turnId, rest, dest = a.channel) => headed(chatHead(a.target, chatTurnUrl(a.target, turnId), undefined, dest || undefined), rest) || "…";
     // ── 出处门 (chatOriginOnly) ───────────────────────────────────────────
     // 人在 CLI 里手敲的一轮, 镜像只发生在两处: 他眼前的终端, 和 chat 详情页 (turn
     // store 全量记录 + SSE 实时刷新)。聊天里不再下发它的气泡 —— 那份内容他本来就
@@ -2549,9 +2776,7 @@ export const startMirror = (deps) => {
     // `[mirror]` 系统提示 —— 它们都不走这道门。
     // 只在 brief 下生效: 抑制的前提是详情页兜得住内容, 而 turn store 只有 brief 在写。
     // 私聊轮 (wizard 之间, 非 public) 同理: 它的回复属于那场私聊, 只进双方的 rolepage。
-    let silenceAnswer = () => false;
-    const answerSilent = (a) => silenceAnswer(a.target, a.briefTurnId ?? a.liveStream?.turnId ?? "");
-    const turnSilent = (a) => answerSilent(a) || isPrivate(a) || (cfg.wrc.mirror.brief && cfg.wrc.mirror.chatOriginOnly && a.turnFromChat === false);
+    const turnSilent = (a) => isPrivate(a) || (cfg.wrc.mirror.brief && cfg.wrc.mirror.chatOriginOnly && a.turnFromChat === false);
     const formatFinal = (target, turn, channel, body) => {
         const pieces = splitMarkdown(body, Math.max(200, cfg.wrc.mirror.chunkBytes - TAG_HEADER_BUDGET));
         return pieces.map((text, n) => withLinkedTagHeader(target, text, chatTurnUrl(target, turn), pieces.length > 1 ? `${n + 1}/${pieces.length}` : undefined, undefined, channel));
@@ -2562,14 +2787,16 @@ export const startMirror = (deps) => {
         finalProgress.delete(id);
     };
     const queueFinal = (target, turn, channel, body, eventId, bubble) => {
-        if (!deps.events || !channel || !body.trim())
+        // 投递出口剥掉行首收口标记与 ARTIFACT 行 (peers.stripForChat): 判定读原文, 群里只看结论。
+        const text = stripForChat(body);
+        if (!deps.events || !channel || !text.trim())
             return undefined;
-        const revision = finalId(eventId || turn, channel, body);
+        const revision = finalId(eventId || turn, channel, text);
         const id = finalId(eventId || turn, channel, revision);
-        const chunks = formatFinal(target, turn, channel, body);
+        const chunks = formatFinal(target, turn, channel, text);
         if (bubble?.pending)
             finalProgress.set(id, bubble.pending);
-        deps.events.delivery({ id, eventId, target, turn, channel, body, revision, chunks,
+        deps.events.delivery({ id, eventId, target, turn, channel, body: text, revision, chunks,
             ...(bubble && !bubble.done ? { stream: { frame: bubble.frame, id: bubble.streamId, expires: bubble.expires ?? Date.now() } } : {}) });
         if (bubble) {
             bubble.done = true;
@@ -2580,200 +2807,34 @@ export const startMirror = (deps) => {
     const recoverEventFinal = (event, bubble) => {
         if (!event.result || event.interjected || event.canceled)
             return;
+        // 事件泵的 evidence 探针 (observe → io.recovered) 与 brief 软收口赛跑: 两者同为
+        // ~1s 周期, 探针常先跑到, 而它调这里不带气泡 —— queueFinal 拿不到 stream, 终句
+        // 全部走 standalone, 气泡定格在最后一行 CoT 进度。没传气泡时按 target/turn 找回
+        // 活着的那只 (turn 已换人/气泡已收则不挂, 维持 standalone)。
+        bubble ??= (() => {
+            const a = byTarget.get(event.target);
+            return a && (!event.turn || a.briefTurnId === event.turn) && a.briefBubble && !a.briefBubble.done ? a.briefBubble : undefined;
+        })();
         const turn = event.turn || event.id;
         const record = getDetail(turn);
         if (!record)
             recordTurnStart({ id: turn, eventId: event.id, target: event.target,
                 userQuery: event.payload.text, createdAt: event.originalAt ?? event.at, channel: event.channel,
                 speaker: event.payload.human ? event.speaker : undefined, from: event.payload.peer?.from });
-        if (record?.kind !== "turn" || !record.items.some((x) => x.t === "text" && x.final && x.body === event.result.body))
+        // tail 已按软收口记过这句话 (final:false —— 它不带终句语义, doneAt 不认): 就地升级,
+        // 不追加同文第二条, 否则 rolepage 上草稿与终稿各画一颗气泡。没有同文的才补 —— 但也
+        // 只补「这轮还没有任何终句」的: 已有终句而 body 不同, 是续答链把子事件的终句写进了
+        // 同一段话只落一次 (子轮 / 父轮不各画一颗气泡)。
+        if (!(record?.kind === "turn" && markTurnTextFinal(turn, event.result.body)) &&
+            (record ? record.kind === "turn" && !record.items.some((x) => x.t === "text" && x.final) : true))
             recordTurnItem(turn, { t: "text", final: true, body: event.result.body, ts: event.result.at });
         recordTurnClose(turn);
         if (!event.turn)
             deps.events?.bind(event.id, turn);
-        const parent = event.replyTo?.kind === "chat" ? deps.events?.get(event.replyTo.turn) : undefined;
-        if (parent && event.channel === parent.channel) {
-            const original = deps.events.continueResult(event.id);
-            if (!original)
-                return;
-            if (eventFinalGate({ ...original, awaitingContinuation: false }))
-                deps.events.defer(original.id, false);
-            const fresh = deps.events.get(original.id);
-            if (fresh.replyTo?.kind === "chat")
-                recoverEventFinal(fresh, bubble);
-            else if (eventFinalGate(fresh))
-                queueFinal(fresh.target, fresh.turn || fresh.id, fresh.channel, event.result.body, fresh.id, bubble);
-        }
-        else if (event.channel && eventFinalGate(event))
+        // 终句按事件自己的 `serves` 放行 (§9.4/§9.5): 收口与否由路由表判 (eventFinalGate)。
+        if (event.channel && eventFinalGate(event))
             queueFinal(event.target, turn, event.channel, event.result.body, event.id, bubble);
     };
-    const answerBubbles = new Map();
-    const answerLine = (held, text) => withLinkedTagHeader(held.receiver, text, chatTurnUrl(held.receiver, held.sourceTurn), undefined, undefined, held.channel);
-    // Serialise the old owner's in-flight refresh, reset, progress and final.
-    // A delayed ACK must never let an earlier writer overtake the new owner.
-    const writeAnswerProgress = (held, text) => {
-        held.pending = held.pending.catch(() => undefined).then(async () => {
-            if (!held.active || held.stopped || !held.bubble || held.bubble.done)
-                return;
-            await client.replyStream(held.bubble.frame, held.bubble.streamId, answerLine(held, text), false);
-        }).catch((e) => log.warn({ err: errText(e) }, "answer transfer progress refresh failed"));
-    };
-    const updateAnswerProgress = (a, item) => {
-        // Queued metadata is not authority: only the input boundary activates a task.
-        const held = a.activePeerTurn ? answerBubbles.get(a.activePeerTurn) : undefined;
-        if (!held || held.receiver !== a.target || held.stopped || held.bubble?.done)
-            return;
-        const raw = item.kind === "tool_use" ? cotToolLabel(item.calls)
-            : item.kind === "thinking" || (item.kind === "text" && item.final !== true) ? item.body : "";
-        const line = cotLine(raw);
-        if (!line)
-            return;
-        held.progress = line;
-        if (!held.active)
-            return;
-        if (held.timer)
-            return;
-        held.timer = setTimeout(() => {
-            held.timer = undefined;
-            if (held.progress)
-                writeAnswerProgress(held, `\`${held.progress}\``);
-        }, COT_FLUSH_MS);
-    };
-    const answerContext = (target) => {
-        const a = byTarget.get(target);
-        if (!a || a.briefConcluded || a.briefIsSlash || isPrivate(a) || a.turnFromChat === false)
-            return undefined;
-        const turn = a.briefTurnId ?? a.liveStream?.turnId;
-        return turn ? { turn, channel: a.channel ?? baseOfKey(target), prefix: "" } : undefined;
-    };
-    const prepareAnswer = (id, source, expectedTurn, receiver, channel) => {
-        const a = byTarget.get(source);
-        if (!a || (a.briefTurnId ?? a.liveStream?.turnId) !== expectedTurn || answerBubbles.has(id))
-            return false;
-        if ((!a.briefBubble || a.briefBubble.done) && (!a.liveStream || a.liveStream.closed || a.liveStream.dead))
-            return false;
-        answerBubbles.set(id, {
-            source, receiver, sourceTurn: expectedTurn, channel, active: false, stopped: false,
-            bubble: a.briefBubble, stream: a.liveStream, pending: Promise.resolve(),
-        });
-        return true;
-    };
-    const cancelAnswerPreparation = (id) => {
-        const held = answerBubbles.get(id);
-        if (held && !held.active)
-            answerBubbles.delete(id);
-    };
-    const stopAnswerProgress = (id) => {
-        const held = answerBubbles.get(id);
-        if (!held)
-            return;
-        held.stopped = true;
-        clearTimeout(held.timer);
-        held.timer = undefined;
-    };
-    const takeAnswer = async (id, target, expectedTurn, receiver, channel) => {
-        const a = byTarget.get(target);
-        const held = answerBubbles.get(id);
-        if (!held || held.active || held.source !== target || held.sourceTurn !== expectedTurn || held.receiver !== receiver || held.channel !== channel)
-            return { taken: false, cleared: false };
-        const sameTurn = a && (a.briefTurnId ?? a.liveStream?.turnId) === expectedTurn;
-        if (sameTurn) {
-            clearCot(a);
-            a.cotLastSent = undefined;
-            if (a.standaloneBuf) {
-                clearTimeout(a.standaloneBuf.timer);
-                a.standaloneBuf = undefined;
-            }
-            // Only this source turn becomes private; a concurrent new human turn is untouched.
-            a.channel = "";
-        }
-        const s = held.stream;
-        if (s && !s.closed && !s.dead) {
-            s.closed = true;
-            clearTimeout(s.flushTimer);
-            clearTimeout(s.idleTimer);
-            clearTimeout(s.hardTimer);
-            // Read the current chain, not prepare's snapshot: source may have flushed during injection.
-            held.bubble = { frame: s.frame, streamId: s.streamId, done: false, pending: s.pending };
-            if (a?.liveStream === s)
-                a.liveStream = undefined;
-        }
-        else if (s)
-            held.bubble = undefined;
-        const b = held.bubble;
-        held.active = true;
-        if (!b || b.done)
-            return { taken: true, cleared: false };
-        clearTimeout(b.hardTimer);
-        if (a?.briefBubble === b)
-            a.briefBubble = undefined;
-        let cleared = false;
-        held.pending = (b.pending ?? Promise.resolve()).catch(() => undefined).then(async () => {
-            if (b.done)
-                return;
-            await client.replyStream(b.frame, b.streamId, answerLine(held, "…"), false);
-            cleared = true;
-        });
-        try {
-            await held.pending;
-        }
-        catch (e) {
-            cleared = false;
-            log.warn({ id, err: errText(e) }, "answer transfer reset not acknowledged");
-        }
-        // Keep delivery possible after a reset error; reset never carries the final answer.
-        held.pending = held.pending.catch(() => undefined);
-        if (!held.stopped && held.progress)
-            writeAnswerProgress(held, `\`${held.progress}\``);
-        return { taken: true, cleared };
-    };
-    const deliverAnswer = async (id, target, turn, channel, _prefix, body, standalone, frozen = false) => {
-        const held = answerBubbles.get(id);
-        const text = body.trim();
-        const content = frozen ? body : withLinkedTagHeader(target, text, chatTurnUrl(target, turn), undefined, undefined, channel);
-        stopAnswerProgress(id);
-        if (held?.bubble && !held.bubble.done) {
-            held.bubble.done = true;
-            clearTimeout(held.timer);
-            await held.pending;
-            try {
-                // Failure closes progress first; the terminal explanation is a standalone message.
-                const progress = withLinkedTagHeader(target, "回答已转交", chatTurnUrl(target, turn), undefined, undefined, channel);
-                const ack = frozen && !standalone
-                    ? await deps.sendFrozen(channel, content, { frame: held.bubble.frame, id: held.bubble.streamId })
-                    : await client.replyStream(held.bubble.frame, held.bubble.streamId, standalone ? progress : content, true);
-                if (!standalone) {
-                    answerBubbles.delete(id);
-                    return ack;
-                }
-            }
-            catch (e) {
-                const ack = e && typeof e === "object" ? e : undefined;
-                // Only a structured non-zero server ACK proves the stream frame was
-                // rejected. Timeout/disconnect errors are ambiguous: standalone retry
-                // could publish the same final answer twice, so let the caller persist
-                // `uncertain` and require a human resend instead.
-                const rejected = !!ack && typeof ack.headers === "object" && !!ack.headers && typeof ack.errcode === "number" && ack.errcode !== 0 && typeof ack.errmsg === "string";
-                if (!rejected && !standalone) {
-                    answerBubbles.delete(id);
-                    throw e;
-                }
-                if (!rejected) {
-                    log.warn({ id, err: errText(e) }, "answer transfer progress close acknowledgement uncertain; continuing with the one standalone terminal explanation");
-                    // In standalone mode this stream only closes progress; it never
-                    // carries the final body, so sending the terminal explanation once
-                    // remains necessary even when progress-close ACK is ambiguous.
-                }
-                else {
-                    log.warn({ id, err: errText(e), errcode: ack.errcode }, "answer transfer stream was explicitly rejected; standalone fallback");
-                }
-            }
-        }
-        const ack = frozen ? await deps.sendFrozen(channel, content)
-            : await client.sendMessage(channel.replace(/^(user|chat|group):/, ""), { msgtype: "markdown", markdown: { content } });
-        answerBubbles.delete(id);
-        return ack;
-    };
     // 收口一条 loading 气泡: finish=true 写入最终内容, 只生效一次。发送失败退回 standalone。
     // raw=true skips withTagHeader (used when content already contains the linked tag header).
     // WeCom 客户端收到 finish=true 后仍有打字机动画要播放, 如果紧接着就下发
@@ -2846,6 +2907,8 @@ export const startMirror = (deps) => {
     const publicPeer = (from) => from?.kind === "peer" && from.public ? from.from : undefined;
     /** reload 后 tail 从 EOF 接上: 正在跑的这一轮的开头那句已在身后, 它的印章随旧进程没了。
      *  那句话自己挂着信封 (谁说的、私聊还是哪个群) —— 读回来就是这一轮的出处。没挂信封 = undefined。 */
+    /** 这一轮挂在哪一笔上: 回执 (与老派活信封) 写在信封上; 新派活信封不带, 问注入事件的 `serves`。 */
+    const rowOf = (env) => env.event ?? (env.eventId ? deps.events?.get(env.eventId)?.serves : undefined);
     const openingOf = (a) => {
         const t = a.jsonlPath ? lastUserTurn(a.jsonlPath) : undefined;
         const env = t?.env;
@@ -2853,7 +2916,9 @@ export const startMirror = (deps) => {
         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.asker ? { asker: env.asker } : {}) }
+        // transfer 过来的那一笔信封上写着群 (不是 private), 但它不是公开派活: 回复不标给发话方。
+        const handed = !!(env.eventId && deps.events?.get(env.eventId)?.payload.peer?.from?.transferred);
+        const from = env.kind === "peer" ? { kind: "peer", from: wizardStore()?.byName(stripSigil(env.from))?.target, ...(handed ? { transferred: true } : env.private ? {} : { public: true }), ...(env.receipt ? { receipt: true } : {}), ...(env.status ? { status: env.status } : {}), ...((turn) => (turn ? { turn } : {}))(rowOf(env)), ...(env.asker ? { asker: env.asker } : {}) }
             : env.kind === "task" ? { kind: "task", taskId: env.from.replace(/^定时 /, "") }
                 : undefined;
         return {
@@ -2903,7 +2968,7 @@ export const startMirror = (deps) => {
         }
         // 私聊派来的活 (不是回执) 这一轮必是私聊, 不论印章带没带频道: 进群的只能是人问的事的
         // 交代与显式公开。带 task 的 fork 分身就只有出处、没有频道印章, 退回 home 就把私聊派的活答进了群。
-        if (from?.kind === "peer" && !from.public && !from.receipt) {
+        if (from?.kind === "peer" && !from.public && !from.receipt && !from.transferred) {
             a.channel = "";
             a.speaker = undefined;
             a.replyTo = undefined;
@@ -2964,7 +3029,6 @@ export const startMirror = (deps) => {
             closeBriefTurn(a);
         a.activeEventId = s.eventId;
         s.activated = true;
-        a.activePeerTurn = undefined;
         a.queryEpoch = (a.queryEpoch ?? 0) + 1; // WeCom 侧的新一轮同样是 query 边界
         a.turnFromChat = true; // 出处确凿: 这一轮有 frame, 群里就是它的主场
         a.pendingFromCli = false; // 人改从聊天里说话了, 之前那条 CLI 输入不再是出处
@@ -3014,7 +3078,6 @@ export const startMirror = (deps) => {
             closeBriefTurn(a);
         a.activeEventId = s.eventId;
         const now = Date.now();
-        a.activePeerTurn = s.from?.kind === "peer" ? s.from.turn : undefined;
         a.pendingFrom = s.from ? { from: s.from, at: now } : undefined;
         a.pendingOrigin = s.origin ? { origin: s.origin, at: now } : undefined;
         // 没写频道的注入 (graph 步骤 / 手动 inject) 等同在 home 里开口: 印章就是全部出处, 不沿用上一轮的。
@@ -3087,7 +3150,6 @@ export const startMirror = (deps) => {
         a.channel = r.channel === undefined || r.channel === baseOfKey(a.target) ? undefined : r.channel;
         a.speaker = r.speaker;
         a.convFrom = r.from;
-        a.activePeerTurn = r.from?.kind === "peer" ? r.from.turn : undefined;
         a.replyTo = publicPeer(r.from);
         a.turnFromChat = a.turnFromChat ?? true;
         a.briefTurnId = r.id;
@@ -3175,12 +3237,27 @@ export const startMirror = (deps) => {
         const event = a.activeEventId ? deps.events?.get(a.activeEventId) : undefined;
         if (event)
             deps.events.result(event.id, body, finalId(event.id, event.channel, body), turnId);
-        if (!answerSilent(a) && !turnSilent(a) && (!event || eventFinalGate(event))) {
+        const gated = !!event && !eventFinalGate(event);
+        if (!turnSilent(a) && !gated) {
             if (event)
                 recoverEventFinal(deps.events.get(event.id), a.briefBubble);
             else
                 queueFinal(a.target, turnId, a.channel ?? baseOfKey(a.target), body, undefined, a.briefBubble);
         }
+        else if (gated && !turnSilent(a)) {
+            // 链式收口 (eventFinalGate: 子活未落定) 延后的是 closing 的释放, 不该扣住气泡:
+            // queueFinal 没跑 = 没人收气泡, 它会定格在最后一行 CoT 进度上 (看着像卡在 tool
+            // use), hardTimer 到点的空 finish 又被 chat-gate 当 empty push 丢掉。气泡还在
+            // stream 窗口内就把终句刷进气泡 (`链接 正文` 覆盖, 与正常收口同形); 气泡已收 /
+            // 过期 / 终句超单条上限则 standalone 展示终句。
+            const b = a.briefBubble;
+            const text = stripForChat(body); // 同 queueFinal: 群气泡不带收口标记 / ARTIFACT 行
+            const fitsOneChunk = splitMarkdown(text, Math.max(200, cfg.wrc.mirror.chunkBytes - TAG_HEADER_BUDGET)).length === 1;
+            if (b && !b.done && fitsOneChunk && Date.now() < (b.expires ?? 0))
+                void finishBriefBubble(a, text);
+            else if (text.trim())
+                sendStandalone(a, text);
+        }
         // The durable result/outbox must exist before this in-memory dedup bit advances.
         a.briefConcluded = true;
         a.lastConcludedBody = body;
@@ -3219,6 +3296,8 @@ export const startMirror = (deps) => {
         voidTurnAgents(a);
         closeSubagentTurns(a); // 父 turn 收口 = 它派出的 subagent 都已结束
         clearCot(a);
+        // 它闲下来了: 收件箱里等它闲的回执 / 派活此刻就该贴, 不等下一拍定时泵。
+        void deps.events?.pump();
     };
     // ── Subagent turns ─────────────────────────────────────────────────
     // Task/Agent 工具派出的子 agent 在自己的转录文件里跑 (主 jsonl 只有派发与最终
@@ -3307,10 +3386,10 @@ export const startMirror = (deps) => {
                 closeSubagentRun(a, agentId);
                 return;
         }
-        // brief 气泡的实时进度: 静默窗 (keepalive 吞没 / 新 pane 未注入) 不推;
+        // brief 气泡的实时进度: 静默窗 (新 pane 未注入) 不推;
         // updateBriefProgress 自身会检查气泡是否仍开。final text 之后的 end 会很快
         // 收口气泡, 进度行不会残留。
-        if (a.muteUntilInject || a.keepaliveQuiet || a.keepaliveByContent)
+        if (a.muteUntilInject)
             return;
         const activity = item.kind === "tool_use"
             ? cotToolLabel(item.calls)
@@ -3412,7 +3491,7 @@ export const startMirror = (deps) => {
         const now = Date.now();
         if (item.kind === "tool_use") {
             markBriefTool(a);
-            updateBriefProgress(a, cotToolLabel(item.calls));
+            updateBriefToolProgress(a, cotToolLabel(item.calls));
             for (const c of item.calls) {
                 // 也走单卡 detail record — turn 页里 tool_use 段可点开链到独立详情 (以后有需要时)。
                 if (c.toolUseId) {
@@ -3602,70 +3681,15 @@ export const startMirror = (deps) => {
         if (a.liveStream && !a.liveStream.closed)
             void finalizeStream(a, a.liveStream);
     };
-    // End the keepalive swallow — the ping turn is over (turn_end / genuine
-    // user line / inject failure), so real items flow through onItem again.
-    // Clears BOTH the timer window and the content flag.
-    const endKeepaliveSwallow = (a) => {
-        if (a.keepaliveQuiet) {
-            clearTimeout(a.keepaliveQuiet);
-            a.keepaliveQuiet = undefined;
-        }
-        if (a.keepaliveContentTimer) {
-            clearTimeout(a.keepaliveContentTimer);
-            a.keepaliveContentTimer = undefined;
-        }
-        a.keepaliveByContent = undefined;
-    };
-    // Content-based swallow entry: the tailed user line IS a configured ping.
-    // Belt to the inject-time timer window — this one keys on the user message
-    // itself, so it holds across daemon reloads, tail replays and replies
-    // slower than the 60s fail-safe. Reuses the detail turn the timer flow may
-    // have opened (fireKeepalive skips opening when this got there first).
-    const KEEPALIVE_CONTENT_FAILSAFE_MS = 5 * 60_000;
-    const PONG_RE = /pong/i;
-    const beginKeepaliveByContent = (a, text) => {
-        a.keepaliveByContent = true;
-        if (a.keepaliveContentTimer)
-            clearTimeout(a.keepaliveContentTimer);
-        // Fail-safe: a ping turn whose reply never emits turn_end (crash/hang)
-        // must not mute a later real turn forever.
-        a.keepaliveContentTimer = setTimeout(() => {
-            a.keepaliveContentTimer = undefined;
-            a.keepaliveByContent = undefined;
-        }, KEEPALIVE_CONTENT_FAILSAFE_MS);
-        if (!a.keepaliveTurnId) {
-            const turnId = newTurnId();
-            a.keepaliveTurnId = turnId;
-            recordTurnStart({ id: turnId, target: a.target, sessionId: a.sessionId, cli: cliOf(a), initialModel: a.model || undefined, initialEffort: a.effort || undefined, userQuery: text });
-        }
-    };
-    // A keepalive ping turn is swallowed wholesale — the reply content doesn't
-    // matter (model may add extra commentary beyond "pong", that's fine).
     const onItem = (a, item) => {
         // 新 spawn 的 pane 在首次 inject 落地前吞掉所有初始输出 (greeting/system)。
         if (a.muteUntilInject)
             return;
-        // Keepalive ping turns are cache-warmers: swallow every item from every
-        // WeCom path so the ping/pong never reaches chat. Two triggers, either
-        // suffices — the timer window opened at inject (keepaliveQuiet) OR the
-        // user line itself matching a configured ping (keepaliveByContent; the
-        // reload/replay/slow-reply-proof one). The REAL exchange is recorded
-        // into its chat-detail turn — the actual assistant reply, the tool calls
-        // if any, and the usage — so the detail page shows the genuine heartbeat.
-        if (item.kind === "keepalive_start") {
-            beginKeepaliveByContent(a, item.body);
-            return;
-        }
-        // A genuine user line (not our inject, not a ping) is a hard turn
-        // boundary — any keepalive swallow still holding never got its turn_end
-        // (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, item.eventId))
                 return;
-            endKeepaliveSwallow(a);
             // 对话边界 = 旧 turn 清算。上一 turn 派发而未返回的前台 Agent/Task 到此作废,
             // 清掉防残留阻塞新 turn 的软收口 (guard 的 defer 判断依据)。
             voidTurnAgents(a);
@@ -3675,7 +3699,6 @@ export const startMirror = (deps) => {
             // 不决定详情页记不记 —— 聊天不再下发 CLI 轮之后, 详情页是唯一的落点。
             a.pendingBriefQuery = item.body;
             a.pendingBriefAt = item.ts;
-            a.activePeerTurn = undefined;
             a.pendingFrom = undefined;
             a.pendingChannel = undefined;
             a.activeEventId = item.eventId;
@@ -3703,46 +3726,9 @@ export const startMirror = (deps) => {
                 recordTurnQuery(a.briefTurnId, item.body, (prev) => cleanUserText(prev ?? "") === item.said);
             return;
         }
-        // 后台派发的结束信号 —— 它不是 function_call_result (那只是 spawn 句柄)。放在
-        // keepalive 门之前: 吞没窗口里到达也必须销账, 否则账本永久悬空。
+        // 后台派发的结束信号 —— 它不是 function_call_result (那只是 spawn 句柄)。
         if (item.kind === "skill_output" && item.agentDone)
             clearBackgroundAgent(a, item.agentDone);
-        // Reply-side belt: a "pong" arriving with NO swallow holding. Both triggers
-        // above live in memory, and the tail re-attaches at EOF — a reload between
-        // the ping and its reply forgets the ping was ever sent, and the pong opens
-        // a chat turn of its own. So ask the transcript: if the last thing said to
-        // the model is a keepalive ping, this text is its pong — swallow from here
-        // to the turn_end, recorded as the same marked detail turn. Gated on the
-        // transcript, not on the word alone: a real answer that mentions pong has a
-        // real question in front of it.
-        if (item.kind === "text" && !a.keepaliveQuiet && !a.keepaliveByContent && PONG_RE.test(item.body)) {
-            const ping = openKeepalivePing(a.jsonlPath, pingSigs);
-            if (ping)
-                beginKeepaliveByContent(a, ping);
-        }
-        if (a.keepaliveQuiet || a.keepaliveByContent) {
-            const id = a.keepaliveTurnId;
-            if (id) {
-                const now = Date.now();
-                if (item.kind === "text") {
-                    recordTurnItem(id, { t: "text", body: item.body, ts: now, final: item.final === true });
-                }
-                else if (item.kind === "tool_result") {
-                    recordTurnItem(id, { t: "tool_result", toolUseId: item.toolUseId, body: item.full, ts: now });
-                }
-                else if (item.kind === "turn_usage") {
-                    recordTurnUsage(id, { model: item.model, effort: item.effort, messageId: item.messageId, usage: item.usage });
-                }
-                else if (item.kind === "turn_end") {
-                    recordTurnClose(id);
-                    a.keepaliveTurnId = undefined;
-                }
-            }
-            if (item.kind === "turn_end") {
-                endKeepaliveSwallow(a);
-            }
-            return;
-        }
         // 父 agent 自己的新产出到达 = 上一条"消息写完了"并不代表这一轮结束 → 撤销待确认
         // 的软收口。硬信号 (end_turn / turn_duration) 的后端永远不会走到这里。
         //
@@ -3766,7 +3752,6 @@ export const startMirror = (deps) => {
         // 的配置下, 人在 CLI 敲的那一行就这么原样回显进了群, 正好破了 chatOriginOnly。
         if (item.kind === "user_text" && (item.quiet || cfg.wrc.mirror.brief))
             return;
-        updateAnswerProgress(a, item);
         // thinking 唯一的出口是 brief 气泡的 CoT 进度行。必须在这里就吃掉 —— 漏到下面任何
         // 一条通道 (deferred buf → renderBuf / standalone / stream append) 都会把它写进正文,
         // 那就变回已下线的 thinkStyle 了。
@@ -4090,7 +4075,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, effort, pendingCwd, keepaliveDisabled }) => {
+    const attach = ({ sessionId, jsonlPath, target: targetOverride, tmuxPane, tmuxSession, cwd, model, effort, pendingCwd }) => {
         const target = resolveTarget(targetOverride);
         if (!target)
             return { ok: false, reason: "no target chat (set wrc.mirror.pushChat or defaultChat, or pass target)" };
@@ -4121,9 +4106,6 @@ export const startMirror = (deps) => {
         // 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);
         if (prevByTarget)
             detach(prevByTarget, "target reassigned");
         // Build the attachment first so the tail's onItem closure can capture it.
@@ -4140,7 +4122,6 @@ export const startMirror = (deps) => {
             pendingCwd: carryPending,
             model: carryModel,
             effort: carryEffort,
-            keepaliveDisabled: carryKeepaliveDisabled,
             tail: { stop: () => undefined, drain: () => undefined, livePath: () => undefined }, // placeholder; replaced below
             standalonePending: Promise.resolve(),
             recentToolSigs: new Map(),
@@ -4155,7 +4136,6 @@ export const startMirror = (deps) => {
             toolUseInlineMaxChars: cfg.wrc.mirror.toolUseInlineMaxChars,
             isOwnInject,
             isOwnAssistantSend,
-            isKeepalivePing,
             onItem: (item) => onItem(a, item),
             onCompact: () => contextCut(a.target, "compact"),
             detailUrlFor,
@@ -4168,9 +4148,6 @@ export const startMirror = (deps) => {
         startSubagentsFor(a);
         bySessionId.set(sessionId, a);
         byTarget.set(target, a);
-        // Preserve a persisted `/stop` pause across the re-attach: restore rebuilds the
-        // record here, and dropping keepaliveOff would resurrect a session the user
-        // explicitly quieted. restoreFromStore re-hydrates the in-memory flags below.
         const prevRec = deps.store.get(target);
         deps.store.set(target, {
             sessionId,
@@ -4182,9 +4159,6 @@ export const startMirror = (deps) => {
             effort: a.effort || undefined,
             pendingCwd: a.pendingCwd || undefined,
             cwdConfirmed: prevRec?.cwdConfirmed,
-            keepaliveOff: prevRec?.keepaliveOff,
-            keepaliveOffAt: prevRec?.keepaliveOffAt,
-            keepaliveDisabled: carryKeepaliveDisabled || undefined,
         });
         log.info({ sessionId, jsonlPath, target, tmuxSession: a.tmuxSession, runningCwd: a.runningCwd, pendingCwd: a.pendingCwd, mirrors: bySessionId.size }, "mirror attached");
         return { ok: true, sessionId, jsonlPath, target };
@@ -4197,16 +4171,14 @@ export const startMirror = (deps) => {
     // the pane is alive — and tmux pane ids monotonically increment within a
     // server lifetime, so a freed id will not be silently reused. We don't need
     // the session name, which matters because some attaches carry only a pane id.
-    const tmuxPaneAlive = async (paneId) => {
-        if (!paneId)
-            return false;
-        const r = await runTmux(["display-message", "-p", "-t", paneId, "#{pane_id}"]);
-        return r.code === 0 && r.stdout.trim() === paneId;
-    };
-    // 注入前的存活判定要多问一句「里面还有 AI 会话吗」: pane 在、claude 却退回了 shell,
+    // 布尔形式留给只问「这个 pane 还在不在」的调用点 (submitPane / 忙闲判定): 三态里的
+    // `unknown` 仍旧是 false —— 它们不动会话, 判错没有副作用。决定要不要重生 pane 的地方
+    // 必须自己看 `probePane` 的三态, 见 injectText / inject job。
+    const tmuxPaneAlive = async (paneId) => (await paneLiveness(paneId)) === "alive";
+    // 注入前的存活判定要多问一句「里面还有 AI 会话吗」: pane 在、CLI 却退回了 shell,
     // 照旧往里贴就是把用户的话当 shell 命令跑。判否即走 respawn (旧 pane 不杀 —— 它可能是
     // 用户自己的终端, 经 switch 绑进来的)。
-    const paneUsable = async (paneId, jsonlPath) => (await tmuxPaneAlive(paneId)) && (await paneHostsSession(paneId, backendForPath(jsonlPath).homeDir));
+    const paneUsable = async (paneId, jsonlPath) => (await probePane(paneId, jsonlPath)).state === "session";
     // Re-attach a stored binding for `principal`. Returns the resulting state, or
     // undefined if the on-disk transcript is gone (in which case the entry is
     // dropped so the next inbound flows through /new auto-spawn).
@@ -4221,6 +4193,9 @@ export const startMirror = (deps) => {
     // 文件。同一个 cwd 下别的 target 的迁移 / 自愈 / 分叉跟随也在扫这个目录里「新出现的
     // jsonl」, 不挡住的话它会先一步把别人的新会话认走, 正主 attach 时反撞 "already bound"。
     const inFlightSids = new Set();
+    // 已 spawn、还没 attach 的 pane: 分身要先说开场白、等分叉文件才能绑定, 这段里它在
+    // tmux 里活着却不在任何绑定上 —— 孤儿清扫必须认得它, 不能只靠进程年龄宽限。
+    const spawningPanes = new Set();
     const sidsClaimedByOthers = (principal) => {
         const s = new Set(inFlightSids);
         for (const [k, v] of Object.entries(deps.store.all()))
@@ -4348,25 +4323,10 @@ export const startMirror = (deps) => {
             log.warn({ principal, reason: r.reason }, "mirror restore: re-attach failed");
             return undefined;
         }
-        // Re-hydrate the `/stop` pause so a reload doesn't resume pinging a quieted
-        // session (attach preserved it on disk; this puts it back in memory).
-        // keepaliveDisabled is carried by attach() itself (same rule as `model`);
-        // only the transient `/stop` pause needs manual re-hydration here.
         const restored = byTarget.get(principal);
-        if (restored && rec.keepaliveOff) {
-            restored.keepaliveOff = true;
-            restored.keepaliveOffAt = rec.keepaliveOffAt;
-        }
         log.info({ principal, sessionId: rec.sessionId, livePane: livePane || "(spawn-mode)" }, "mirror restored from store");
         return restored;
     };
-    // Write the live `/stop` pause state through to the store (merging, not
-    // clobbering, the rest of the record) so it survives a daemon reload.
-    const persistPause = (a) => {
-        const rec = deps.store.get(a.target);
-        if (rec)
-            deps.store.set(a.target, { ...rec, keepaliveOff: a.keepaliveOff, keepaliveOffAt: a.keepaliveOffAt, keepaliveDisabled: a.keepaliveDisabled });
-    };
     // We re-attach lazily on demand too (see restoreFromStore in dispatch /
     // hasMirrorTarget), but eager boot-restore makes outbound (tail → push) work
     // even before any inbound arrives — e.g. claude finishes a long-running
@@ -4575,15 +4535,6 @@ export const startMirror = (deps) => {
         markCut(a.target, newSessionId, cleared ? "clear" : "switch");
         if (cleared)
             contextCut(a.target, "clear");
-        if (cleared) {
-            // 真清空 = 缓存里已无任何值得保温的内容。像 /stop 一样暂停保活 —— 与
-            // dispatch 里 WeCom 注入 /clear 的暂停对齐;TUI 手打 /clear 只走这个漏斗,
-            // 不在这里停下的话旧时钟会继续 ping 一个空上下文。busy-resume(过 grace)
-            // 或真实 inbound 解除。下方 store.set 一并落盘。
-            a.keepaliveOff = true;
-            a.keepaliveOffAt = Date.now();
-            a.keepalive = undefined;
-        }
         a.tail.stop();
         bySessionId.delete(oldSessionId);
         a.sessionId = newSessionId;
@@ -4599,7 +4550,6 @@ export const startMirror = (deps) => {
             toolUseInlineMaxChars: cfg.wrc.mirror.toolUseInlineMaxChars,
             isOwnInject,
             isOwnAssistantSend,
-            isKeepalivePing,
             onItem: (item) => onItem(a, item),
             onCompact: () => contextCut(a.target, "compact"),
             detailUrlFor,
@@ -4619,10 +4569,6 @@ export const startMirror = (deps) => {
             tmuxPane: a.tmuxPane || undefined,
             cwd: a.runningCwd || undefined,
             pendingCwd: a.pendingCwd || undefined,
-            // store.set 是整记录替换 —— 必须带上暂停态,否则迁移会把 dispatch 刚落盘
-            // 的 /clear 暂停(或之前的 /stop 暂停)从盘上抹掉,reload 后保活复活。
-            keepaliveOff: a.keepaliveOff || undefined,
-            keepaliveOffAt: a.keepaliveOffAt || undefined,
         });
         log.info({ target: a.target, oldSessionId, newSessionId, oldJsonlPath, newJsonlPath, startOffset }, "mirror migrated session");
     };
@@ -4856,6 +4802,10 @@ export const startMirror = (deps) => {
     // different project dir whose live session has a different sid, migrate onto
     // it. Tail from EOF (undefined startOffset): the worktree session already
     // carries full history we don't want to re-dump to WeCom.
+    //
+    // 同目录的轮换 (人在 TUI 里敲 `/clear`、或 CLI 自己换了会话) 走下面同一张表的 sameDir
+    // 分支 —— 目录没变, 但「旧 jsonl 从此没人写」的后果一模一样, 而它比 worktree 常见得多
+    // (人就在 pane 里敲命令)。
     let paneDriftTicking = false;
     const followPaneDrift = async () => {
         if (paneDriftTicking)
@@ -4891,8 +4841,26 @@ export const startMirror = (deps) => {
                     continue;
                 }
                 const paneDir = projectDirFor(a.jsonlPath, expandHome(cwd));
-                if (backendForPath(a.jsonlPath).name === "codex" ? expandHome(cwd) === a.runningCwd : paneDir === dirname(a.jsonlPath))
-                    continue; // same project dir — no drift
+                const sameDir = backendForPath(a.jsonlPath).name === "codex" ? expandHome(cwd) === a.runningCwd : paneDir === dirname(a.jsonlPath);
+                if (sameDir) {
+                    // 同一个项目目录里的会话轮换: 人在 TUI 里直接敲了 `/clear` (或 CLI 自己换了会话)。
+                    // 目录没变, 下面那条按目录判的漂移看不见它, 结果一样是「旧 jsonl 再没人写, 气泡
+                    // 永远停在最后一格」, 而每次 reload 的 boot 恢复都会把这份死绑定再恢复一遍。
+                    //   判据只认**注册表按 pane 报的会话** —— 只有写 `tmux` 字段的后端有这条路。
+                    // codebuddy 没有: 它的注册行里 sessionId 是续接链的根, 换过 sid 后不更新 (实测
+                    // pid 84679 报 3d51b76b 而进程实际在写 01a13ae5), 沿进程树只能认出「有活的 CLI」
+                    // 而不是「哪份转录」; 而「目录里最新的是谁」在共用 cwd 下会把别人的转录认到自己
+                    // 身上。两条都不能用, 所以这里对 codebuddy 什么都不做 —— 认不出就不动。
+                    const liveOnPane = sessionOnPane(backendForPath(a.jsonlPath).homeDir, a.tmuxPane);
+                    if (!liveOnPane || liveOnPane.sessionId === a.sessionId || sidsClaimedByOthers(a.target).has(liveOnPane.sessionId))
+                        continue;
+                    // 从 EOF 起读 (不给 startOffset): 轮换之后新文件已经自己长了一段 (轮换那一刻到这一
+                    // tick 之间人敲进去的话), 从 0 重读等于把整段会话倒进聊天窗口。补不上接缝,
+                    // 但从此往后是通的 —— 比一直不通强。
+                    log.info({ target: a.target, pane: a.tmuxPane, from: a.sessionId, to: liveOnPane.sessionId }, "mirror: pane 里的会话轮换 (同目录), 跟随它");
+                    migrateAttachment(a, liveOnPane.sessionId, join(dirname(a.jsonlPath), `${liveOnPane.sessionId}.jsonl`));
+                    continue;
+                }
                 const live = liveSessionForCwd(cwd, backendForPath(a.jsonlPath), sidsClaimedByOthers(a.target));
                 if (!live || live.sessionId === a.sessionId)
                     continue; // empty dir, or same-sid rename (tail follows it)
@@ -5033,7 +5001,7 @@ export const startMirror = (deps) => {
             cfg,
             log: log.child({ sub: "new-session", target }),
             sessionId: freshSid,
-            windowName: windowName ?? target,
+            windowName: windowLabel(target, windowName),
             cwdOverride: eff,
             cli: effCli,
             model: effModel,
@@ -5065,7 +5033,6 @@ export const startMirror = (deps) => {
             // raw request — a later respawn's fast path then matches on try one.
             model: r.model ?? effModel ?? "",
             effort: r.effort ?? "",
-            keepaliveDisabled: opts?.keepalive === undefined ? undefined : !opts.keepalive,
         });
         inFlightSids.delete(freshSid);
         if (!att.ok)
@@ -5079,14 +5046,6 @@ export const startMirror = (deps) => {
             // 只有换过 pane 才是断点 —— 首次建会话时 prev 为空, 那不是"不连续", 是开局。
             if (prev)
                 markCut(target, spawned.sessionId, "new");
-            // A freshly spawned session is empty — nothing in the cache to keep warm.
-            // Pause keepalive like /stop; the first real turn (WeCom inbound, or the
-            // pane going busy after the resume grace) re-earns the budget. Mirrors
-            // interruptPane so /new can't strand a ping loop on an idle blank session.
-            spawned.keepaliveOff = !opts?.warm;
-            spawned.keepaliveOffAt = Date.now();
-            spawned.keepalive = undefined; // re-anchors cleanly on resume
-            persistPause(spawned);
         }
         // Clear the chat's pendingCwd on the BASE record too — the queued switch
         // has just been consumed by this respawn. Without this, a subsequent /new
@@ -5176,7 +5135,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, effort: args.effort, cwd: args.cwd, systemPrompt: args.systemPrompt, silent: true, keepalive: args.keepalive, guard: args.guard ? () => args.guard("paste") : undefined,
+                model: args.model, effort: args.effort, cwd: args.cwd, systemPrompt: args.systemPrompt, silent: true, guard: args.guard ? () => args.guard("paste") : undefined,
             });
             return { ...r, inherited: false };
         }
@@ -5195,7 +5154,7 @@ export const startMirror = (deps) => {
             log: lg,
             resumeSessionId: parent.sessionId,
             forkSession: true,
-            windowName: args.windowName ?? args.target,
+            windowName: windowLabel(args.target, args.windowName),
             cwdOverride: parent.runningCwd,
             cli: parentCli,
             model,
@@ -5204,51 +5163,61 @@ export const startMirror = (deps) => {
         });
         if (!r.ok)
             return { ok: false, reason: r.reason, inherited: false };
-        // 分叉文件不是开机就有的: CLI 在这个 pane **收到第一条消息**的那一刻才把父亲的
-        // transcript 复制成新文件。所以必须先说一句话, 分身才会有自己的 sid —— 这句话
-        // 顺便就是它的开场白 (「你是谁、继承了什么、准备接什么」)。
-        const hello = args.bootstrap?.trim()
-            || "（wezard 分身初始化）用一句话说明: 你是谁、从谁那里继承了哪些上下文、准备接什么活。不要复述这条指令。";
-        rememberInject(hello);
-        const boot = await inject({
-            text: hello, images: [], cfg, log: lg,
-            sessionId: parentCli === "codex" ? r.sessionId : parent.sessionId, jsonlPath: parentCli === "codex" ? r.jsonlPath : parent.jsonlPath,
-            tmuxTarget: r.tmuxPane, freshSpawn: true, guard: args.guard,
-        });
-        if (!boot.ok) {
-            await runTmux(["kill-pane", "-t", r.tmuxPane ?? ""]);
-            return { ok: false, reason: `分身开场白注入失败: ${boot.reason ?? "unknown"}`, inherited: false };
-        }
-        const fork = parentCli === "codex" ? { sessionId: r.sessionId, jsonlPath: r.jsonlPath } : 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 一起杀掉, 调用方拿到的是一个干净的失败。
-        if (!fork) {
-            await runTmux(["kill-pane", "-t", r.tmuxPane ?? ""]);
-            return { ok: false, reason: "分身没能在超时内分叉出自己的会话 (CLI 可能不支持 --fork-session)", inherited: false };
-        }
-        if (args.guard && !args.guard("submit")) {
+        // 开场白 + 等分叉期间 pane 活着却没绑定: 挂上 spawningPanes, 别被孤儿清扫当尸体收掉。
+        const pane = r.tmuxPane ?? "";
+        spawningPanes.add(pane);
+        let att;
+        let fork;
+        try {
+            // 分叉文件不是开机就有的: CLI 在这个 pane **收到第一条消息**的那一刻才把父亲的
+            // transcript 复制成新文件。所以必须先说一句话, 分身才会有自己的 sid —— 这句话
+            // 顺便就是它的开场白 (「你是谁、继承了什么、准备接什么」)。
+            const hello = args.bootstrap?.trim()
+                || "（wezard 分身初始化）用一句话说明: 你是谁、从谁那里继承了哪些上下文、准备接什么活。不要复述这条指令。";
+            rememberInject(hello);
+            const boot = await inject({
+                text: hello, images: [], cfg, log: lg,
+                sessionId: parentCli === "codex" ? r.sessionId : parent.sessionId, jsonlPath: parentCli === "codex" ? r.jsonlPath : parent.jsonlPath,
+                tmuxTarget: r.tmuxPane, freshSpawn: true, guard: args.guard,
+            });
+            if (!boot.ok) {
+                await runTmux(["kill-pane", "-t", r.tmuxPane ?? ""]);
+                return { ok: false, reason: `分身开场白注入失败: ${boot.reason ?? "unknown"}`, inherited: false };
+            }
+            const forked = parentCli === "codex" ? { sessionId: r.sessionId, jsonlPath: r.jsonlPath } : 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 一起杀掉, 调用方拿到的是一个干净的失败。
+            if (!forked) {
+                await runTmux(["kill-pane", "-t", r.tmuxPane ?? ""]);
+                return { ok: false, reason: "分身没能在超时内分叉出自己的会话 (CLI 可能不支持 --fork-session)", inherited: false };
+            }
+            fork = forked;
+            if (args.guard && !args.guard("submit")) {
+                inFlightSids.delete(fork.sessionId);
+                // The bootstrap may already have executed; withhold binding, report the
+                // unconfirmed birth to its caller instead of claiming cancellation success.
+                return { ok: false, reason: "fork executed after permission withdrawal; reconcile pane manually", inherited: false };
+            }
+            att = attach({
+                sessionId: fork.sessionId,
+                jsonlPath: fork.jsonlPath,
+                target: args.target,
+                tmuxPane: r.tmuxPane,
+                tmuxSession: r.tmuxSession,
+                cwd: r.cwd,
+                pendingCwd: "",
+                model: r.model ?? model,
+                effort: r.effort ?? "",
+            });
+            // 绑上 (或没绑上) 之后预留就没用了: 绑上的 sid 由 sidsClaimedByOthers 挡住别人。
             inFlightSids.delete(fork.sessionId);
-            // The bootstrap may already have executed; withhold binding, report the
-            // unconfirmed birth to its caller instead of claiming cancellation success.
-            return { ok: false, reason: "fork executed after permission withdrawal; reconcile pane manually", inherited: false };
         }
-        const att = attach({
-            sessionId: fork.sessionId,
-            jsonlPath: fork.jsonlPath,
-            target: args.target,
-            tmuxPane: r.tmuxPane,
-            tmuxSession: r.tmuxSession,
-            cwd: r.cwd,
-            pendingCwd: "",
-            model: r.model ?? model,
-            effort: r.effort ?? "",
-            keepaliveDisabled: args.keepalive === undefined ? undefined : !args.keepalive,
-        });
-        // 绑上 (或没绑上) 之后预留就没用了: 绑上的 sid 由 sidsClaimedByOthers 挡住别人。
-        inFlightSids.delete(fork.sessionId);
+        finally {
+            spawningPanes.delete(pane);
+        }
         if (!att.ok)
             return { ok: false, reason: att.reason, inherited: false };
         const spawned = byTarget.get(args.target);
@@ -5256,10 +5225,6 @@ export const startMirror = (deps) => {
             // 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) {
@@ -5489,18 +5454,40 @@ export const startMirror = (deps) => {
     };
     const paneOf = (target) => byTarget.get(target)?.tmuxPane || deps.store.get(target)?.tmuxPane || "";
     const jsonlOf = (target) => expandHome(byTarget.get(target)?.jsonlPath || deps.store.get(target)?.jsonlPath || "");
-    // Busy ≡ the pane is showing an interrupt hint. A dead or unbound pane is
+    const inputSessionInfo = (target) => {
+        const pane = paneOf(target);
+        const transcript = jsonlOf(target);
+        if (!pane || !transcript)
+            return undefined;
+        if (backendForPath(transcript).name === "codex") {
+            const session = codexSessionForPane(pane);
+            return session && { sessionId: session.sessionId, jsonlPath: session.jsonlPath };
+        }
+        const live = activeBackends().map((b) => sessionOnPane(b.homeDir, pane)).find((s) => s?.pane === pane);
+        return live && { sessionId: live.sessionId, jsonlPath: join(dirname(transcript), `${live.sessionId}.jsonl`) };
+    };
+    // Busy comes from the native lifecycle or an interrupt hint. A dead/unbound pane is
     // reported idle, not busy: "nothing is running there" is the truthful answer
     // and it keeps a graph step from blocking forever on a session that vanished.
     const paneBusy = async (pane) => !!pane && (await tmuxPaneAlive(pane)) && paneIsBusy(await capturePaneTail(pane, 12));
-    const isBusy = (target) => paneBusy(paneOf(target));
+    const isBusy = async (target) => {
+        const pane = paneOf(target);
+        return !!pane && (await tmuxPaneAlive(pane)) && (idleVerdict(target) === false || await paneBusy(pane));
+    };
     // 「它这一轮结束了、可以投了」。注册表认得这个 pane 时以它为准: status 在整轮里
     // (工具调用之间、PreToolUse 审批 hook 挂着时) 一直是 busy, 只在轮结束那一刻翻成
     // idle —— 所以不必抽样 spinner, 也不必连数几次安静来排除工具间隙。idle 却悬着工具
     // 调用 = 停在本地审批框上等人点, 不算闲。注册表不认得 (codebuddy / 旧版 CC /
     // 会话已退出) 返回 undefined, 交给 pane 裁决。
     const idleVerdict = (target) => {
+        const path = jsonlOf(target);
         const pane = paneOf(target);
+        if (path && backendForPath(path).name === "codex") {
+            const session = codexSessionForPane(pane);
+            const busy = codexTurnBusy(path, session?.jsonlPath === path ? session.startedAt : 0);
+            if (busy !== undefined)
+                return !busy;
+        }
         const live = pane ? activeBackends().map((b) => sessionOnPane(b.homeDir, pane)).find(Boolean) : undefined;
         if (!live)
             return undefined;
@@ -5523,6 +5510,9 @@ export const startMirror = (deps) => {
         return live?.status === "idle" && hanging(target, live.sessionId);
     };
     const idleNow = async (target) => {
+        // An interrupt footer vetoes stale idle records; never strip its dim text.
+        if (await isBusy(target))
+            return false;
         const registry = idleVerdict(target);
         if (registry !== undefined)
             return registry;
@@ -5530,14 +5520,24 @@ export const startMirror = (deps) => {
         if (!pane || !(await tmuxPaneAlive(pane)))
             return false;
         const { cap, box } = await readPaneInput(pane);
-        return !!cap.trim() && box.known && !paneIsBusy(cap) && !isModalPane(cap).modal;
+        if (paneIsBusy(cap) || isModalPane(cap).modal)
+            return false;
+        // 注册表说不出 (codebuddy 的注册表没有 status) 时, 转录里这一轮紧跟正文落了轮终记录
+        // (turn-metrics) 就是确定闲了, 不必再认出输入框 —— 只读屏曾把闲了 5 分钟的 owner 一直
+        // 判成不闲, 回执卡在收件箱里直到它下一轮结束。CLI 退回 shell 的 pane 照旧不算。
+        const path = jsonlOf(target);
+        if (path && turnClosed(path))
+            return !(await paneRunsShell(pane));
+        return !!cap.trim() && box.known;
     };
     // 等到它闲下来, 事件驱动: 注册表目录一有写入就重判, 翻成 idle 的那一刻即返回。
     // 兜底轮询只防 watch 漏事件 (以及悬着的审批被点掉后 status 没再动的边角)。
     const IDLE_SAFETY_POLL_MS = 1000;
     const untilIdle = (target, timeoutMs, { aborted = () => false, confirm = 2 } = {}) => {
+        // A vanished pane ends a wait, but must not become eligible for injection.
+        const waiting = async (t) => !!paneOf(t) && (await tmuxPaneAlive(paneOf(t))) && !(await idleNow(t));
         if (idleVerdict(target) === undefined)
-            return waitForIdle(target, isBusy, timeoutMs, aborted, { rampMs: 0, confirm });
+            return waitForIdle(target, waiting, timeoutMs, aborted, { rampMs: 0, confirm });
         return new Promise((resolve) => {
             let done = false;
             const finish = (r) => {
@@ -5557,8 +5557,7 @@ export const startMirror = (deps) => {
                     finish({ idle: false, reason: "stopped" });
                     return;
                 }
-                const v = idleVerdict(target);
-                if (v ?? !(await isBusy(target)))
+                if (!(await waiting(target)))
                     finish({ idle: true });
             };
             const unwatch = activeBackends().map((b) => watchRegistry(b.homeDir, () => void check()));
@@ -5569,15 +5568,15 @@ export const startMirror = (deps) => {
     };
     const lastText = (target) => {
         const p = jsonlOf(target);
-        return p ? lastAssistantText(p, 4000, pingSigs) : "";
+        return p ? lastAssistantText(p, 4000) : "";
     };
     const replySince = (target, sinceMs = 0) => {
         const p = jsonlOf(target);
-        return p ? lastReply(p, sinceMs, pingSigs) : "";
+        return p ? lastReply(p, sinceMs) : "";
     };
     const replyToPeerSince = (target, fromName, sinceMs = 0, turn) => {
         const p = jsonlOf(target);
-        return p ? replyToPeerIn(p, fromName, sinceMs, pingSigs, turn) : undefined;
+        return p ? replyToPeerIn(p, fromName, sinceMs, turn) : undefined;
     };
     /** 绑着的 pane 还能用 (存在、且不是别人的窗口) —— 不重生、不猜。 */
     const paneLiveOf = async (target) => {
@@ -5594,7 +5593,7 @@ export const startMirror = (deps) => {
     const quoteCanon = (s) => s.replace(OPEN_QUOTE_URL_RE, " ").replace(/[^\p{L}\p{N}]/gu, "");
     const openBubbleBodies = (a) => {
         if (a.briefBubble && !a.briefBubble.done && !a.briefConcluded) {
-            return [a.cotLastSent, a.cotText].filter((s) => !!s);
+            return [a.cotLastSent, a.cotText, a.cotTool].filter((s) => !!s);
         }
         const s = a.liveStream;
         return s && !s.closed && !s.dead ? [s.acc, s.lastSent] : [];
@@ -5642,9 +5641,9 @@ export const startMirror = (deps) => {
             tmuxPane: pane,
             attached: !!a,
             paneAlive,
-            busy: paneAlive ? paneIsBusy(await capturePaneTail(pane, 12)) : false,
+            busy: paneAlive ? await isBusy(t) : false,
             lastActivity,
-            summary: jsonlPath ? summarizeTail(jsonlPath, 3, 80, pingSigs) : "(未绑定会话)",
+            summary: jsonlPath ? summarizeTail(jsonlPath, 3, 80) : "(未绑定会话)",
             self: t === self,
         };
     };
@@ -5690,7 +5689,7 @@ export const startMirror = (deps) => {
     };
     // Reading a peer's conversation is a transcript job, not a terminal job: the
     // jsonl holds whole role-tagged messages, while a pane capture is ANSI-laden
-    // and clipped at the viewport edge. Text turns only, keepalive stripped. Only
+    // and clipped at the viewport edge. Text turns only. Only
     // `busy` still comes from the pane (the spinner is the one thing a transcript
     // cannot say during a long tool call); "where is it stuck" is answered by the
     // transcript too — `waiting` = tool calls still hanging on an idle session.
@@ -5701,237 +5700,16 @@ export const startMirror = (deps) => {
             return { ok: false, reason: "它还没有 transcript (没接过第一句话) —— send_peer 跟它说一句就有了", busy };
         // `n` 数的是来回: 每个来回给问话和它最新的一句 (跑完的是终句, 还在跑的是途中
         // 最近说的那句) —— 途中的其余叙述不给, 那是过程不是结论。
-        const rounds = talkRounds(jsonl, n, pingSigs).slice(-n);
+        const rounds = talkRounds(jsonl, n).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 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
-    // back to "just active" and pin it in an endless ping loop. lastRealMs stays
-    // anchored on genuine work, so the tick's realIdle guard can finally let it die.
-    const initKeepalive = (jsonlPath, mtime, pingSigs) => {
-        let lastMs = 0;
-        let lastRealMs = 0;
-        // round is seeded from the transcript too: starting at 0 would hand every
-        // daemon reload a fresh budget, and a session idle across N reloads gets
-        // N × rounds pings instead of rounds.
-        let round = 0;
-        try {
-            const s = keepaliveStamps(jsonlPath, pingSigs);
-            lastMs = s.lastMs;
-            lastRealMs = s.lastRealMs;
-            round = s.streak;
-        }
-        catch { /* unreadable tail */ }
-        return { lastMs, lastRealMs, seenMtime: mtime, pinging: false, pingMtime: 0, round, settledAt: 0, ttlSec: cacheTtlSec(jsonlPath), cacheAt: cacheTouchMs(jsonlPath) };
-    };
-    const fireKeepalive = async (a, guard) => {
-        if (!guard())
-            return;
-        const kc = cfg.wrc.mirror.keepalive;
-        // 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 = 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;
-        // it also closes the detail turn so it can't hang open in the chat timeline.
-        const r = await inject({
-            text, images: [], cfg,
-            guard,
-            requireIdle: () => idleVerdict(a.target) === true,
-            beforeInput: () => {
-                // A queued heartbeat must not mute the peer turn that won the lane.
-                // Drain its tail first, then open swallow only at permitted physical input.
-                a.tail.drain();
-                rememberInject(text);
-                a.keepaliveQuiet = setTimeout(() => {
-                    a.keepaliveQuiet = undefined;
-                    if (a.keepaliveTurnId) {
-                        recordTurnClose(a.keepaliveTurnId);
-                        a.keepaliveTurnId = undefined;
-                    }
-                }, 60_000);
-            },
-            log: log.child({ target: a.target, sessionId: a.sessionId, sub: "keepalive" }),
-            sessionId: a.sessionId, jsonlPath: a.jsonlPath, tmuxTarget: a.tmuxPane,
-        });
-        if (!r.ok) {
-            endKeepaliveSwallow(a);
-            if (a.keepalive)
-                a.keepalive.pinging = false; // roll back so the next tick can retry
-            log.warn({ target: a.target, reason: r.reason }, "keepalive: inject failed");
-            return;
-        }
-        if (!guard())
-            return;
-        const tokens = lastContextTokens(a.jsonlPath);
-        const round = a.keepalive ? (a.keepalive.round += 1) : 1;
-        log.info({ target: a.target, tokens, round, totalRounds: Math.max(1, kc.rounds) }, "keepalive: ping injected");
-        // Open a chat-detail turn for the real heartbeat exchange: userQuery is the
-        // actual ping we injected; the assistant reply (expected: just "pong"), any
-        // tool calls, and usage are grafted on from the swallowed items in onItem;
-        // 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) {
-            const turnId = newTurnId();
-            a.keepaliveTurnId = turnId;
-            recordTurnStart({ id: turnId, target: a.target, sessionId: a.sessionId, cli: cliOf(a), initialModel: a.model || undefined, initialEffort: a.effort || undefined, userQuery: text });
-        }
-    };
-    // One pool for both maintenance paths: slow panes do not stall other panes,
-    // and a keepalive never overlaps a picker scan/automatic press on the same pane.
+    // One pool for the picker sentinel's pane probes: slow panes do not stall
+    // other panes, and scans on the same pane never overlap.
     const maintenance = createKeyedScheduler(4);
     const maintenanceValid = (a, pane, sid, gen, signal) => !signal.aborted && byTarget.get(a.target) === a && a.tmuxPane === pane && a.sessionId === sid
         && (a.injectGen ?? 0) === gen && !a.migrationWatcher;
-    const keepaliveOne = async (a, pane, sid, gen, signal) => {
-        const valid = () => maintenanceValid(a, pane, sid, gen, signal) && cfg.wrc.mirror.keepalive.enabled;
-        if (!valid())
-            return;
-        const kc = cfg.wrc.mirror.keepalive;
-        const pingSigs = [normAssistant(kc.ping).slice(0, 40)].filter((s) => s.length > 0);
-        const now = Date.now();
-        if (a.keepaliveDisabled)
-            return; // sticky spawn-time opt-out — never pings
-        if (!a.tmuxPane)
-            return; // spawn-mode: no live pane to warm
-        if (a.migrationWatcher)
-            return; // session rotating — skip
-        if (a.liveStream && !a.liveStream.closed)
-            return; // mid typewriter — don't inject
-        if (!(await tmuxPaneAlive(pane)) || !valid())
-            return; // dead pane — nothing to keep alive
-        let mtime = 0;
-        try {
-            mtime = statSync(a.jsonlPath).mtimeMs;
-        }
-        catch {
-            return;
-        }
-        if (!mtime)
-            return;
-        const k = (a.keepalive ??= initKeepalive(a.jsonlPath, mtime, pingSigs));
-        // File mtime is only a cheap "did anything change → re-read the tail" gate.
-        // The clocks themselves come from message turns, so metadata churn (which
-        // bumps mtime but is not a turn) can never move them. `grewSinceLast` now
-        // means a NEW message turn appeared — not that the file grew.
-        const prevRealMs = k.lastRealMs;
-        if (mtime > k.seenMtime + 1000) {
-            const s = keepaliveStamps(a.jsonlPath, pingSigs);
-            if (s.stamped) {
-                k.lastMs = s.lastMs;
-                k.lastRealMs = s.lastRealMs;
-            }
-            else {
-                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
-        // keepalive ping+pong advances lastMs but NOT lastRealMs, so the heartbeat
-        // no longer reads as activity to itself (which was pinning round at 1/N).
-        const grewSinceLast = k.lastRealMs > prevRealMs + 1000;
-        const paneTail = await capturePaneTail(pane, 16);
-        if (!valid())
-            return;
-        const busy = paneIsBusy(paneTail);
-        if (k.pinging) {
-            // Waiting for our own ping to land and settle: until a NEWER message turn
-            // (the ping's own user line) appears and the pane goes idle, keep waiting.
-            if (busy || k.lastMs <= k.pingMtime)
-                return;
-            k.pinging = false;
-            k.settledAt = now;
-            return;
-        }
-        // A new real message turn (or a busy pane) re-anchors: reset the round
-        // counter, and past the /stop grace lift a busy-resume. grewSinceLast is
-        // message-based now, so `/stop`'s Esc settling writes (metadata, no new
-        // turn) can no longer self-resume the pause — only a busy pane past grace,
-        // or a WeCom inbound in dispatch, does.
-        // Suppress the grewSinceLast reset for 30s after pinging settles — the
-        // pong's tail flush can lag a tick and would otherwise fake real activity.
-        const justSettled = k.settledAt > 0 && now - k.settledAt < 30_000;
-        if (busy || (grewSinceLast && !justSettled)) {
-            k.round = 0;
-            k.settledAt = 0;
-            if (a.keepaliveOff && busy && now - (a.keepaliveOffAt ?? 0) > RESUME_GRACE_MS) {
-                a.keepaliveOff = false;
-                persistPause(a);
-            }
-            if (busy)
-                return;
-        }
-        if (a.keepaliveOff)
-            return; // paused by /stop until real activity returns
-        // 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)
-            return; // cache still comfortably warm
-        if (sinceCache >= ttlMs)
-            return; // cache already cold — a ping would cold-rewrite for nothing
-        if (sinceCache > KEEPALIVE_MAX_IDLE_MS)
-            return; // idle past 10min (a long-TTL entry) — not worth warming
-        if (k.round >= kc.rounds)
-            return; // budget spent — let it go cold
-        if (idleVerdict(a.target) !== true)
-            return; // no confirmed idle → no heartbeat input
-        k.pinging = true;
-        k.pingMtime = k.lastMs; // settles when a newer turn (the ping's own) appears
-        await fireKeepalive(a, () => valid() && !a.keepaliveOff);
-    };
-    const keepaliveTick = () => {
-        if (!cfg.wrc.mirror.keepalive.enabled)
-            return;
-        for (const a of byTarget.values()) {
-            if (!a.tmuxPane || a.keepaliveDisabled)
-                continue;
-            const pane = a.tmuxPane, sid = a.sessionId, gen = a.injectGen ?? 0;
-            void maintenance.schedule(`keepalive:${a.target}`, pane, (signal) => keepaliveOne(a, pane, sid, gen, signal))
-                ?.catch((e) => {
-                if (maintenanceValid(a, pane, sid, gen, maintenance.signal)) {
-                    if (a.keepalive)
-                        a.keepalive.pinging = false;
-                    endKeepaliveSwallow(a);
-                }
-                log.warn({ target: a.target, err: e.message }, "keepalive tick failed");
-            });
-        }
-    };
-    const keepaliveTimer = setInterval(() => void keepaliveTick(), 15_000);
     // ── 原生权限 picker 哨兵 ──────────────────────────────────────────────
     // CodeBuddy 对一部分调用先弹自家权限 picker、PreToolUse hook 在人点掉之后才
     // 触发 / 根本不触发 (与 AskUserQuestion 的「本地面板先行」同源; 实测命中: 子代理
@@ -6344,14 +6122,21 @@ export const startMirror = (deps) => {
             const generation = a.injectGen ?? 0;
             const permitted = () => permission() && byTarget.get(target) === a && a.sessionId === sid && (a.injectGen ?? 0) === generation;
             const probedPane = a.tmuxPane;
-            const paneAlive = a.tmuxPane ? await paneUsable(a.tmuxPane, a.jsonlPath) : false;
+            const probe = a.tmuxPane ? await probePane(a.tmuxPane, a.jsonlPath) : { state: "gone" };
             if (!permitted() || a.tmuxPane !== probedPane)
                 return denied;
+            // tmux 没给出定论 (server 卡住时 display-message 会超时): 既不能贴 (不知道往哪贴),
+            // 也不能重生 —— pane 很可能好端端的。按「稍后重发」交回去: 超时是分钟级的偶发, 重发
+            // 几乎总能落地, 而重生的代价是这个会话被整个换掉。
+            if (probe.state === "unknown") {
+                log.warn({ target, sessionId: sid, pane: a.tmuxPane }, "injectText: pane 探活无定论 (tmux 无响应), 不重生");
+                return { ok: false, retryable: true, reason: "tmux 探活无定论 (server 可能卡住), 未重生 pane, 稍后重发即可" };
+            }
             // 同 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");
+            if (probe.state !== "session") {
+                log.warn({ target, sessionId: sid, oldPane: a.tmuxPane, why: probe.state }, "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));
@@ -6383,9 +6168,9 @@ export const startMirror = (deps) => {
                 return denied;
             // Busy/queued retries must not consume notices or stamp a future turn.
             // Render only after the pane lane grants delivery, then stamp exactly at
-            // the first permitted input. activePeerTurn still changes in bindLine.
+            // the first permitted input.
             const envelope = text.trimStart().startsWith("/") ? "" : opts?.envelope ?? "";
-            let full = text + envelope;
+            let full = text + renderTail(envelope);
             const beforeInput = () => {
                 a.pendingFromCli = false;
                 a.turnFromChat = true;
@@ -6400,10 +6185,10 @@ export const startMirror = (deps) => {
             const preClearBaseline = clearing ? listJsonls(dirname(a.jsonlPath)) : undefined;
             const injectPane = a.tmuxPane;
             const r = await inject({
-                text: full, images: [], cfg, guard: (phase) => permitted() && a.tmuxPane === injectPane && (!opts?.guard || opts.guard(phase)), log: log.child({ principal: target, sessionId: sid, sub: "init-demo" }),
-                sessionId: sid, jsonlPath: a.jsonlPath, tmuxTarget: a.tmuxPane, freshSpawn: fresh,
+                text: full, images: [], cfg, guard: (phase, identity) => permitted() && a.tmuxPane === injectPane && (!opts?.guard || opts.guard(phase, identity)), log: log.child({ principal: target, sessionId: sid, sub: "init-demo" }),
+                sessionId: sid, eventId: opts?.eventId, jsonlPath: a.jsonlPath, tmuxTarget: a.tmuxPane, freshSpawn: fresh,
                 requireIdle: opts?.requireIdle ? () => idleNow(target) : undefined,
-                prepareText: () => (full = text + envelope + noticeSuffixFor(target, text)),
+                prepareText: () => (full = text + renderTail(envelope, noticeSuffixFor(target, text))),
                 beforeInput,
             });
             if (r.ok && a.tmuxPane && permitted()) {
@@ -6442,15 +6227,6 @@ export const startMirror = (deps) => {
             else if (!a.tmuxPane) {
                 return { ok: false, reason: "no live tmux pane (spawn-mode attachment)" };
             }
-            // /stop also pauses keepalive: the user is deliberately quieting this
-            // session, so stop poking it too. A real turn (WeCom inbound, or the pane
-            // going busy AFTER the resume grace) lifts the pause and re-earns the
-            // budget. Stamping keepaliveOffAt gates the busy-resume so the ping that
-            // may be mid-flight right now can't immediately self-resume.
-            a.keepaliveOff = true;
-            a.keepaliveOffAt = Date.now();
-            a.keepalive = undefined; // re-anchors cleanly on resume
-            persistPause(a); // survive a reload — don't resurrect a quieted session
             // Best-effort Esc. Every failure mode here is reported, never fatal: the
             // teardown above already gave the user their chat back.
             let escOk = false;
@@ -6504,15 +6280,22 @@ export const startMirror = (deps) => {
             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}"]);
+            const snap = await runTmux(["list-panes", "-a", "-F", "#{pane_id}\t#{session_name}\t#{window_name}\t#{pane_pid}"]);
             if (snap.code !== 0)
                 return [];
-            const bound = new Set(allTargets().map(paneOf).filter(Boolean));
+            // 「生到一半」只可能是上一个进程留下的: 本进程自己 spawn 的 pane (名字被 sweepUnborn
+            // 腾出后同名重生、或 spawnTmux 等 TUI 就绪那十几秒里还没回 pane id 的) 一律不碰 ——
+            // pane 的 shell 比本进程年轻就是本进程生的。拿不到年龄 = 认不出, 不收。
+            const ps = await psSnap();
+            const bornBeforeUs = (pid) => (ps.etimes.get(Number(pid)) ?? 0) > process.uptime();
             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))
+                .filter(([, session, win = "", pid = ""]) => session === cfg.wrc.tmuxPrefix && want.has(win) && bornBeforeUs(pid))
                 .map(([pane = ""]) => pane);
             const killed = [];
             for (const pane of doomed) {
+                // 绑定现查: 逐个收的 await 期间别人可能刚 attach 上。
+                if (spawningPanes.has(pane) || allTargets().some((t) => paneOf(t) === pane))
+                    continue;
                 // 与 killPane 同款前戏: Esc 给可能已起来的 CLI 一个收束落盘的机会。
                 await runTmux(["send-keys", "-t", pane, "Escape"]);
                 await sleep(250);
@@ -6560,7 +6343,6 @@ export const startMirror = (deps) => {
             // 找)。不看注册表的 `tmux` 字段 —— codebuddy 的注册表没有它, 那条路对 codebuddy
             // 全盲。普通 pane (人自己开的 shell / ssh / 编辑器, 会话已退回 shell 的) 树里
             // 没有注册表 pid, 一律跳过 —— 认不出就不动。
-            const bound = new Set(targets.map(paneOf).filter(Boolean));
             const regPids = new Set(activeBackends().flatMap((b) => [...liveSessionPids(b.homeDir)]));
             const ps = await psSnap();
             // 沿进程树找注册表 pid; 找到返回那个 pid (它的 etimes 供宽限判), 找不到返回 0。
@@ -6580,13 +6362,15 @@ export const startMirror = (deps) => {
                 return 0;
             };
             for (const [pane = "", , session, pid] of rows) {
-                if (session !== cfg.wrc.tmuxPrefix || bound.has(pane))
+                // 绑定现查而非用开头的快照: 前面几轮 putDown 的 await 期间别人可能刚 attach 上。
+                if (session !== cfg.wrc.tmuxPrefix || spawningPanes.has(pane) || allTargets().some((t) => paneOf(t) === pane))
                     continue;
                 const cliPid = hostedBy(Number(pid) || 0);
                 if (!cliPid)
                     continue;
                 // 宽限按 CLI 进程年龄, 不按 window_activity: TUI 重绘会让它永远「刚动过」。
-                if ((ps.etimes.get(cliPid) ?? Number.POSITIVE_INFINITY) * 1000 < ORPHAN_GRACE_MS)
+                // 拿不到年龄按刚生算 (跳过): 认不出就不收。
+                if ((ps.etimes.get(cliPid) ?? 0) * 1000 < ORPHAN_GRACE_MS)
                     continue;
                 const why = await putDown(pane);
                 if (why) {
@@ -6733,12 +6517,12 @@ export const startMirror = (deps) => {
         newSession,
         cloneSession,
         sessionInfo,
+        inputSessionInfo,
         setCharterProvider,
         onSpawn,
         onContextCut,
         shutdown: () => {
             clearInterval(paneDriftTimer);
-            clearInterval(keepaliveTimer);
             clearInterval(pickerTimer);
             maintenance.stop();
             for (const a of bySessionId.values()) {
@@ -6758,8 +6542,6 @@ export const startMirror = (deps) => {
                 return a.convFrom.asker;
             return a?.speaker ? { who: a.speaker, chat: a.channel ?? baseOfKey(target) } : undefined;
         },
-        answerContext, prepareAnswer, takeAnswer, cancelAnswerPreparation, stopAnswerProgress, deliverAnswer,
-        setAnswerSilencer: (fn) => { silenceAnswer = fn; },
         currentChannel: (target) => {
             const a = byTarget.get(target);
             return a?.channel ?? baseOfKey(target);
@@ -6786,28 +6568,16 @@ export const startMirror = (deps) => {
                 }
                 return;
             }
-            if (eventId && a.tmuxPane && await tmuxPaneAlive(a.tmuxPane) && !(await idleNow(principal))) {
-                onSubmitted?.({ ok: false, retryable: true, reason: "target became busy before opening the human turn" });
+            // 人说的普通消息不再问「你现在忙不忙」: 忙就贴进去, 顺序交给 CLI 自己的输入队列 ——
+            // 贴进运行中的一轮会由 startBriefTurn 记成 queued 轮, 等它在 transcript 里露面再 bindLine,
+            // 终句照样归到这条 event。只有 slash 命令仍旧等它闲: /clear、/model 这些要改会话状态,
+            // 落在运行中的一轮上会跟 armMigration / 原生 picker 抢 pane。(modal 那一层守卫在
+            // injectViaTmux 里照旧管着: 停在确认框上时既不贴也不吞。)
+            const slashCmd = /^\/[a-z]/i.test(text.trim());
+            if (eventId && slashCmd && a.tmuxPane && await tmuxPaneAlive(a.tmuxPane) && !(await idleNow(principal))) {
+                onSubmitted?.({ ok: false, retryable: true, reason: "target became busy before opening the slash command turn" });
                 return;
             }
-            // `/clear` resets to an empty session — nothing in the cache to keep warm,
-            // so pause keepalive like `/stop` instead of lifting it. Every other inbound
-            // is real work: lift any prior pause and re-anchor both clocks to now.
-            // Pane-side new turns re-anchor via the tick's stamps; this covers the
-            // WeCom-driven path.
-            if (isClearCommand(text)) {
-                a.keepaliveOff = true;
-                a.keepaliveOffAt = Date.now();
-                a.keepalive = undefined; // re-anchors cleanly on resume
-            }
-            else {
-                a.keepaliveOff = false;
-                if (a.keepalive) {
-                    a.keepalive.lastMs = Date.now();
-                    a.keepalive.lastRealMs = Date.now();
-                }
-            }
-            persistPause(a); // persist the pause/resume too, else a reload would revert it
             // 频道印章要早于任何开 turn 的路径 (startBriefTurn 同步消费)。
             // brief 模式下频道随这一句的印章走 (startBriefTurn); 其余路径仍是开 turn 时消费的格子。
             if (!cfg.wrc.mirror.brief || isClearCommand(text))
@@ -6822,7 +6592,7 @@ export const startMirror = (deps) => {
             const isModelSwitch = /^\/model\s+\S/.test(text.trim());
             // 任意 slash 命令 (/context, /cost, /status…): 产物走 skill_output standalone,
             // 详情链接是纯噪声 —— brief 起 turn 时不推链接。
-            const isSlash = /^\/[a-z]/i.test(text.trim());
+            const isSlash = slashCmd;
             // codebuddy 没有可用的剪贴板图片通道 (tmux 里 C-v 会被它自己的
             // syncTmuxToSystemClipboard 冲掉, 见 injectViaTmux 分流注释) —— 图片只能以
             // @<path> 文本进会话。既然如此, 问话 / 印章 / 回显去重 / 静默分叉跟随都按这个
@@ -6937,11 +6707,18 @@ export const startMirror = (deps) => {
                 // First step of the job and the historical hang point — log BEFORE the
                 // probe so a stall is attributable to it next time, not invisible.
                 log.info({ target: a.target, sessionId: sid, pane: a.tmuxPane, gen: myGen }, "inject job start");
-                const paneAlive = a.tmuxPane ? await paneUsable(a.tmuxPane, a.jsonlPath) : false;
+                const probe = a.tmuxPane ? await probePane(a.tmuxPane, a.jsonlPath) : { state: "gone" };
                 let freshSpawn = a.justSpawned === true;
                 a.justSpawned = false;
-                if (!paneAlive) {
-                    log.warn({ target: a.target, sessionId: sid, oldPane: a.tmuxPane, oldSession: a.tmuxSession }, "mirror: no live tmux pane, respawning");
+                // tmux 没给出定论: 不重生 (同 injectText)。turn 已经开了头 (气泡可能已挂), 所以
+                // 报一个可重试的失败让调用方收口 —— 比换掉整个会话温和得多。
+                if (probe.state === "unknown") {
+                    log.warn({ target: a.target, sessionId: sid, pane: a.tmuxPane }, "mirror: pane 探活无定论 (tmux 无响应), 不重生");
+                    onSubmitted?.({ ok: false, retryable: true, reason: "tmux 探活无定论 (server 可能卡住), 未重生 pane" });
+                    return;
+                }
+                if (probe.state !== "session") {
+                    log.warn({ target: a.target, sessionId: sid, oldPane: a.tmuxPane, oldSession: a.tmuxSession, why: probe.state }, "mirror: no live tmux pane, respawning");
                     // Interactive `claude --resume <sid>` does NOT keep appending to the
                     // same <sid>.jsonl — it FORKS to a fresh <newSid>.jsonl seeded with a
                     // copy of the transcript. Our tail stays bound to the OLD, now-frozen
@@ -7015,16 +6792,25 @@ export const startMirror = (deps) => {
                 // 用户行有 isOwnInject 过滤 —— 提前解除不会泄漏脏数据。
                 a.muteUntilInject = false;
                 const injectPane = a.tmuxPane;
+                // 人话不再等 pane 闲 (§人话直入): `requireIdle` 在这一层只剩一个作用 —— 必须有 pane,
+                // 不许退化成 spawn-mode (`--resume -p`) 的无窗口注入。忙闲交给 CLI 自己的输入队列:
+                // 贴进运行中的一轮会被记成 queued 轮, 等它在 transcript 露面再接上这条 event。
+                // slash 命令要等闲, 那一道在上面 (dispatch 开头) 已经拦过了。
                 const r = await inject({
                     text: effText, images: effImages, cfg, log: log.child({ principal, sessionId: sid }),
-                    sessionId: sid, jsonlPath: a.jsonlPath, tmuxTarget: a.tmuxPane, freshSpawn,
-                    requireIdle: eventId ? () => idleNow(a.target) : undefined,
-                    guard: (phase) => byTarget.get(a.target) === a && a.tmuxPane === injectPane && (a.injectGen ?? 0) === myGen && (!guard || guard(phase)),
+                    sessionId: sid, eventId, jsonlPath: a.jsonlPath, tmuxTarget: a.tmuxPane, freshSpawn,
+                    requireIdle: eventId ? () => true : undefined,
+                    guard: (phase, identity) => byTarget.get(a.target) === a && a.tmuxPane === injectPane && (a.injectGen ?? 0) === myGen && (!guard || guard(phase, identity)),
                 });
                 onSubmitted?.(r);
                 if (!r.ok) {
+                    // retryable = 一个字都没进输入框, 消息事件层会稍后重投 —— 不是失败, 别报 ✗
+                    // (每次退避重试都会走到这里, 报 ✗ 就是一串假警报)。
+                    const note = r.retryable && eventId
+                        ? `[mirror] ⏳ 暂未送达, 稍后自动重投 (${r.reason ?? "deferred"})`
+                        : `[mirror] ✗ ${r.reason ?? "failed"}`;
                     if (s) {
-                        s.acc = s.acc ? `${s.acc}\n\n[mirror] ✗ ${r.reason ?? "failed"}` : `[mirror] ✗ ${r.reason ?? "failed"}`;
+                        s.acc = s.acc ? `${s.acc}\n\n${note}` : note;
                         await finalizeStream(a, s);
                     }
                     else if (armMigration) {
@@ -7042,7 +6828,7 @@ export const startMirror = (deps) => {
                         if (a.outbound?.kind === "deferred")
                             clearTimeout(a.outbound.timer);
                         a.outbound = undefined;
-                        sendStandalone(a, `[mirror] ✗ ${r.reason ?? "failed"}`);
+                        sendStandalone(a, note);
                     }
                     return;
                 }