wezard 2.0.0 → 2.0.2

package/dist/daemon/mirror-bridge.js

@@ -25,6 +25,7 @@ import { isAutoWindowActive } from "./session-cache.js";
 import { noticeSuffixFor } from "./notices.js";
 import { dangerOf } from "./danger.js";
 import { runTmux, spawnTmuxClaude } from "./spawn-tmux.js";
+import { hasRegistry, markTranscript, probeOf, sessionOnPane, submittedSince } from "./cc-session.js";
 import { wizardStore } from "./wizard.js";
 import { startSubagentWatch } from "./subagent-tail.js";
 import { recordTool, recordToolResult, recordMark, recordTurnStart, recordTurnItem, recordTurnUsage, recordTurnClose, recordCloseOpenTurns, buildDetailUrl, buildChatUrl } from "./detail.js";
@@ -33,7 +34,7 @@ import { splitMarkdown } from "../shared/md-chunk.js";
 import { randomTip } from "./tips.js";
 import { chatBaseOf, chatNameOf, listChatNames, parsePeerRef, peerAddress } from "./chat-name.js";
 import { stripAnsi, compactPane, paneIsBusy, paneIsStalled, transcriptStalled, summarizeTail, lastAssistantText, lastContextTokens, keepaliveStamps, tailTurns, renderDialog } from "./peers.js";
-// Same PATH augmentation logic as cc-bridge: launchd / systemd start the daemon
+// PATH augmentation: launchd / systemd start the daemon
 // with a stripped PATH that often lacks nvm / homebrew, breaking spawn(claudeBin).
 // Backend resolution is per-transcript, not global: `backendForPath` recovers
 // which CLI wrote a jsonl from its projects root, so claude / claude-internal /
