wezard 2.3.0 → 2.4.1

package/dist/daemon/mirror-bridge.js

@@ -38,7 +38,7 @@ import { labelFor, tagOfKey, baseOfKey, keyOf, stripSigil, displayName, withTagH
 import { splitMarkdown } from "../shared/md-chunk.js";
 import { randomTip } from "./tips.js";
 import { chatBaseOf, chatNameOf, listChatNames, parsePeerRef, peerAddress } from "./chat-name.js";
-import { stripAnsi, paneIsBusy, transcriptStalled, summarizeTail, lastAssistantText, lastReply, replyToPeer as replyToPeerIn, unwrapPasted, lastContextTokens, lastModel, cacheTtlSec, keepaliveStamps, openKeepalivePing, lastUserTurn, talkRounds, openToolUses, renderDialog } from "./peers.js";
+import { stripAnsi, paneIsBusy, summarizeTail, lastAssistantText, lastReply, replyToPeer as replyToPeerIn, unwrapPasted, lastContextTokens, lastModel, cacheTouchMs, cacheTtlSec, keepaliveStamps, openKeepalivePing, lastUserTurn, talkRounds, openToolUses, renderDialog } from "./peers.js";
 import { keepalivePingSigs, isKeepalivePingText } from "../shared/keepalive.js";
 // PATH augmentation: launchd / systemd start the daemon
 // with a stripped PATH that often lacks nvm / homebrew, breaking spawn(claudeBin).
@@ -152,6 +152,9 @@ const findJsonlBySid = (sid, only) => {
 // codebuddy persists message/function_call records instead, so route every
 // parsed line through the owning backend's adapter first (identity for claude).
 const normalizeForPath = (path, raw) => backendForPath(path).normalizeTranscriptLine(raw);
+// /model、/effort 的本地回执 (spawn 兜底路径 / set_model 敲出来的) 是守护进程自己的
+// 操作痕迹, 不是聊天内容 —— 不镜像、不进详情页。
+const MODEL_RECEIPT_RE = /^(?:Set model to|Kept model as|Set effort level to|Kept effort|Switch model)\b/;
 // Local-command noise on user lines: Claude marks the caveat / command-stdout
 // records isMeta; codebuddy persists them as PLAIN user messages (no isMeta
 // field at all). Predicates looking for the first REAL user line must skip
@@ -525,6 +528,8 @@ const renderLine = (raw, deps) => {
             const stdoutMatch = c.match(/<local-command-stdout>([\s\S]*?)<\/local-command-stdout>/);
             if (stdoutMatch && stdoutMatch[1]) {
                 const skillOutput = stdoutMatch[1].replace(/\[[0-9;]*m/g, "").trim();
+                if (MODEL_RECEIPT_RE.test(skillOutput))
+                    return out;
                 if (skillOutput) {
                     out.push({ kind: "skill_output", body: `⚙️ ${skillOutput}` });
                 }
@@ -1432,9 +1437,9 @@ const injectViaTmux = async (target, text, images, log, freshSpawn, backend, jso
 // 证人不作声 (忙时排队、slash 命令、无注册表的后端) 才看框回没回到贴之前的样子。
 // 框认得出来时这条判据可信, 于是允许多补回车 (空框上的回车在 CLI 里是 no-op);
 // 每次补之前再问一遍证人, 已提交就不补。
+/** 具名粘贴 buffer 的序号 (见 loadAndPaste)。 */
+let pasteSeq = 0;
 const injectViaTmuxText = async (target, text, log, freshSpawn, witness = NO_WITNESS) => {
-    /** 具名粘贴 buffer 的序号 (见 loadAndPaste)。 */
-    let pasteSeq = 0;
     // Warm pane: tight timings, low latency. Fresh spawn (claude --resume just
     // started, transcript still loading): extended timings — bracketed-paste
     // end can take 4-7s to be honored on a cold TUI. Only the fresh-spawn path
@@ -1777,18 +1782,13 @@ export const startMirror = (deps) => {
         return true;
     };
     // Keepalive ping detector for the tail's user-line judgment — the SAME
-    // normalized-prefix signature set keepaliveTick feeds keepaliveStamps
-    // (every configured form + the bare "ping" legacy streak form), so
-    // renderLine, the tick and the transcript parser all agree on what counts
-    // as a ping. Content is the source of truth for the swallow: timers and
-    // echo-TTLs lose it across reloads/replays.
-    const pingSigs = keepalivePingSigs(cfg.wrc.mirror.keepalive.ping, cfg.wrc.mirror.keepalive.resumePing);
-    // The warmer alone — what the peer readers (peek / wait / roster summary) strip.
-    // `resumePing` is excluded on purpose: the turn it opens is real work resumed.
-    const warmerSigs = keepalivePingSigs(cfg.wrc.mirror.keepalive.ping);
-    // 行上只认保温那一句: 报错之后的续跑 (resumePing) 开出的是那一轮的接续, 整轮吞掉的话
-    // 续出来的结论既不进群也没有频道。续跑若只回了 pong, 回复侧的那道保险照样吞。
-    const isKeepalivePing = (text) => isKeepalivePingText(text, warmerSigs);
+    // 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
@@ -2438,6 +2438,13 @@ export const startMirror = (deps) => {
             }
             return opening?.query;
         }
+        // 私聊派来的活 (不是回执) 这一轮必是私聊, 不论印章带没带频道: 进群的只能是人问的事的
+        // 交代与显式公开。带 task 的 fork 分身就只有出处、没有频道印章, 退回 home 就把私聊派的活答进了群。
+        if (from?.kind === "peer" && !from.public && !from.receipt) {
+            a.channel = "";
+            a.speaker = undefined;
+            a.replyTo = undefined;
+        }
         return undefined;
     };
     /** 本轮落 turn 记录的频道字段。 */
@@ -2473,11 +2480,21 @@ export const startMirror = (deps) => {
         const t = said.trim();
         const hit = (x) => pick(x) && x.keys.some((k) => k === t || (k.length >= 8 && t.includes(k)));
         const seals = a.seals ?? [];
-        const first = seals.find(hit);
-        if (first)
-            a.seals = seals.filter((x) => !hit(x));
+        const hits = seals.filter(hit);
+        // CLI 把排队的几句并成一行, 这一轮只能有一个去向: 里面有私聊的那句就是私聊 —— 它的答复不能
+        // 跟着人的话进群; 没有才轮到人从聊天说的那句 (它的轮次与气泡早已建好)。
+        const first = hits.find((x) => x.channel === "") ?? hits.find((x) => !!x.turn) ?? hits[0];
+        if (!first)
+            return undefined;
+        a.seals = seals.filter((x) => !hit(x));
+        hits.filter((x) => x !== first && x.turn && !x.activated).forEach((x) => mergedAway(a, x.turn));
         return first;
     };
+    /** 人那句被并进了一轮私聊: 它预建的气泡与轮次收口成一个链接 —— 答复不进群, 也不让气泡挂到超时。 */
+    const mergedAway = (a, q) => {
+        void finishBubble(a, q.bubble, `${briefDetailLink(q.turnId, a.target)} （这句和一段私聊并成了一轮, 答复只在 rolepage）`, true);
+        recordTurnClose(q.turnId);
+    };
     /** 人在聊天里说的那一句接成活跃 turn: 收掉在跑的那一轮, 频道与发话人取它自己的印章。
      *  `at` = 那一行落盘的时刻: 排队的那句从这一刻才开始被处理, 轮次的起点以它为准; 闲时当场接上就是投递那一刻。 */
     const activateDispatch = (a, s, at = s.at) => {
@@ -3347,7 +3364,7 @@ export const startMirror = (deps) => {
                 // codebuddy 对 AskUserQuestion 不在提问时触发 PreToolUse hook — 先弹本地
                 // 面板, hook 只在面板被提交后才到达 (实测可延迟数小时)。这里从 jsonl 提前
                 // 看到 function_call, 直接驱动 vote 卡让远端可答; 点选后注入一段触发文本
-                // 提交本地面板, hook 到达时以 deny+reason 覆盖答案, 与 claude 路径同产物。
+                // 提交本地面板, hook 到达时以 deny+reason 覆盖答案 (claude 路径改走 allow+updatedInput)。
                 // claude 系 hook 即时触发, 不走此路 (否则双重发卡)。
                 if (c.name === "AskUserQuestion"
                     && backendForPath(a.jsonlPath).name === "codebuddy"
@@ -4495,7 +4512,11 @@ export const startMirror = (deps) => {
         const baseBound = base === target ? undefined : byTarget.get(base)?.jsonlPath ?? deps.store.get(base)?.jsonlPath;
         const boundPath = prev?.jsonlPath ?? rec?.jsonlPath ?? baseBound;
         const effCli = cli ?? (boundPath ? backendForPath(expandHome(boundPath)).name : undefined);
-        const effEffort = opts?.effort ?? parseEffort(prev?.effort ?? deps.store.get(target)?.effort);
+        // 群的默认会话 (管家) 没点名模型 / 档位时用 models.router。只管这里新起的 —— 死 pane
+        // 重生走绑定里记下的模型, 不经过这里; 已在跑的管家也不动 (换模型会让缓存整份重读)。
+        const router = !tagOfKey(target) && !isInternalKey(target) ? cfg.models.router : undefined;
+        const effModel = opts?.model?.trim() || router?.model || undefined;
+        const effEffort = opts?.effort ?? parseEffort(prev?.effort ?? deps.store.get(target)?.effort) ?? router?.effort;
         if (prev?.tmuxPane) {
             // Best-effort kill; ignore errors (pane may already be dead).
             void runTmux(["kill-pane", "-t", prev.tmuxPane]);
@@ -4512,7 +4533,7 @@ export const startMirror = (deps) => {
             windowName: windowName ?? target,
             cwdOverride: eff,
             cli: effCli,
-            model: opts?.model,
+            model: effModel,
             knownModels: modelSightings(effCli, [target, base]),
             effort: effEffort,
             systemPrompt: opts?.systemPrompt ?? charterFor(target, { cwd: eff }),
@@ -4534,7 +4555,7 @@ export const startMirror = (deps) => {
             // means this CLI's default, not the dead pane's model. Store what
             // spawnTmuxClaude actually confirmed via `/model` (r.model), not the
             // raw request — a later respawn's fast path then matches on try one.
-            model: r.model ?? (opts?.model?.trim() ?? ""),
+            model: r.model ?? effModel ?? "",
             effort: r.effort ?? "",
             keepaliveDisabled: opts?.keepalive === undefined ? undefined : !opts.keepalive,
         });
@@ -4674,7 +4695,7 @@ export const startMirror = (deps) => {
             return { ok: false, reason: r.reason, inherited: false };
         // 分叉文件不是开机就有的: CLI 在这个 pane **收到第一条消息**的那一刻才把父亲的
         // transcript 复制成新文件。所以必须先说一句话, 分身才会有自己的 sid —— 这句话
-        // 顺便就是它的开场白 (「你是谁、继承了什么、准备接什么」), 群里看到的第一条也是它。
+        // 顺便就是它的开场白 (「你是谁、继承了什么、准备接什么」)。
         const hello = args.bootstrap?.trim()
             || "（wezard 分身初始化）用一句话说明: 你是谁、从谁那里继承了哪些上下文、准备接什么活。不要复述这条指令。";
         rememberInject(hello);
@@ -4716,7 +4737,7 @@ export const startMirror = (deps) => {
         const spawned = byTarget.get(args.target);
         if (spawned) {
             // muteUntilInject 是给"全新 pane 的 greeting 噪音"准备的; 分身的开场白是正经
-            // 内容 (群里第一条就该是它), 所以这里不静音。
+            // 内容 (rolepage 上它的第一轮), 所以这里不静音 —— 进不进群由下面的频道印章定。
             spawned.justSpawned = true;
             spawned.keepaliveOff = true;
             spawned.keepaliveOffAt = Date.now();
@@ -4728,6 +4749,8 @@ export const startMirror = (deps) => {
                 spawned.pendingFrom = { from: args.bootstrapFrom.from, at: Date.now() };
                 spawned.pendingBriefQuery = args.bootstrapFrom.query;
             }
+            // 开场白不是谁在群里问的: 带活的是私聊派活, 不带的是守护进程让它自报家门 —— 都只进 rolepage。
+            spawned.pendingChannel = { channel: "", at: Date.now() };
         }
         lg.info({ parent: args.parent, sessionId: fork.sessionId }, "clone: forked");
         afterSpawn();
@@ -4971,6 +4994,10 @@ export const startMirror = (deps) => {
             const check = async () => {
                 if (done)
                     return;
+                if (aborted()) {
+                    finish({ idle: false, reason: "stopped" });
+                    return;
+                }
                 const v = idleVerdict(target);
                 if (v ?? !(await isBusy(target)))
                     finish({ idle: true });
@@ -4979,23 +5006,19 @@ export const startMirror = (deps) => {
             const tick = setInterval(() => void check(), IDLE_SAFETY_POLL_MS);
             const timer = setTimeout(() => finish({ idle: false, reason: "idle wait timed out" }), timeoutMs);
             void check();
-            if (aborted()) {
-                finish({ idle: false, reason: "stopped" });
-                return;
-            }
         });
     };
     const lastText = (target) => {
         const p = jsonlOf(target);
-        return p ? lastAssistantText(p, 4000, warmerSigs) : "";
+        return p ? lastAssistantText(p, 4000, pingSigs) : "";
     };
     const replySince = (target, sinceMs = 0) => {
         const p = jsonlOf(target);
-        return p ? lastReply(p, sinceMs, warmerSigs) : "";
+        return p ? lastReply(p, sinceMs, pingSigs) : "";
     };
     const replyToPeerSince = (target, fromName, sinceMs = 0, turn) => {
         const p = jsonlOf(target);
-        return p ? replyToPeerIn(p, fromName, sinceMs, warmerSigs, turn) : undefined;
+        return p ? replyToPeerIn(p, fromName, sinceMs, pingSigs, turn) : undefined;
     };
     /** 绑着的 pane 还能用 (存在、且不是别人的窗口) —— 不重生、不猜。 */
     const paneLiveOf = async (target) => {
@@ -5062,7 +5085,7 @@ export const startMirror = (deps) => {
             paneAlive,
             busy: paneAlive ? paneIsBusy(await capturePaneTail(pane, 12)) : false,
             lastActivity,
-            summary: jsonlPath ? summarizeTail(jsonlPath, 3, 80, warmerSigs) : "(未绑定会话)",
+            summary: jsonlPath ? summarizeTail(jsonlPath, 3, 80, pingSigs) : "(未绑定会话)",
             self: t === self,
         };
     };
@@ -5119,24 +5142,27 @@ export const startMirror = (deps) => {
             return { ok: false, reason: "它还没有 transcript (没接过第一句话) —— send_peer 跟它说一句就有了", busy };
         // `n` 数的是来回: 每个来回给问话和它最新的一句 (跑完的是终句, 还在跑的是途中
         // 最近说的那句) —— 途中的其余叙述不给, 那是过程不是结论。
-        const rounds = talkRounds(jsonl, n, warmerSigs).slice(-n);
+        const rounds = talkRounds(jsonl, n, pingSigs).slice(-n);
         const dialog = renderDialog(rounds.flatMap((r) => (r.length > 1 ? [r[0], r.at(-1)] : r)), 800, 4000);
         const waiting = busy ? [] : openToolUses(jsonl);
         return dialog ? { ok: true, dialog, busy, waiting } : { ok: false, reason: "transcript 里还没有对话", busy, waiting };
     };
     // ── Prompt-cache keepalive ──────────────────────────────────────────
-    // Anthropic's prompt cache expires ~5min after the last request. A pane that
-    // goes idle (agent parked on a peer, background task running) lets the whole
-    // context fall out of cache — the next real turn then re-writes it at 1.25x.
-    // We inject a tiny ping just before expiry so the model makes one cheap
-    // request (cache-read 0.1x) that slides the TTL forward. The whole schedule is
-    // anchored to the last REAL (non-ping) activity, NOT to our own pings — so a
-    // dead session is never kept warm forever, and once real work is older than
-    // `maxIdleSec` we stop and let the cache die.
+    // Anthropic's prompt cache expires a TTL (5min API default, 1h on a Claude Code
+    // subscription) after the start of the last request. A pane that goes idle
+    // (agent parked on a peer, background task running) lets the whole context fall
+    // out of cache — the next real turn then re-writes it. We inject a tiny ping just
+    // before expiry so the model makes one cheap request (cache-read) that slides the
+    // TTL forward. The budget is anchored to the last REAL (non-ping) activity, NOT to
+    // our own pings — so a dead session is never kept warm forever.
     // After `/stop`, ignore pane-busy as a resume signal for this long — long
     // enough for an in-flight ping (interrupted by the same /stop's Esc) to settle,
     // so it can't self-resume the pause. A genuine new turn after this window does.
     const RESUME_GRACE_MS = 30_000;
+    // A cache untouched this long is not kept warm: on a 1h entry the ping would come
+    // ~59min into the idle stretch, re-reading the whole context to cover a gap the
+    // TTL already covered — warming only pays on short (5min) entries.
+    const KEEPALIVE_MAX_IDLE_MS = 10 * 60_000;
     // Seed the keepalive clocks from message-turn timestamps (keepaliveStamps), never
     // from file mtime — non-message lines (file-history-snapshot / ai-title / mode)
     // bump mtime without being a model turn, which would fake a long-dead session
@@ -5156,35 +5182,30 @@ export const startMirror = (deps) => {
             round = s.streak;
         }
         catch { /* unreadable tail */ }
-        return { lastMs, lastRealMs, seenMtime: mtime, pinging: false, pingMtime: 0, round, settledAt: 0, ttlSec: cacheTtlSec(jsonlPath), stallFree: 0 };
+        return { lastMs, lastRealMs, seenMtime: mtime, pinging: false, pingMtime: 0, round, settledAt: 0, ttlSec: cacheTtlSec(jsonlPath), cacheAt: cacheTouchMs(jsonlPath) };
     };
-    const fireKeepalive = async (a, stalled) => {
+    const fireKeepalive = async (a) => {
         const kc = cfg.wrc.mirror.keepalive;
-        // Stalled (error/limit banner + idle pane): send the full resume instruction
-        // — inviting the model to finish genuinely-unfinished work, or to reply
-        // "pong" if it was legitimately parked. Otherwise the plain warmer, the SAME
-        // full instruction every round: a bare "ping" used to be sent from round 2 on
+        // The SAME full instruction every round: a bare "ping" used to be sent from round 2 on
         // (the instruction was already in context), but the model reads a bare "ping"
         // as an open turn and answers it however it likes — anything other than
         // "pong" un-swallows the heartbeat into chat and re-anchors the clocks as
         // real activity. Restating the instruction is a few tokens of cache-write and
         // buys a deterministic reply. keepaliveStamps matches every form, so none
         // reads as real activity. (round is incremented below, after the inject lands.)
-        const text = stalled ? kc.resumePing : kc.ping;
+        const text = kc.ping;
         // Suppress the pane→WeCom echo of the ping user line, then swallow the whole
         // ping turn (reply included). The 60s fail-safe clears the quiet window if
         // the turn somehow never emits turn_end, so a later real turn is never muted;
         // it also closes the detail turn so it can't hang open in the chat timeline.
         rememberInject(text);
-        // 续跑不是保温 (见 isKeepalivePing): 不开吞没窗口, 也不记成保温轮。
-        if (!stalled)
-            a.keepaliveQuiet = setTimeout(() => {
-                a.keepaliveQuiet = undefined;
-                if (a.keepaliveTurnId) {
-                    recordTurnClose(a.keepaliveTurnId);
-                    a.keepaliveTurnId = undefined;
-                }
-            }, 60_000);
+        a.keepaliveQuiet = setTimeout(() => {
+            a.keepaliveQuiet = undefined;
+            if (a.keepaliveTurnId) {
+                recordTurnClose(a.keepaliveTurnId);
+                a.keepaliveTurnId = undefined;
+            }
+        }, 60_000);
         const r = await inject({
             text, images: [], cfg,
             log: log.child({ target: a.target, sessionId: a.sessionId, sub: "keepalive" }),
@@ -5206,7 +5227,7 @@ export const startMirror = (deps) => {
         // closed on the ping's turn_end (or the fail-safe). Kept out of chat.
         // The tail's keepalive_start (content match on the user line) may have
         // opened this turn already — only open when it hasn't.
-        if (!stalled && !a.keepaliveTurnId) {
+        if (!a.keepaliveTurnId) {
             const turnId = newTurnId();
             a.keepaliveTurnId = turnId;
             recordTurnStart({ id: turnId, target: a.target, sessionId: a.sessionId, cli: cliOf(a), userQuery: text });
@@ -5219,14 +5240,11 @@ export const startMirror = (deps) => {
             return;
         keepaliveTicking = true;
         try {
-            // Stall recovery keeps the configured window: a turn that died on an API
-            // error should be resumed minutes later, whatever the cache tier.
-            const stallQuietMs = Math.max(30, kc.ttlSec - kc.marginSec) * 1000;
-            const pingSigs = [normAssistant(kc.ping).slice(0, 40), normAssistant(kc.resumePing).slice(0, 40)].filter((s) => s.length > 0);
+            const pingSigs = [normAssistant(kc.ping).slice(0, 40)].filter((s) => s.length > 0);
             const now = Date.now();
             for (const a of byTarget.values()) {
                 if (a.keepaliveDisabled)
-                    continue; // sticky spawn-time opt-out — never pings, never auto-resumes
+                    continue; // sticky spawn-time opt-out — never pings
                 if (!a.tmuxPane)
                     continue; // spawn-mode: no live pane to warm
                 if (a.migrationWatcher)
@@ -5261,6 +5279,7 @@ export const startMirror = (deps) => {
                         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
@@ -5298,34 +5317,25 @@ export const startMirror = (deps) => {
                 }
                 if (a.keepaliveOff)
                     continue; // paused by /stop until real activity returns
-                const idleSinceTouch = k.lastMs ? now - k.lastMs : now - mtime; // last model turn = cache touch
+                // 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 (idleSinceTouch < stallQuietMs)
-                    continue; // nothing due yet on either clock
-                if (idleSinceTouch >= ttlMs)
+                if (sinceCache < idleTriggerMs)
+                    continue; // cache still comfortably warm
+                if (sinceCache >= ttlMs)
                     continue; // cache already cold — a ping would cold-rewrite for nothing
+                if (sinceCache > KEEPALIVE_MAX_IDLE_MS)
+                    continue; // idle past 10min (a long-TTL entry) — not worth warming
                 if (k.round >= kc.rounds)
                     continue; // budget spent — let it go cold
-                // Stall recovery, decided by RULE only (no model self-judgment) and from
-                // the transcript's structure only — never the screen: the turn is still
-                // unfinished (died on a synthetic API error, or a tool result nobody
-                // answered) and has been quiet for the whole idle window. Send the resume
-                // instruction instead of the plain warmer. A transcript found un-stalled a
-                // minute past the quiet window stays so until a new turn lands (= lastMs
-                // moves) — remembered, so a 1h idle stretch reads it once, not every tick.
-                const stalled = kc.resumeOnStall && k.stallFree !== k.lastMs
-                    && transcriptStalled(a.jsonlPath, keepalivePingSigs(kc.ping, kc.resumePing), stallQuietMs, now);
-                if (!stalled && idleSinceTouch >= stallQuietMs + 60_000)
-                    k.stallFree = k.lastMs;
-                if (!stalled && idleSinceTouch < idleTriggerMs)
-                    continue; // cache still comfortably warm
                 k.pinging = true;
                 k.pingMtime = k.lastMs; // settles when a newer turn (the ping's own) appears
-                await fireKeepalive(a, stalled);
+                await fireKeepalive(a);
             }
         }
         catch (e) {
@@ -5482,6 +5492,7 @@ export const startMirror = (deps) => {
         isBusy,
         idleNow,
         parkedNow,
+        idleVerdict,
         untilIdle,
         setModel: async (target, wanted, scope) => {
             const a = byTarget.get(target);
@@ -5717,6 +5728,9 @@ export const startMirror = (deps) => {
             pushSeal(a, { keys: sealKeys(full), at: Date.now(), query: text, from: opts?.from, channel: opts?.channel, origin, fresh: idleVerdict(target) === true });
             const sid = a.sessionId;
             const paneAlive = a.tmuxPane ? await paneUsable(a.tmuxPane, a.jsonlPath) : false;
+            // 同 dispatch: 只有刚生 / 刚重生的 pane 才要冷启动的宽限 —— 对一个热着、正忙的 pane 贴 `now`
+            // 也按冷启动等 idle 至多 15s, 「不等不打断」就成了「晚 15–20s 才进」(handoff-owe 的竞态即此)。
+            let fresh = a.justSpawned === true;
             if (!paneAlive) {
                 log.warn({ target, sessionId: sid, oldPane: a.tmuxPane }, "injectText: pane not alive, respawning");
                 // Same resume-fork hazard as dispatch: snapshot before spawn, re-bind
@@ -5731,9 +5745,8 @@ export const startMirror = (deps) => {
                     a.runningCwd = r.cwd;
                 deps.store.set(target, { sessionId: sid, jsonlPath: a.jsonlPath, tmuxSession: a.tmuxSession, tmuxPane: a.tmuxPane, cwd: a.runningCwd || undefined, model: a.model || undefined, effort: a.effort || undefined, pendingCwd: a.pendingCwd || undefined });
                 startMigrationWatcher(a, resumeBaseline, forkOf(a.jsonlPath));
+                fresh = true;
             }
-            // freshSpawn: true — the pane was just minted by /mirror/spawn, the TUI
-            // is still warming up so the verifier in injectViaTmux needs the slack.
             // 同 dispatch: 在 inject 之前解除静默, 防止验证循环中 LLM 回复被永久吞掉。
             a.muteUntilInject = false;
             a.justSpawned = false;
@@ -5743,7 +5756,7 @@ export const startMirror = (deps) => {
             const preClearBaseline = clearing ? listJsonls(dirname(a.jsonlPath)) : undefined;
             const r = await inject({
                 text: full, images: [], cfg, log: log.child({ principal: target, sessionId: sid, sub: "init-demo" }),
-                sessionId: sid, jsonlPath: a.jsonlPath, tmuxTarget: a.tmuxPane, freshSpawn: true,
+                sessionId: sid, jsonlPath: a.jsonlPath, tmuxTarget: a.tmuxPane, freshSpawn: fresh,
             });
             if (r.ok && a.tmuxPane) {
                 if (preClearBaseline) {