wezard 2.7.1 → 2.7.3

package/dist/daemon/mirror-bridge.js

@@ -38,7 +38,7 @@ 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, sessionOfPid, sessionOnPane, submittedSince, submittedEventSince, watchRegistry } from "./wezard-session.js";
+import { hasRegistry, liveSessionPids, markTranscript, probeOf, registrySnapshot, 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";
@@ -1288,9 +1288,6 @@ const BOX_PROMPT_RE = /^\s*[❯>]\s?/u;
 const BOX_FOOTER_ROWS = 6;
 const UNKNOWN_BOX = { known: false, body: "" };
 export const parseInputBox = (cap, styledLayout = cap) => {
-    const lines = cap.split("\n");
-    while (lines.length && lines[lines.length - 1].trim() === "")
-        lines.pop();
     // Codex has no rulers. Anchor the composer to its bottom shortcuts footer,
     // then use the LAST › prompt: earlier prompts belong to the transcript.
     // Requiring a status row and a blank separator avoids treating arbitrary
@@ -1301,36 +1298,47 @@ export const parseInputBox = (cap, styledLayout = cap) => {
     while (layout.length && !layout[layout.length - 1].trim())
         layout.pop();
     const footer = layout.length - 1;
-    // Codex hides the shortcuts row while the composer contains text.
-    const shortcuts = /(?:^|\s)\? for shortcuts(?:\s|$)/u.test(layout[footer] ?? "");
-    if (shortcuts || (layout[footer] ?? "").includes("·")) {
-        let status = shortcuts ? footer - 1 : footer;
+    // A populated Codex composer replaces shortcuts with "tab to queue message"
+    // and may have no background SGR. Its footer still anchors the editable box;
+    // missing it sends collapsed pastes through the 15s late-landing window.
+    const inputHint = /(?:^|\s)(?:\? for shortcuts|tab to queue message)(?:\s|$)/u.test(layout[footer] ?? "");
+    // Idle Codex hides the left hint after a paste but keeps a right-aligned
+    // warnings footer. Its middle dot is not the status row's separator.
+    const warnings = /^\s*⚠\s*\d+\s+warnings?\s*·\s*f2 to view\s*$/u.test(layout[footer] ?? "");
+    if (inputHint || warnings || (layout[footer] ?? "").includes("·")) {
+        let status = inputHint || warnings ? footer - 1 : footer;
         while (status >= 0 && !layout[status].trim())
             status--;
         if (status >= 0 && footer - status <= BOX_FOOTER_ROWS && layout[status].includes("·") && status > 0 && !layout[status - 1].trim()) {
             let prompt = status - 2;
-            // Continuation rows are indented; a › inside pasted content is not a
-            // new composer prompt.
-            while (prompt >= 0 && !/^›(?:\s|$)/u.test(layout[prompt]))
+            // Only contiguous, indented continuation rows belong to this composer.
+            // Crossing a blank/output row can otherwise select a historical user
+            // prompt (which may carry the same background SGR as the live box).
+            while (prompt >= 0 && /^\s{2,}\S/u.test(layout[prompt]))
                 prompt--;
-            if (prompt >= 0 && (shortcuts || /\x1b\[[0-9;:]*48[;:]/u.test(styledLines[prompt]))) {
+            if (prompt >= 0 && /^›(?:\s|$)/u.test(layout[prompt])
+                && (prompt === 0 || !layout[prompt - 1].trim())
+                && (inputHint || /\x1b\[[0-9;:]*48[;:]/u.test(styledLines[prompt]))) {
                 const body = dropDim(styledLines.slice(prompt, status).join("\n"))
                     .replace(/^\s*›\s?/u, "").replace(/[\s\u200b\ufeff]+/gu, " ").trim();
                 return { known: true, body };
             }
         }
     }
-    const rulers = lines.reduce((acc, l, i) => (BOX_RULER_RE.test(l) ? [...acc, i] : acc), []);
+    // Dim is presentation, not layout: removing it before locating rulers also
+    // removes dim borders/prompts, leaving collapsed pastes unverifiable.
+    const rulers = layout.reduce((acc, l, i) => (BOX_RULER_RE.test(l) ? [...acc, i] : acc), []);
     const bottom = rulers[rulers.length - 1];
     const top = rulers[rulers.length - 2];
     if (top === undefined || bottom === undefined || bottom - top < 1)
         return UNKNOWN_BOX;
-    if (lines.length - bottom > BOX_FOOTER_ROWS)
+    if (layout.length - bottom > BOX_FOOTER_ROWS)
         return UNKNOWN_BOX;
-    const rows = lines.slice(top + 1, bottom);
+    const rows = layout.slice(top + 1, bottom);
     if (!rows.length || !BOX_PROMPT_RE.test(rows[0]))
         return UNKNOWN_BOX;
-    const body = [rows[0].replace(BOX_PROMPT_RE, ""), ...rows.slice(1)].join("\n").replace(/[\s\u200b\ufeff]+/gu, " ").trim();
+    const body = dropDim(styledLines.slice(top + 1, bottom).join("\n"))
+        .replace(BOX_PROMPT_RE, "").replace(/[\s\u200b\ufeff]+/gu, " ").trim();
     return { known: true, body };
 };
 // CodeBuddy 忙时回车不落盘: 那句挂进输入框上方的待发队列, 一条一行
@@ -1438,8 +1446,12 @@ const paneHasLiveSession = async (paneId, homeDir, panePid, ps) => {
     const root = panePid ?? (await panePidOf(paneId));
     if (!root)
         return false;
-    const { kids } = ps ?? (await psSnap());
-    return registeredPidUnder(root, liveSessionPids(homeDir), kids) !== undefined;
+    const snapshot = ps ?? (await psSnap());
+    // Codex runs under a foreground bash wrapper and has no Claude registry.
+    const codexPids = codexSessionForPane(paneId)
+        ? [...snapshot.commands].filter(([, command]) => basename(command) === "codex").map(([pid]) => pid)
+        : [];
+    return registeredPidUnder(root, new Set([...liveSessionPids(homeDir), ...codexPids]), snapshot.kids) !== undefined;
 };
 /** 注入前问 pane 一句话: 还在吗 / 里面还有 AI 会话吗。
  *  `unknown` 必须由调用方按「不知道」处理 —— 不许当 pane 死了去重生。 */
@@ -1456,6 +1468,19 @@ const probePane = async (paneId, jsonlPath) => {
         return { state: "unknown" };
     return SHELL_RE.test(cmd.stdout.trim()) ? { state: "shell" } : { state: "session" };
 };
+// Recover only an exact SessionStart transcript match; a shared cwd is not identity.
+const codexPaneForTranscript = async (jsonlPath) => {
+    if (backendForPath(jsonlPath).name !== "codex")
+        return "";
+    const panes = await runTmux(["list-panes", "-a", "-F", "#{pane_id}"]);
+    if (!panes.ok)
+        return "";
+    for (const pane of panes.stdout.trim().split("\n")) {
+        if (codexSessionForPane(pane)?.jsonlPath === jsonlPath && (await probePane(pane, jsonlPath)).state === "session")
+            return pane;
+    }
+    return "";
+};
 /** 注册表没有 tmux 字段的后端 (codebuddy): pane 里住着谁只能沿 pane 的进程树往下找
  *  注册表登记过、还活着的 pid。冷 pane 的注册行晚于进程出生, `waitMs` 内轮询。 */
 const hostPidOnPane = async (target, homeDir, waitMs) => {
@@ -1532,7 +1557,7 @@ const witnessFor = (target, homeDir, jsonlPath, live, actualTranscript) => {
 // 整块为判据, 粘贴只在「确凿看见框仍是空的」时才重来。
 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)");
+    log.info({ target, eventId, len: text.length, images: images.length, freshSpawn, backendName }, "mirror inject (tmux)");
     // 就绪门: pane 里得真有一个进入了交互态的 AI 会话, 才轮得到贴。先于 modal guard ——
     // 这一步只读注册表, 会话都不在时也就不必去 capture pane 找对话框了。
     const gate = await awaitSession(target, backend.homeDir, freshSpawn, log);
@@ -1638,7 +1663,7 @@ 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, boundGuard, eventId);
+        return injectViaTmuxText(target, withImageRefs(text, images), log, freshSpawn, witness, boundGuard, eventId, bypassModalGuard);
     }
     // 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
@@ -1690,7 +1715,7 @@ const injectViaTmux = async (target, text, images, log, freshSpawn, backend, jso
         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, boundGuard, eventId);
+    return injectViaTmuxText(target, text, log, freshSpawn, witness, boundGuard, eventId, bypassModalGuard);
 };
 // 图片以 @<path> 文本提及的形式进会话 (codebuddy 的 tmux 路径、一切 spawn 路径)。
 // 提升为共享 helper: dispatch 侧的印章 / 回显去重 / turn 记录必须拿到与 inject
@@ -1712,7 +1737,7 @@ const withImageRefs = (text, images) => {
 // 证人不作声 (忙时排队、slash 命令、无注册表的后端) 才看框回没回到贴之前的样子。
 // 框认得出来时这条判据可信, 于是允许多补回车 (空框上的回车在 CLI 里是 no-op);
 // 每次补之前再问一遍证人, 已提交就不补。
-const injectViaTmuxText = async (target, text, log, freshSpawn, witness = NO_WITNESS, guard, eventId) => {
+const injectViaTmuxText = async (target, text, log, freshSpawn, witness = NO_WITNESS, guard, eventId, bypassModalGuard = false) => {
     // 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
@@ -1740,8 +1765,16 @@ 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 = () => requireEventEvidence
-        ? witness.submittedEvent(eventId, since) : witness.submitted(probe, since, enterAt);
+    let confirmed = false;
+    const submitted = () => {
+        const yes = requireEventEvidence
+            ? witness.submittedEvent(eventId, since) : witness.submitted(probe, since, enterAt);
+        if (yes && !confirmed) {
+            confirmed = true;
+            log.info({ target, eventId, enterToEvidenceMs: Number.isFinite(enterAt) ? Date.now() - enterAt : undefined }, "mirror inject: submission confirmed");
+        }
+        return yes;
+    };
     // 贴之前框里是什么: 空框、幽灵提示 (`Try "how do I log an error?"`)、甚至用户
     // 自己敲了一半的字 —— 一律作为基线, 免得去维护一张「哪些文案算空」的清单。
     const pre = await readPaneInput(target);
@@ -1755,9 +1788,23 @@ const injectViaTmuxText = async (target, text, log, freshSpawn, witness = NO_WIT
     const alreadyTyped = boxVerify && Boolean(probe) && stripWs(preBox.body).includes(probe);
     // 提交后框该回到的样子: 正常是贴之前的基线; 文本本就在框里时基线就是它, 只能以「空」为准。
     const baseBody = alreadyTyped ? "" : preBox.body;
+    let landedBody = alreadyTyped ? preBox.body : undefined;
     /** 框里还是贴之前那样 (或彻底空了) = 我们的文本不在框里。 */
     const boxIntact = (b) => boxVerify && b.known && (b.body === "" || b.body === baseBody);
-    const loadAndPaste = () => pasteTmuxBuffer(target, text, guard ? () => guard("paste") : undefined);
+    const loadAndPaste = async () => {
+        const start = Date.now();
+        const result = await pasteTmuxBuffer(target, text, guard ? () => guard("paste") : undefined);
+        log.info({ target, eventId, tmuxPasteMs: Date.now() - start, boxVerify, ok: result.ok }, "mirror inject: paste completed");
+        return result;
+    };
+    const landed = (cap, box) => {
+        const seen = box.known ? (boxVerify ? !boxIntact(box) : box.body !== "") : Boolean(headFp) && stripWs(cap).includes(headFp);
+        // Bind recovery to the first observed paste, not arbitrary contents found
+        // after settling: another writer may have replaced the draft meanwhile.
+        if (seen && box.known && landedBody === undefined)
+            landedBody = box.body;
+        return seen;
+    };
     // 框认得出来 → 看它变没变; 认不出来 → 退回宽窗口找 headFp (长文本会换行,
     // 头部可能在框顶, 所以窗口要宽)。
     const sawLanded = async (timeoutMs) => {
@@ -1766,7 +1813,7 @@ const injectViaTmuxText = async (target, text, log, freshSpawn, witness = NO_WIT
             const { cap, box } = await readPaneInput(target);
             // A redraw can hide the baseline. Once the composer reappears, its
             // nonempty body also proves landing of a collapsed paste.
-            if (box.known ? (boxVerify ? !boxIntact(box) : box.body !== "") : Boolean(headFp) && stripWs(cap).includes(headFp))
+            if (landed(cap, box))
                 return true;
             await sleep(POLL_MS);
         }
@@ -1778,7 +1825,7 @@ const injectViaTmuxText = async (target, text, log, freshSpawn, witness = NO_WIT
         if (submitted())
             return "submitted";
         const { cap, box } = await readPaneInput(target);
-        if (box.known ? (boxVerify ? !boxIntact(box) : box.body !== "") : Boolean(headFp) && stripWs(cap).includes(headFp))
+        if (landed(cap, box))
             return "landed";
         if (Date.now() - t0 >= timeoutMs)
             return box.known ? "intact" : "unknown";
@@ -1878,8 +1925,26 @@ const injectViaTmuxText = async (target, text, log, freshSpawn, witness = NO_WIT
             await sleep(Math.max(0, POST_PASTE_SETTLE_FALLBACK_MS - (Date.now() - pastedAt)));
     }
     const sendEnter = async () => {
+        // A picker can open after the pre-paste gate, especially during a delayed
+        // render. Check again before every Enter; askq text entry keeps its bypass.
+        if (process.env.WEZARD_MODAL_GUARD !== "0" && !bypassModalGuard) {
+            const modal = await detectModalPicker(target);
+            if (modal.modal || !modal.screen.trim())
+                return { ok: false, reason: "native picker or unreadable pane before submission; refusing Enter" };
+        }
+        if (submitted())
+            return { ok: true };
+        if (landedBody !== undefined) {
+            const box = await readInputBox(target);
+            if (!box.known || box.body !== landedBody)
+                return { ok: false, reason: "composer changed after paste verification; refusing Enter" };
+        }
         if (guard && !guard("submit"))
             return { ok: false, reason: "submit canceled by dispatch guard" };
+        if (tailFp && !Number.isFinite(enterAt)) {
+            enterAt = Date.now();
+            log.info({ target, eventId, pasteToEnterMs: enterAt - pastedAt, pasteSeen, boxTrusted, freshSpawn }, "mirror inject: first Enter");
+        }
         const e = await runTmux(["send-keys", "-t", target, "Enter"]);
         return e.ok ? { ok: true } : { ok: false, reason: `tmux send-keys failed: ${e.stderr.slice(-200)}` };
     };
@@ -1906,6 +1971,21 @@ const injectViaTmuxText = async (target, text, log, freshSpawn, witness = NO_WIT
         }
         return false;
     };
+    /** 回车后的证据也是会迟到的 —— 粘贴有迟到窗, 提交同样要有。
+     *  CodeBuddy 的 user 行按「接受输入的时刻」打时间戳、却要等 TUI 把这一轮消化完才落盘: 忙时
+     *  能晚好几秒 (2026-10-14 h687c3a5 实测: 标记 23:06:50.834 写进转录, 但 CLEARED_TIMEOUT_MS 的
+     *  1.5s 窗内读不到, 于是判成「框空了却没有这一笔」, 往群里发了一条 ✗ —— 消息其实到了, 还被并进
+     *  同一秒另一条注入的提交里)。判据是「宽限到 LATE_LAND_MS 仍没有」, 不是「1.5s 内还没看到」。 */
+    const lateEvidence = async (timeoutMs, t0 = Date.now()) => {
+        if (submitted())
+            return true;
+        if (await queued())
+            return true;
+        if (Date.now() - t0 >= timeoutMs)
+            return false;
+        await sleep(LATE_POLL_MS);
+        return lateEvidence(timeoutMs, t0);
+    };
     if (!pasteSeen)
         log.warn({ target }, "mirror inject: paste unverified, requiring session submission evidence");
     if (!tailFp) {
@@ -1915,36 +1995,52 @@ const injectViaTmuxText = async (target, text, log, freshSpawn, witness = NO_WIT
     }
     // 回车可能被冷启动中的 TUI 吞掉 (框里躺着没提交的提示)。框认得出来时判据可信,
     // 多补一次; 认不出来时维持原来的「只补一次」, 免得判据出错往真实对话里灌回车。
-    const boxTrusted = boxVerify && (await readInputBox(target)).known;
-    const attempts = requireEventEvidence ? 1 : boxTrusted ? 3 : 2;
+    const pendingBox = await readInputBox(target);
+    const boxTrusted = boxVerify && pendingBox.known;
+    // An event may retry Enter only while the very same landed composer remains.
+    // Empty/unknown/changed boxes need transcript evidence, never another paste
+    // or a blind Enter that could confirm a newly opened native picker.
+    const pendingBody = pasteSeen && pendingBox.known && pendingBox.body === landedBody
+        ? landedBody : undefined;
+    const attempts = requireEventEvidence ? pendingBody ? 3 : 1 : boxTrusted ? 3 : 2;
     for (let i = 0; i < attempts; i++) {
         if (i > 0) {
             await sleep(RETRY_SETTLE_MS);
             if (submitted())
                 return { ok: true }; // 迟到的确认 —— 补的这一下会落在空框上, 省了
+            if (requireEventEvidence) {
+                const box = await readInputBox(target);
+                if (!box.known || box.body !== pendingBody)
+                    break;
+            }
             log.warn({ target, tailFp, attempt: i + 1 }, "mirror inject: 回车后输入框未清空, 再补一次");
         }
-        if (i === 0) {
-            enterAt = Date.now();
-            log.info({ target, pasteToEnterMs: enterAt - pastedAt, pasteSeen, boxTrusted, freshSpawn }, "mirror inject: first Enter");
-        }
         const e = await sendEnter();
         if (!e.ok)
             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 (requireEventEvidence && await cleared()) {
+            if (await lateEvidence(LATE_LAND_MS))
+                return { ok: true };
+            // 宽限用完仍没有这一笔的证据才是真不确定 —— 这条会以 `[mirror] ✗` 的面目出现在
+            // 问话的那个群里, 所以留一行日志, 免得事后只剩群里那句话可查。
+            log.warn({ target, eventId, freshSpawn, boxTrusted, witness: witness.status }, "mirror inject: 框空了且转录里始终没有这一笔, 判不确定并停止重贴");
+            return { ok: false, uncertain: true, reason: "composer cleared without this event's transcript marker; delivery remains uncertain and will not be resubmitted" };
+        }
     }
     if (submitted() || await queued())
         return { ok: true };
-    if (requireEventEvidence && await cleared())
+    if (requireEventEvidence && await cleared()) {
+        if (await lateEvidence(LATE_LAND_MS))
+            return { ok: true };
+        log.warn({ target, eventId, freshSpawn, boxTrusted, witness: witness.status }, "mirror inject: 框空了且转录里始终没有这一笔, 判不确定并停止重贴");
         return { ok: false, uncertain: true, reason: "composer cleared without this event's transcript marker; delivery remains uncertain and will not be resubmitted" };
-    // 补到头还没清空。通常是渲染滞后 (回车其实落了), 但也可能是目标会话正忙 /
-    // 上下文满了不消费输入 —— 那样用户这条消息会悄无声息地消失。不报硬失败 (用户
-    // 多半已经被服务到了), 标 uncertain 让调用方按需提示。
-    log.warn({ target, tailFp, freshSpawn, boxTrusted, witness: witness.status }, "mirror inject: clear not observed, trusting submit");
-    return { ok: true, uncertain: true, reason: "目标会话可能正忙或未消费输入(回车后输入框未清空)" };
+    }
+    // 补到头仍没证据: 可能只是渲染/落盘迟到, 也可能根本没提交。
+    // 保留 uncertain 阻止重贴, 但不能让只看 ok 的调用方把它当成已送达。
+    log.warn({ target, tailFp, freshSpawn, boxTrusted, witness: witness.status }, "mirror inject: submission unconfirmed, stopping input");
+    return { ok: false, uncertain: true, reason: "目标会话未确认收下消息，停止输入以避免误提交或重复投递" };
 };
 const injectViaSpawn = async (args) => {
     const { text, images = [], cfg, log, sessionId, jsonlPath } = args;
@@ -2103,17 +2199,19 @@ const etimeSec = (s) => {
     return ((d * 24 + h) * 60 + mi) * 60 + se;
 };
 const psSnap = () => new Promise((resolve) => {
-    const p = spawn("ps", ["-axo", "pid=,ppid=,etime="], { env: { ...process.env, PATH: augmentedPath(process.env.PATH) }, stdio: ["ignore", "pipe", "ignore"] });
+    const p = spawn("ps", ["-axo", "pid=,ppid=,etime=,comm="], { 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();
+        const commands = new Map();
         for (const line of out.split("\n")) {
-            const [pidS = "", ppidS = "", etS = ""] = line.trim().split(/\s+/);
+            const [pidS = "", ppidS = "", etS = "", ...command] = line.trim().split(/\s+/);
             const pid = Number(pidS), ppid = Number(ppidS), et = etimeSec(etS);
             if (!pid || !ppid)
                 continue;
+            commands.set(pid, command.join(" "));
             const arr = kids.get(ppid);
             if (arr)
                 arr.push(pid);
@@ -2122,10 +2220,10 @@ const psSnap = () => new Promise((resolve) => {
             if (!Number.isNaN(et))
                 etimes.set(pid, et);
         }
-        resolve({ kids, etimes });
+        resolve({ kids, etimes, commands });
     };
     p.on("close", done);
-    p.on("error", () => resolve({ kids: new Map(), etimes: new Map() }));
+    p.on("error", () => resolve({ kids: new Map(), etimes: new Map(), commands: new Map() }));
 });
 /** Drop a session's queue chain. A hung job can't be cancelled (it's parked in a
  *  tmux read), but detaching the chain means the NEXT message doesn't inherit
@@ -2267,6 +2365,7 @@ export const startMirror = (deps) => {
     };
     const TOOL_DETAIL_PREFIX = "TOOL_DETAIL|";
     let eventFinalGate = () => true;
+    let eventHandedAway = () => false;
     const newTurnId = () => `t${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
     const newMarkId = () => `m${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
     const detailCardFor = (s, target) => {
@@ -2868,6 +2967,62 @@ export const startMirror = (deps) => {
         return p;
     };
     const finishBriefBubble = (a, content, raw = false) => finishBubble(a, a.briefBubble, content, raw);
+    // ── transfer 的气泡移交 ───────────────────────────────────────────────
+    // 人问的那一笔 transfer 出去, 气泡 (那句人话的 frame/streamId) 跟着行走: 从交出方这一轮摘下,
+    // 按接手方的注入事件 id 寄存, 接手方开出那一轮时 (ensureBriefTurn) 接过去 —— CoT 进度与终句
+    // 续写同一颗气泡, 不另开新的。寄存只在内存: reload 后丢了就退回 standalone, 与过期同。
+    const handedBubbles = new Map();
+    const writeBubble = (b, content, finish) => (b.pending = (b.pending ?? Promise.resolve()).catch(() => undefined)
+        .then(() => client.replyStream(b.frame, b.streamId, content, finish))
+        .catch((e) => log.warn({ err: e.message, finish }, "transfer: handed bubble write failed")));
+    /** 6min 窗口的兜底收口按气泡自己的到期点算 (它从人那句话起算, 不因转手重置)。 */
+    const untilExpiry = (b) => Math.max(0, (b.expires ?? Date.now()) - Date.now());
+    const handBubble = (source, serves, eventId, target) => {
+        const a = byTarget.get(source);
+        const b = a?.briefBubble;
+        const turnId = a?.briefTurnId;
+        // 只交「这一轮正服务着那一笔」的气泡: 别的轮的气泡与这次移交无关。
+        if (!a || !b || b.done || !turnId || !a.activeEventId || deps.events?.get(a.activeEventId)?.serves !== serves)
+            return false;
+        clearTimeout(b.hardTimer);
+        a.briefBubble = undefined;
+        clearCot(a);
+        const channel = a.channel || undefined;
+        const line = (rest) => headed(chatHead(target, chatTurnUrl(target, turnId), undefined, channel), rest) || "…";
+        void writeBubble(b, line("…"), false);
+        const held = { bubble: b };
+        // 接手方迟迟不开轮 (在忙 / 被并进别的轮): 到期前收口成「仍在处理中」, 终句届时走 standalone。
+        if (!isWxFrame(b.frame))
+            held.timer = setTimeout(() => {
+                if (handedBubbles.get(eventId) !== held)
+                    return;
+                handedBubbles.delete(eventId);
+                b.done = true;
+                void writeBubble(b, line(STILL_WORKING), true);
+            }, untilExpiry(b));
+        handedBubbles.set(eventId, held);
+        log.info({ source, target, serves, eventId, turnId }, "transfer: bubble handed to new owner");
+        return true;
+    };
+    /** 接手方这一轮 (`a.activeEventId`) 若有寄存的气泡: 接成本轮气泡, 头换成它自己的链接。 */
+    const adoptBubble = (a, turnId) => {
+        const held = a.activeEventId ? handedBubbles.get(a.activeEventId) : undefined;
+        if (!held)
+            return undefined;
+        handedBubbles.delete(a.activeEventId);
+        clearTimeout(held.timer);
+        const b = held.bubble;
+        if (b.done || untilExpiry(b) === 0)
+            return undefined;
+        if (!isWxFrame(b.frame))
+            b.hardTimer = setTimeout(() => {
+                const live = a.briefBubble === b && !a.briefConcluded;
+                void finishBubble(a, b, briefLine(a, turnId, live ? STILL_WORKING : ""), true);
+            }, untilExpiry(b));
+        void writeBubble(b, briefLine(a, turnId, "…"), false);
+        log.info({ sessionId: a.sessionId, turnId, eventId: a.activeEventId }, "transfer: handed bubble adopted");
+        return b;
+    };
     // 让一个已建好记录的 turn 成为活跃 turn。turn 级状态在这里统一归零 —— 唯一入口。
     const openBriefTurn = (a, q) => {
         a.briefTurnId = q.turnId;
@@ -3187,12 +3342,15 @@ export const startMirror = (deps) => {
         a.briefTurnId = turnId;
         if (a.activeEventId)
             deps.events?.bind(a.activeEventId, turnId);
-        a.briefBubble = undefined;
         a.briefIsSlash = false;
         a.briefHadTool = false;
         a.briefConcluded = false;
         a.briefLastText = undefined;
         clearCot(a);
+        // transfer 接过来的那一笔: 续写人那句话的气泡 —— 这一轮就是在答群里的人。
+        a.briefBubble = adoptBubble(a, turnId);
+        if (a.briefBubble)
+            a.turnFromChat = true;
         // 详情链接不在这里单独发 — 本轮的每条 standalone 都由 withLinkedTag 自带
         // (chatTurnUrl 读的正是 a.briefTurnId)。静默轮没有 standalone 可搭车, 那就
         // 一条都不发: 群里只该出现有正文的消息, 纯入口提示是噪音。
@@ -3238,7 +3396,10 @@ export const startMirror = (deps) => {
         if (event)
             deps.events.result(event.id, body, finalId(event.id, event.channel, body), turnId);
         const gated = !!event && !eventFinalGate(event);
-        if (!turnSilent(a) && !gated) {
+        // 那一笔已交出: 交代归接手方, 这句只留 rolepage —— 不进气泡 (已移交) 也不 standalone。
+        if (event && eventHandedAway(event))
+            log.info({ sessionId: a.sessionId, turnId, event: event.id }, "brief: final of a transferred-away row kept off chat");
+        else if (!turnSilent(a) && !gated) {
             if (event)
                 recoverEventFinal(deps.events.get(event.id), a.briefBubble);
             else
@@ -4227,7 +4388,7 @@ export const startMirror = (deps) => {
         // jsonl means "no input yet", NOT "rotated away" — healing it onto some
         // unrelated newest-in-cwd file is exactly the cross-wire we must avoid.
         const storedPane = (rec.tmuxPane ?? "").trim();
-        const livePane = storedPane && (panes ? panes.has(storedPane) : await tmuxPaneAlive(storedPane)) ? storedPane : "";
+        const livePane = storedPane && (panes ? panes.has(storedPane) : await tmuxPaneAlive(storedPane)) ? storedPane : await codexPaneForTranscript(jsonlAbs);
         if (permitted && !permitted())
             return undefined;
         if (!existsSync(jsonlAbs)) {
@@ -5254,7 +5415,8 @@ export const startMirror = (deps) => {
             model: a?.model || rec?.model || "",
             effort: a?.effort || rec?.effort || "",
             tmuxPane: a?.tmuxPane ?? rec?.tmuxPane ?? "",
-            contextTokens: lastContextTokens(jsonlPath),
+            // 惰性: 读 transcript 尾巴 (64K 起, 最多 2MB), 只要 pane / sid 的调用方 (调度器每秒逐行问) 不该替它付。
+            get contextTokens() { return lastContextTokens(jsonlPath); },
         };
     };
     const getCwd = (target) => {
@@ -5463,7 +5625,8 @@ export const startMirror = (deps) => {
             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);
+        // 只喂调度器 (message-events 的 transcript / sessionId 适配器): 每秒逐行问, 走目录快照。
+        const live = activeBackends().map((b) => sessionOnPane(b.homeDir, pane, registrySnapshot)).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
@@ -6116,11 +6279,20 @@ export const startMirror = (deps) => {
             const a = byTarget.get(target) ?? (await restoreFromStore(target, undefined, permission));
             if (!permission())
                 return denied;
+            // 恢复已经试过了: store 里连绑定都没有 (被 stop / kill 收掉, 或 transcript 没了被 drop) =
+            // 收方真不在了, 报 gone 让上层改投; 还有绑定只是这次 attach 没成, 照旧稍后重试。
             if (!a)
-                return { ok: false, retryable: true, reason: "no mirror attached for target" };
+                return { ok: false, retryable: true, reason: "no mirror attached for target", ...(deps.store.get(target) ? {} : { gone: true }) };
             const sid = a.sessionId;
             const generation = a.injectGen ?? 0;
             const permitted = () => permission() && byTarget.get(target) === a && a.sessionId === sid && (a.injectGen ?? 0) === generation;
+            if (!a.tmuxPane) {
+                const recovered = await codexPaneForTranscript(a.jsonlPath);
+                if (!permitted())
+                    return denied;
+                if (!a.tmuxPane)
+                    a.tmuxPane = recovered;
+            }
             const probedPane = a.tmuxPane;
             const probe = a.tmuxPane ? await probePane(a.tmuxPane, a.jsonlPath) : { state: "gone" };
             if (!permitted() || a.tmuxPane !== probedPane)
@@ -6549,6 +6721,8 @@ export const startMirror = (deps) => {
         formatFinal,
         recoverEventFinal,
         setEventFinalGate: (gate) => { eventFinalGate = gate; },
+        setEventHandedAway: (away) => { eventHandedAway = away; },
+        handBubble,
         settleFinalProgress,
         dispatch: async ({ principal, text, images, frame, streamId, channel, speaker, eventId, guard, onSubmitted }) => {
             // Route by inbound principal — the WeCom chat the user just messaged us
@@ -6707,6 +6881,15 @@ 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");
+                if (!a.tmuxPane) {
+                    const recovered = await codexPaneForTranscript(a.jsonlPath);
+                    if (byTarget.get(a.target) !== a || (a.injectGen ?? 0) !== myGen || (guard && !guard())) {
+                        onSubmitted?.({ ok: false, retryable: true, reason: "pane recovery permission withdrawn" });
+                        return;
+                    }
+                    if (!a.tmuxPane)
+                        a.tmuxPane = recovered;
+                }
                 const probe = a.tmuxPane ? await probePane(a.tmuxPane, a.jsonlPath) : { state: "gone" };
                 let freshSpawn = a.justSpawned === true;
                 a.justSpawned = false;
@@ -6760,7 +6943,16 @@ export const startMirror = (deps) => {
                     else {
                         // Drop only the stale pane id; keep tmuxSession (if any) so the
                         // store still reflects "user wanted tmux" — next turn retries.
-                        log.error({ reason: r.reason }, "mirror: tmux respawn failed, this turn falls back to spawn-mode");
+                        log.error({ reason: r.reason }, "mirror: tmux respawn failed");
+                        if (eventId) {
+                            onSubmitted?.({ ok: false, retryable: true, reason: `respawn failed: ${r.reason ?? "unknown"}` });
+                            if (s)
+                                await finalizeStream(a, s);
+                            if (a.outbound?.kind === "deferred")
+                                clearTimeout(a.outbound.timer);
+                            a.outbound = undefined;
+                            return;
+                        }
                         a.tmuxPane = "";
                     }
                 }
@@ -6806,9 +6998,15 @@ export const startMirror = (deps) => {
                 if (!r.ok) {
                     // retryable = 一个字都没进输入框, 消息事件层会稍后重投 —— 不是失败, 别报 ✗
                     // (每次退避重试都会走到这里, 报 ✗ 就是一串假警报)。
-                    const note = r.retryable && eventId
-                        ? `[mirror] ⏳ 暂未送达, 稍后自动重投 (${r.reason ?? "deferred"})`
-                        : `[mirror] ✗ ${r.reason ?? "failed"}`;
+                    if (r.retryable && eventId) {
+                        if (s)
+                            await finalizeStream(a, s);
+                        if (a.outbound?.kind === "deferred")
+                            clearTimeout(a.outbound.timer);
+                        a.outbound = undefined;
+                        return;
+                    }
+                    const note = `[mirror] ✗ ${r.reason ?? "failed"}`;
                     if (s) {
                         s.acc = s.acc ? `${s.acc}\n\n${note}` : note;
                         await finalizeStream(a, s);