@@ -44,7 +45,7 @@ import { stripAnsi, compactPane, paneIsBusy, paneIsStalled, transcriptStalled, s
 // jsonl line carries a `cwd` field; the encoded directory name is lossy (both
 // `/` and `.` collapse to `-`) so it can't be reversed — reading the file is
 // the only faithful path. Used as the middle tier in attach()'s cwd resolution
-// so /wrc-attached sessions reflect their real project in /pwd, /clear, /new,
+// so sessions attached without an explicit cwd (switch / restore) reflect their real project in /pwd, /clear, /new,
 // instead of falling back to the global cfg.wrc.cwd.
 const readCwdFromJsonl = (path) => {
     try {
@@ -1172,12 +1173,80 @@ export const parseInputBox = (cap) => {
 };
 // 24 行足够容纳展开后的多行粘贴 (折叠态只占一行)。
 const readInputBox = async (target) => parseInputBox(await capturePaneTail(target, 24));
+// ── 注入门控的会话证人 (cc-session) ─────────────────────────────────
+// 能从会话自己写的 json 读到的判据, 就不读 pane: 就绪看注册表的 status, 提交看
+// 注册表的 busy 翻转或 jsonl 里新落的那一行。输入框里「贴进去没有」是唯一只有
+// pane 知道的事 (未提交的输入不落任何盘), 那一段仍旧 capture。
+const SHELL_RE = /^-?(zsh|bash|sh|fish|dash|ksh|tcsh|csh)$/;
+/** pane 前台是个 shell = 里面的 AI 会话已经退出 (或从没起来)。只读 tmux 元数据, 不读屏。 */
+const paneRunsShell = async (target) => {
+    const r = await runTmux(["display-message", "-p", "-t", target, "#{pane_current_command}"]);
+    return r.ok && SHELL_RE.test(r.stdout.trim());
+};
+/** pane 活着且里面住着 AI 会话。注册表认得它就是; 不认得时只在前台确是 shell 才判否 ——
+ *  注册表缺席 (codebuddy / 旧版 CC / 进程不在 tmux 里记的行) 不能被当成会话不在。 */
+const paneHostsSession = async (target, homeDir) => !hasRegistry(homeDir) || sessionOnPane(homeDir, target) !== undefined || !(await paneRunsShell(target));
+const SESSION_READY_TIMEOUT_MS = 15_000;
+/** 冷 pane 等注册表报 idle (会话建好、输入框等人); 热 pane 只核一次会话还在 —— 忙也照贴,
+ *  CC 会把它排进队列。等不到 idle 不算失败 (贴后校验会兜), 前台退回 shell 才算:
+ *  往 shell 里贴 = 把用户的话当命令执行。 */
+const awaitSession = async (target, homeDir, fresh, log) => {
+    if (!hasRegistry(homeDir))
+        return { ok: true };
+    const deadline = Date.now() + (fresh ? SESSION_READY_TIMEOUT_MS : 0);
+    const poll = async () => {
+        const s = sessionOnPane(homeDir, target);
+        if ((s && (!fresh || s.status === "idle")) || Date.now() >= deadline)
+            return s;
+        await sleep(200);
+        return poll();
+    };
+    const live = await poll();
+    if (live) {
+        if (fresh && live.status !== "idle")
+            log.warn({ target, status: live.status }, "mirror inject: 会话未报 idle, 按贴后校验兜底继续");
+        return { ok: true, live };
+    }
+    if (await paneRunsShell(target)) {
+        log.warn({ target }, "mirror inject: pane 前台是 shell, AI 会话不在, 拒绝注入");
+        return { ok: false, reason: "目标 pane 里的 AI 会话已退出 (前台是 shell), 消息未送达。重发即会在新 pane 里恢复该会话。" };
+    }
+    return { ok: true };
+};
+const NO_WITNESS = { status: "", submitted: () => false };
+/** 贴之前给会话可能落盘的 jsonl 打书签: 绑定的那份, 加上注册表报的当前 sid 那份
+ *  (resume / fork 会换 sid)。提交后 sid 若又变了, 新文件从 0 读 —— 时间门挡掉 fork 里的旧话。 */
+const witnessFor = (target, homeDir, jsonlPath, live) => {
+    if (!live)
+        return NO_WITNESS;
+    const dir = dirname(jsonlPath);
+    const marks = new Map([jsonlPath, join(dir, `${live.sessionId}.jsonl`)].map((p) => [p, markTranscript(p)]));
+    return {
+        status: live.status,
+        submitted: (probe, since, enterAt) => {
+            const now = sessionOnPane(homeDir, target);
+            if (now && live.status !== "busy" && now.status === "busy" && now.statusUpdatedAt >= enterAt)
+                return true;
+            const p = now && join(dir, `${now.sessionId}.jsonl`);
+            if (p && !marks.has(p))
+                marks.set(p, { path: p, offset: 0 });
+            return submittedSince([...marks.values()], probe, since);
+        },
+    };
+};
 // Self-verifying inject. The cold-spawn race we guard against: paste lands
 // but the trailing Enter is eaten while the TUI is still initializing, so
 // the prompt sits typed-but-unsent. 校验策略见 injectViaTmuxText —— 以输入框
 // 整块为判据, 粘贴只在「确凿看见框仍是空的」时才重来。
-const injectViaTmux = async (target, text, images, log, freshSpawn, backendName, bypassModalGuard = false) => {
+const injectViaTmux = async (target, text, images, log, freshSpawn, backend, jsonlPath, bypassModalGuard = false) => {
+    const backendName = backend.name;
     log.info({ target, len: text.length, images: images.length, freshSpawn, backendName }, "mirror inject (tmux)");
+    // 就绪门: pane 里得真有一个进入了交互态的 AI 会话, 才轮得到贴。先于 modal guard ——
+    // 这一步只读注册表, 会话都不在时也就不必去 capture pane 找对话框了。
+    const gate = await awaitSession(target, backend.homeDir, freshSpawn, log);
+    if (!gate.ok)
+        return gate;
+    const witness = witnessFor(target, backend.homeDir, jsonlPath, gate.live);
     // Never type into a modal picker (see detectModalPicker). Checked before the
     // image pump too — a C-v into a picker is just as destructive as a paste.
     // 必须在按后端分流之前: 每个后端都有自己的原生确认框, 往任何一个里打字都会
@@ -1210,7 +1279,7 @@ const injectViaTmux = async (target, text, images, log, freshSpawn, backendName,
     if (backendName === "codebuddy") {
         const refs = images.map((p) => `@${p}`);
         const textWithRefs = refs.length ? (text ? `${refs.join("\n")}\n${text}` : refs.join("\n")) : text;
-        return injectViaTmuxText(target, textWithRefs, log, freshSpawn);
+        return injectViaTmuxText(target, textWithRefs, log, freshSpawn, witness);
     }
     // Pump images first via clipboard+C-v so each one is attached as a separate
     // image content block. Each C-v needs a brief settle for Claude Code's TUI
@@ -1236,18 +1305,22 @@ const injectViaTmux = async (target, text, images, log, freshSpawn, backendName,
         const e = await runTmux(["send-keys", "-t", target, "Enter"]);
         return e.ok ? { ok: true } : { ok: false, reason: `tmux send-keys Enter failed: ${e.stderr.slice(-200)}` };
     }
-    return injectViaTmuxText(target, text, log, freshSpawn);
+    return injectViaTmuxText(target, text, log, freshSpawn, witness);
 };
 // 文本 paste + Enter 提交 + 自校验。从 injectViaTmux 抽出来，让 codebuddy
 // 后端的 @<path> 回退路径也能复用同样的 paste-verify 逻辑。
 //
-// 两个判据都以**输入框整块**为准 (parseInputBox), 指纹只是认不出布局时的退路:
-//   1. 贴完轮询「框变了」→ 粘贴已被 TUI 消化 (折叠成占位符也算)。这是个**正**
-//      信号, 只有确凿看见框仍是贴之前的样子才重贴 —— 存疑一律不重贴, 多贴一次
-//      的代价 (两份提示叠进同一个输入框) 远高于少贴一次。
-//   2. 回车后轮询「框回到贴之前的样子」→ 提交被吃下了。框认得出来时这条判据可
-//      信, 于是允许多补一次回车 (空框上的回车在 CLI 里是 no-op)。
-const injectViaTmuxText = async (target, text, log, freshSpawn) => {
+// 贴 —— 只有 pane 知道 (未提交的输入不落任何盘), 以**输入框整块**为准 (parseInputBox),
+// 指纹只是认不出布局时的退路:
+//   1. 框里已经躺着这段文本 (上一次注入回车被吞 / 被 watchdog 掐断) → 不再贴第二份, 直接提交。
+//   2. 贴完轮询「框变了」→ 粘贴已被 TUI 消化 (折叠成占位符也算)。这是个**正**信号,
+//      只有确凿看见框仍是贴之前的样子、且会话也没收到这段话, 才重贴 —— 存疑一律不重贴,
+//      多贴一次的代价 (两份提示叠进同一个输入框) 远高于少贴一次。
+// 交 —— 先问会话证人 (注册表 busy 翻转 / jsonl 新落的提交行), 确认了就完事, 不碰 pane;
+// 证人不作声 (忙时排队、slash 命令、无注册表的后端) 才看框回没回到贴之前的样子。
+// 框认得出来时这条判据可信, 于是允许多补回车 (空框上的回车在 CLI 里是 no-op);
+// 每次补之前再问一遍证人, 已提交就不补。
+const injectViaTmuxText = async (target, text, log, freshSpawn, witness = NO_WITNESS) => {
     // Warm pane: tight timings, low latency. Fresh spawn (claude --resume just
     // started, transcript still loading): extended timings — bracketed-paste
     // end can take 4-7s to be honored on a cold TUI. Only the fresh-spawn path
@@ -1257,17 +1330,30 @@ const injectViaTmuxText = async (target, text, log, freshSpawn) => {
     const POST_PASTE_SETTLE_FALLBACK_MS = freshSpawn ? 2500 : 700;
     const CLEARED_TIMEOUT_MS = freshSpawn ? 4000 : 1500;
     const RETRY_SETTLE_MS = freshSpawn ? 1500 : 800;
+    // 回车后先只问证人这么久: CC 提交即落盘, 通常 <200ms。证人注定不作声的场合
+    // (会话正忙 → 只是排队; slash 命令 → 不一定落 user 行) 不空等, 直接看框。
+    const witnessQuiet = witness.status === "" || witness.status === "busy" || text.trimStart().startsWith("/");
+    const WITNESS_ONLY_MS = witnessQuiet ? 0 : freshSpawn ? 2500 : 1000;
     const { headFp, tailFp } = fingerprints(text);
+    const probe = probeOf(text);
     const POLL_MS = 100;
     const stripWs = (s) => s.replace(/\s+/gu, "");
+    // 时间门往前放 1s: jsonl 的 timestamp 与本机时钟同源, 只差写盘的毫秒。
+    const since = Date.now() - 1000;
+    let enterAt = Number.POSITIVE_INFINITY;
+    const submitted = () => witness.submitted(probe, since, enterAt);
     // 贴之前框里是什么: 空框、幽灵提示 (`Try "how do I log an error?"`)、甚至用户
     // 自己敲了一半的字 —— 一律作为基线, 免得去维护一张「哪些文案算空」的清单。
     const preBox = await readInputBox(target);
     // 基线读不出来 (框被模态顶掉 / 正在重绘) 就整条退回指纹法: 没有基线,「框变了」
     // 无从谈起, 而把幽灵提示 (`Try "…"`) 误当成「贴进去了」会让这条消息静静消失。
     const boxVerify = preBox.known;
+    // 去重: 框里已经是这段文本 —— 上一次注入贴上了却没交出去。再贴就是两份。
+    const alreadyTyped = boxVerify && Boolean(probe) && stripWs(preBox.body).includes(probe);
+    // 提交后框该回到的样子: 正常是贴之前的基线; 文本本就在框里时基线就是它, 只能以「空」为准。
+    const baseBody = alreadyTyped ? "" : preBox.body;
     /** 框里还是贴之前那样 (或彻底空了) = 我们的文本不在框里。 */
-    const boxIntact = (b) => boxVerify && b.known && (b.body === "" || b.body === preBox.body);
+    const boxIntact = (b) => boxVerify && b.known && (b.body === "" || b.body === baseBody);
     const loadAndPaste = async () => {
         // stdin variant of the shared exec path — it carries the same hard timeout,
         // which a hand-rolled spawn here did not.
@@ -1279,9 +1365,6 @@ const injectViaTmuxText = async (target, text, log, freshSpawn) => {
             return { ok: false, reason: `tmux paste-buffer failed: ${pasted.stderr.slice(-200)}` };
         return { ok: true };
     };
-    let r = await loadAndPaste();
-    if (!r.ok)
-        return r;
     // 框认得出来 → 看它变没变; 认不出来 → 退回宽窗口找 headFp (长文本会换行,
     // 头部可能在框顶, 所以窗口要宽)。
     const sawLanded = async (timeoutMs) => {
@@ -1301,10 +1384,24 @@ const injectViaTmuxText = async (target, text, log, freshSpawn) => {
         const pane = await capturePaneTail(target, 5);
         return Boolean(tailFp) && stripWs(pane).includes(tailFp);
     };
-    let pasteSeen = await sawLanded(PASTE_VERIFY_MS);
+    let pasteSeen = alreadyTyped;
+    if (alreadyTyped) {
+        log.warn({ target, headFp }, "mirror inject: 输入框里已有这段文本 (上次未提交) — 不重贴, 直接提交");
+    }
+    else {
+        const r = await loadAndPaste();
+        if (!r.ok)
+            return r;
+        pasteSeen = await sawLanded(PASTE_VERIFY_MS);
+    }
     if (!pasteSeen) {
         const box = await readInputBox(target);
         const empty = boxVerify && box.known ? boxIntact(box) : !(await inputBoxStillHasTail());
+        if (submitted()) {
+            // 框看着空, 是因为粘贴连同某次回车一起被收下了 —— 再贴就是第二份。
+            log.info({ target }, "mirror inject: 会话已收到这段文本, 不重贴");
+            return { ok: true };
+        }
         if (!empty) {
             log.warn({ target, headFp, boxKnown: box.known }, "mirror inject: 粘贴未验证但输入框非空 — 首次粘贴已落地, 不重贴");
             pasteSeen = true;
@@ -1312,7 +1409,9 @@ const injectViaTmuxText = async (target, text, log, freshSpawn) => {
         else {
             log.warn({ target, headFp, boxKnown: box.known }, "mirror inject: 输入框确认为空, 重贴一次");
             await sleep(RETRY_SETTLE_MS);
-            r = await loadAndPaste();
+            if (submitted())
+                return { ok: true };
+            const r = await loadAndPaste();
             if (!r.ok)
                 return r;
             pasteSeen = await sawLanded(PASTE_VERIFY_MS);
@@ -1320,7 +1419,8 @@ const injectViaTmuxText = async (target, text, log, freshSpawn) => {
     }
     // Bracketed-paste end + TUI catch-up. Warm pane: 400ms is invisible.
     // Fresh respawn: 1500ms+ — claude --resume is still loading the transcript.
-    await sleep(pasteSeen ? POST_PASTE_SETTLE_MS : POST_PASTE_SETTLE_FALLBACK_MS);
+    if (!alreadyTyped)
+        await sleep(pasteSeen ? POST_PASTE_SETTLE_MS : POST_PASTE_SETTLE_FALLBACK_MS);
     const sendEnter = async () => {
         const e = await runTmux(["send-keys", "-t", target, "Enter"]);
         return e.ok ? { ok: true } : { ok: false, reason: `tmux send-keys failed: ${e.stderr.slice(-200)}` };
@@ -1329,11 +1429,15 @@ const injectViaTmuxText = async (target, text, log, freshSpawn) => {
         const box = await readInputBox(target);
         return boxVerify && box.known ? boxIntact(box) : !(await inputBoxStillHasTail());
     };
-    const waitForCleared = async (timeoutMs) => {
+    /** 证人先答; 它的窗口过了还不作声, 才每轮加看一眼框。 */
+    const waitForSubmit = async (timeoutMs) => {
         const t0 = Date.now();
-        while (Date.now() - t0 < timeoutMs) {
+        const budget = Math.max(timeoutMs, WITNESS_ONLY_MS + 500);
+        while (Date.now() - t0 < budget) {
             await sleep(POLL_MS);
-            if (await cleared())
+            if (submitted())
+                return true;
+            if (Date.now() - t0 >= WITNESS_ONLY_MS && (await cleared()))
                 return true;
         }
         return false;
@@ -1351,19 +1455,25 @@ const injectViaTmuxText = async (target, text, log, freshSpawn) => {
     const attempts = boxTrusted ? 3 : 2;
     for (let i = 0; i < attempts; i++) {
         if (i > 0) {
-            log.warn({ target, tailFp, attempt: i + 1 }, "mirror inject: 回车后输入框未清空, 再补一次");
             await sleep(RETRY_SETTLE_MS);
+            if (submitted())
+                return { ok: true }; // 迟到的确认 —— 补的这一下会落在空框上, 省了
+            log.warn({ target, tailFp, attempt: i + 1 }, "mirror inject: 回车后输入框未清空, 再补一次");
         }
+        if (i === 0)
+            enterAt = Date.now();
         const e = await sendEnter();
         if (!e.ok)
             return e;
-        if (await waitForCleared(CLEARED_TIMEOUT_MS))
+        if (await waitForSubmit(CLEARED_TIMEOUT_MS))
             return { ok: true };
     }
+    if (submitted())
+        return { ok: true };
     // 补到头还没清空。通常是渲染滞后 (回车其实落了), 但也可能是目标会话正忙 /
     // 上下文满了不消费输入 —— 那样用户这条消息会悄无声息地消失。不报硬失败 (用户
     // 多半已经被服务到了), 标 uncertain 让调用方按需提示。
-    log.warn({ target, tailFp, freshSpawn, boxTrusted }, "mirror inject: clear not observed, trusting submit");
+    log.warn({ target, tailFp, freshSpawn, boxTrusted, witness: witness.status }, "mirror inject: clear not observed, trusting submit");
     return { ok: true, uncertain: true, reason: "目标会话可能正忙或未消费输入(回车后输入框未清空)" };
 };
 const injectViaSpawn = (args) => {
@@ -1418,8 +1528,7 @@ const inject = (args) => {
     const target = (args.tmuxTarget ?? "").trim();
     if (!target)
         return injectViaSpawn(args);
-    const backendName = backendForPath(args.jsonlPath).name;
-    return injectViaTmux(target, args.text, args.images ?? [], args.log, args.freshSpawn ?? false, backendName, args.bypassModalGuard ?? false);
+    return injectViaTmux(target, args.text, args.images ?? [], args.log, args.freshSpawn ?? false, backendForPath(args.jsonlPath), args.jsonlPath, args.bypassModalGuard ?? false);
 };
 const queues = new Map();
 /** Ceiling for one whole inject job (respawn + paste + submit verification).
@@ -3103,7 +3212,7 @@ export const startMirror = (deps) => {
         // missing file (existsSync gate at start, try/catch in drain) and the 1s
         // poll picks it up the moment claude writes the first line.
         // Replace any existing attach with the same sessionId or same target. The
-        // sessionId clash is the "/wrc again from same window" case; the target
+        // sessionId clash is the "same session attached again" case; the target
         // clash is "different window steals my WeCom chat" — both end the previous.
         // Guard: if a DIFFERENT principal already owns this sessionId, refuse rather
         // than detaching it — prevents cross-wire when concurrent restoreFromStore
@@ -3137,7 +3246,7 @@ export const startMirror = (deps) => {
             tmuxPane: (tmuxPane ?? "").trim(),
             tmuxSession: (tmuxSession ?? "").trim(),
             // Explicit cwd (spawn path) wins; otherwise derive from jsonl head so
-            // /wrc attaches inherit the bound session's real project dir instead of
+            // cwd-less attaches inherit the bound session's real project dir instead of
             // collapsing to cfg.wrc.cwd (which would mislabel /pwd, /clear, /new).
             runningCwd: expandHome(((cwd ?? "").trim()) || readCwdFromJsonl(jsonlPath) || cfg.wrc.cwd),
             pendingCwd: carryPending,
@@ -3196,13 +3305,17 @@ export const startMirror = (deps) => {
     // Verify a paneId still exists. `display-message -t <paneId>` succeeds iff
     // the pane is alive — and tmux pane ids monotonically increment within a
     // server lifetime, so a freed id will not be silently reused. We don't need
-    // the session name, which matters because /wrc attaches capture only $TMUX_PANE.
+    // the session name, which matters because some attaches carry only a pane id.
     const tmuxPaneAlive = async (paneId) => {
         if (!paneId)
             return false;
         const r = await runTmux(["display-message", "-p", "-t", paneId, "#{pane_id}"]);
         return r.code === 0 && r.stdout.trim() === paneId;
     };
+    // 注入前的存活判定要多问一句「里面还有 AI 会话吗」: pane 在、claude 却退回了 shell,
+    // 照旧往里贴就是把用户的话当 shell 命令跑。判否即走 respawn (旧 pane 不杀 —— 它可能是
+    // 用户自己的终端, 经 switch 绑进来的)。
+    const paneUsable = async (paneId, jsonlPath) => (await tmuxPaneAlive(paneId)) && (await paneHostsSession(paneId, backendForPath(jsonlPath).homeDir));
     // Re-attach a stored binding for `principal`. Returns the resulting state, or
     // undefined if the on-disk transcript is gone (in which case the entry is
     // dropped so the next inbound flows through /new auto-spawn).
@@ -3379,7 +3492,7 @@ export const startMirror = (deps) => {
         }
     }
     else {
-        log.info("mirror: no persisted attachments and no pinned sessionId — waiting for /new or /mirror/attach");
+        log.info("mirror: no persisted attachments and no pinned sessionId — waiting for the first inbound or /new");
     }
     // Render full tool details for a finalized turn into one-or-more markdown
     // chunks (split at chunkBytes boundaries).
@@ -3910,6 +4023,9 @@ export const startMirror = (deps) => {
     // 由 index.ts 在启动时装上 (注册表活在那边); 没装 = 退回无身份行为, 全链路无回归。
     let charterOf;
     const setCharterProvider = (fn) => { charterOf = fn; };
+    // 新 pane 落地后的钩子 —— pane 上限在这里数 (由 index.ts 装上; 没装 = 不数)。
+    let afterSpawn = () => { };
+    const onSpawn = (fn) => { afterSpawn = fn; };
     // `cwd` = 这个 pane 正要启动的目录。attach 在 spawn 之后才发生, 所以此刻 getCwd
     // 给的还是上一个 pane 的目录 —— 换目录重开时照它渲染, 新 wizard 会以为自己还在
     // 旧工作区里。
@@ -3993,7 +4109,7 @@ export const startMirror = (deps) => {
         if (spawned) {
             spawned.justSpawned = true;
             spawned.muteUntilInject = true;
-            // 只有换过 pane 才是断点 —— 首次 /wrc 建会话时 prev 为空, 那不是"不连续", 是开局。
+            // 只有换过 pane 才是断点 —— 首次建会话时 prev 为空, 那不是"不连续", 是开局。
             if (prev)
                 markCut(target, spawned.sessionId, "new");
             // A freshly spawned session is empty — nothing in the cache to keep warm.
@@ -4030,6 +4146,7 @@ export const startMirror = (deps) => {
         }
         if (!opts?.silent)
             pushProjectInfo(target, "created");
+        afterSpawn();
         return { ok: true, sessionId: r.sessionId, cwd: r.cwd, model: r.model, modelWarning: r.modelWarning };
     };
     // ── Clone ───────────────────────────────────────────────────────────
@@ -4140,6 +4257,7 @@ export const startMirror = (deps) => {
             persistPause(spawned);
         }
         lg.info({ parent: args.parent, sessionId: fork.sessionId }, "clone: forked");
+        afterSpawn();
         return { ok: true, sessionId: fork.sessionId, cwd: r.cwd, inherited: true, model: r.model, modelWarning: r.modelWarning };
     };
     /** 一个会话此刻的硬事实 —— whoami / 交接判断要用的那几个数。 */
@@ -4988,7 +5106,7 @@ export const startMirror = (deps) => {
             if (opts?.channel)
                 a.turnFromChat = true;
             const sid = a.sessionId;
-            const paneAlive = a.tmuxPane ? await tmuxPaneAlive(a.tmuxPane) : false;
+            const paneAlive = a.tmuxPane ? await paneUsable(a.tmuxPane, a.jsonlPath) : false;
             if (!paneAlive) {
                 log.warn({ target, sessionId: sid, oldPane: a.tmuxPane }, "injectText: pane not alive, respawning");
                 // Same resume-fork hazard as dispatch: snapshot before spawn, re-bind
@@ -5096,45 +5214,64 @@ export const startMirror = (deps) => {
             log.info({ target, sessionId: a?.sessionId, pane }, "mirror /kill — pane killed, binding dropped");
             return { ok: true };
         },
-        reapIdle: async (ttlMs, skip) => {
+        lastActivity: (target) => {
+            const jsonl = jsonlOf(target);
+            try {
+                return jsonl ? statSync(jsonl).mtimeMs : 0;
+            }
+            catch {
+                return 0;
+            }
+        },
+        reapOverflow: async (max, skip) => {
             const now = Date.now();
             const reaped = [];
             const skipped = {};
-            for (const target of allTargets()) {
-                const a = byTarget.get(target);
-                const sessionId = a?.sessionId || deps.store.get(target)?.sessionId || "";
-                // 便宜闸门先行: transcript mtime 一次 statSync, 不 spawn —— 跑了几个
-                // 月的机器上 allTargets 是几百个 key, 见 target 就问 tmux 会打穿 fd
-                // (同 worldPeers 的 WORLD_PROBE 取舍)。还没写过 transcript 的 spawn-mode
-                // 绑定没有活动证据, 不动它。
-                const jsonl = jsonlOf(target);
-                let mtime = 0;
+            // 一次 list-panes 同时回答「活着吗」和「有人盯着吗」—— 跑了几个月的机器上
+            // allTargets 是几百个 key, 见 target 就问 tmux 会打穿 fd (同 worldPeers 的
+            // WORLD_PROBE 取舍)。
+            const snap = await runTmux(["list-panes", "-a", "-F", "#{pane_id}\t#{window_active}:#{session_attached}"]);
+            if (snap.code !== 0)
+                return { reaped, skipped };
+            const watchedBy = new Map(snap.stdout.split("\n").filter(Boolean).map((l) => {
+                const [id, w = ""] = l.split("\t");
+                const [wActive, sAttached] = w.split(":");
+                return [id, wActive === "1" && sAttached !== "0"];
+            }));
+            const live = allTargets().filter((t) => watchedBy.has(paneOf(t)));
+            let over = live.length - max;
+            if (over <= 0)
+                return { reaped, skipped };
+            // 超了才 stat: 最久没动的先收。还没写过 transcript 的是刚起的 pane, 按"此刻"算。
+            const mtimeOf = (target) => {
                 try {
-                    if (jsonl)
-                        mtime = statSync(jsonl).mtimeMs;
+                    return statSync(jsonlOf(target)).mtimeMs;
                 }
-                catch { /* 文件没了 */ }
-                if (!mtime || now - mtime < ttlMs)
-                    continue;
+                catch {
+                    return now;
+                }
+            };
+            const oldestFirst = live.map((target) => ({ target, mtime: mtimeOf(target) })).sort((x, y) => x.mtime - y.mtime);
+            for (const { target, mtime } of oldestFirst) {
+                if (over <= 0)
+                    break;
+                const a = byTarget.get(target);
+                const sessionId = a?.sessionId || deps.store.get(target)?.sessionId || "";
                 const veto = skip?.(target, sessionId);
                 if (veto) {
                     skipped[target] = veto;
                     continue;
                 }
                 const pane = paneOf(target);
-                if (!pane || !(await tmuxPaneAlive(pane)))
-                    continue; // pane 已死, 没什么可收的
-                if (paneIsBusy(await capturePaneTail(pane, 12))) {
-                    skipped[target] = "busy";
-                    continue;
-                }
                 // 人正盯着这个 window —— 收掉他的视野比省下那点内存更讨嫌。
-                const w = await runTmux(["display-message", "-p", "-t", pane, "#{window_active}:#{session_attached}"]);
-                const [wActive, sAttached] = w.stdout.trim().split(":");
-                if (wActive === "1" && sAttached !== "0") {
+                if (watchedBy.get(pane)) {
                     skipped[target] = "watched";
                     continue;
                 }
+                if (paneIsBusy(await capturePaneTail(pane, 12))) {
+                    skipped[target] = "busy";
+                    continue;
+                }
                 // 与 killPane 同款前戏: Esc 给生成中的 CLI 一个收束落盘的机会。
                 await runTmux(["send-keys", "-t", pane, "Escape"]);
                 await sleep(250);
@@ -5144,10 +5281,11 @@ export const startMirror = (deps) => {
                     continue;
                 }
                 if (a)
-                    detach(a, "idle reap");
+                    detach(a, "pane cap");
                 // 不碰 store —— 绑定留着, 下一条 inbound 走 dead-pane `--resume` 复活。
                 reaped.push(target);
-                log.info({ target, sessionId, pane, idleHours: Math.round((now - mtime) / 3.6e6) }, "mirror idle reap — pane killed, binding kept");
+                over -= 1;
+                log.info({ target, sessionId, pane, idleHours: Math.round((now - mtime) / 3.6e6), max }, "mirror pane cap — pane killed, binding kept");
             }
             return { reaped, skipped };
         },
@@ -5238,6 +5376,7 @@ export const startMirror = (deps) => {
         cloneSession,
         sessionInfo,
         setCharterProvider,
+        onSpawn,
         shutdown: () => {
             clearInterval(paneDriftTimer);
             clearInterval(keepaliveTimer);
@@ -5268,7 +5407,7 @@ export const startMirror = (deps) => {
                 a = await restoreFromStore(principal);
             if (!a) {
                 try {
-                    await client.replyStream(frame, streamId, withTagHeader(principal, "[wezard] wecom remote control not attached — run `/wrc` inside the target Claude session"), true);
+                    await client.replyStream(frame, streamId, withTagHeader(principal, "[wezard] 本聊天还没有会话 — 发 `/new` 开一个"), true);
                 }
                 catch {
                     /* ignore */
@@ -5400,7 +5539,7 @@ export const startMirror = (deps) => {
                     return; // (eager path) superseded by a newer dispatch
                 // Always reincarnate when no live pane: covers (a) pane closed between
                 // turns, (b) daemon reload restored a binding without a live pane, AND
-                // (c) /wrc'd from a non-tmux context (no tmuxSession ever stored) —
+                // (c) a binding made from a non-tmux context (no tmuxSession ever stored) —
                 // that last case used to permanently lock the chat into spawn-mode.
                 // If respawn fails, fall through to spawn-mode inject for THIS turn
                 // but DON'T erase tmuxSession from store — next inbound will retry,
@@ -5408,7 +5547,7 @@ export const startMirror = (deps) => {
                 // First step of the job and the historical hang point — log BEFORE the
                 // probe so a stall is attributable to it next time, not invisible.
                 log.info({ target: a.target, sessionId: sid, pane: a.tmuxPane, gen: myGen }, "inject job start");
-                const paneAlive = a.tmuxPane ? await tmuxPaneAlive(a.tmuxPane) : false;
+                const paneAlive = a.tmuxPane ? await paneUsable(a.tmuxPane, a.jsonlPath) : false;
                 let freshSpawn = a.justSpawned === true;
                 a.justSpawned = false;
                 if (!paneAlive) {