wezard 1.2.25 → 1.2.27

package/dist/daemon/mirror-bridge.js

@@ -368,6 +368,17 @@ const stripTrailingBody = (think, body) => {
     }
     return think;
 };
+// thinkStyle 兜底: turn 收口时无正式 body, 从累积的 thinking 里摘出最后一段
+// 看起来像正文的内容当作 body 下发。工具调用行 (🔧) 和工具结果行 (↳) 跳过。
+const rescueBodyFromThinking = (thinking) => {
+    const paragraphs = thinking.split(/\n\n/).map(s => s.trim()).filter((s) => s.length > 0);
+    for (let i = paragraphs.length - 1; i >= 0; i--) {
+        const p = paragraphs[i];
+        if (!p.startsWith("🔧 ") && !p.startsWith("↳ "))
+            return p;
+    }
+    return undefined;
+};
 // WeCom's markdown sanitizer strips HTML-like `<...>` runs even inside inline
 // code spans — so a Bash command containing `<<'EOF'` (heredoc), `<file>`,
 // `<noreply@x>` etc. silently swallows the rest of the line plus the closing
@@ -1448,6 +1459,22 @@ export const startMirror = (deps) => {
     const SOFT_TURN_END_MS = 4_000;
     const STREAM_SOFT_CAP = 18_000;
     const TOOL_DETAIL_TTL_MS = 24 * 60 * 60 * 1000;
+    /** thinkStyle 兜底超时: turn 开始 2min 后仍未 conclude → 强制软收口。
+     *  比 HARD_TIMEOUT_MS (350s) 短, 气泡还活着时走 finishBriefBubble 路径。 */
+    const THINK_RESCUE_TIMEOUT_MS = 120_000;
+    /** Standalone 发送前正文检查: 内容无正文 (纯 think 标记 / 工具行) 时,
+     *  回队列等这么久。期间有新消息入队则重置; 到期且无新消息才发出。 */
+    const STANDALONE_BODY_WAIT_MS = 8_000;
+    // 判断 standalone 内容是否含有正文 (非纯 <think>…</think> / 工具行)。
+    const standaloneHasBody = (content) => {
+        // 剥掉 <think>…</think> 包裹 (含 tag header)
+        const stripped = content.replace(/<think>[\s\S]*?<\/think>/g, "")
+            // 工具行
+            .replace(/^🔧 .*/gm, "")
+            .replace(/^↳ .*/gm, "")
+            .trim();
+        return stripped.length > 0;
+    };
     const turnRegistry = new Map();
     const evictTurns = () => {
         const now = Date.now();
@@ -1627,12 +1654,22 @@ export const startMirror = (deps) => {
     };
     // Debounce 聚合: 仅 standalone 路径用。窗口内 onItem 多次落入 → 合并成单条 markdown。
     // 0 关闭时退化为透传。flushStandalone 也用于 detach 时的 drain。
-    const flushStandalone = (a) => {
+    // 正文检查: 合并内容无正文 (纯 think/工具) 时, 回队列等 STANDALONE_BODY_WAIT_MS;
+    // 期间有新消息入队 (parts 增长) 则重置; 到期且无新消息才强制发出。
+    // force=true 跳过正文检查, 用于 teardown / detach / pre-card 等强制 drain 场景。
+    const flushStandalone = (a, force = false) => {
         const buf = a.standaloneBuf;
         if (!buf)
             return;
+        const merged = buf.parts.join("\n\n");
+        // 无正文 & 队列有新增 → 再等一轮 (force 跳过)
+        if (!force && !standaloneHasBody(merged) && buf.bodyWaitLen !== buf.parts.length) {
+            buf.bodyWaitLen = buf.parts.length;
+            buf.timer = setTimeout(() => flushStandalone(a), STANDALONE_BODY_WAIT_MS);
+            return;
+        }
         a.standaloneBuf = undefined;
-        sendStandalone(a, buf.parts.join("\n\n"));
+        sendStandalone(a, merged);
     };
     const enqueueStandalone = (a, content) => {
         const ms = cfg.wrc.mirror.standaloneDebounceMs;
@@ -1683,7 +1720,7 @@ export const startMirror = (deps) => {
         if (!a.standaloneBuf)
             return;
         clearTimeout(a.standaloneBuf.timer);
-        flushStandalone(a);
+        flushStandalone(a, true);
     };
     // Path A: a needs-approval tool_use just landed. Aggregate the buffer as one
     // standalone, send it BEFORE the approval card race, transition to AWAITING_APPR.
@@ -1842,6 +1879,11 @@ export const startMirror = (deps) => {
     // 收口一条 loading 气泡: finish=true 写入最终内容, 只生效一次。发送失败退回 standalone。
     // 排队中的 turn 也持有气泡, 所以气泡是显式入参而不是从 a 上取。
     // raw=true skips withSessionTag (used when content already contains the linked tag header).
+    // WeCom 客户端收到 finish=true 后仍有打字机动画要播放, 如果紧接着就下发
+    // standalone (sendMessage), 用户会看到 standalone 抢在气泡动画结束之前出现。
+    // 把 finishBubble 的 replyStream promise 链入 standalonePending, 让后续
+    // standalone 自然排在 finish 之后; 额外加一小段延迟留给客户端渲染。
+    const BUBBLE_FINISH_SETTLE_MS = 600;
     const finishBubble = async (a, b, content, raw = false) => {
         if (!b || b.done)
             return;
@@ -1851,16 +1893,28 @@ export const startMirror = (deps) => {
             clearTimeout(b.earlyTimer);
             b.earlyTimer = undefined;
         }
+        // think-style: 清除待发的 flush 定时器, 避免 doStreamThink 在 done 后空跑。
+        if (a.briefBubble === b && a.thinkFlushTimer) {
+            clearTimeout(a.thinkFlushTimer);
+            a.thinkFlushTimer = undefined;
+        }
         if (a.briefBubble === b)
             a.briefBubble = undefined;
-        try {
-            await client.replyStream(b.frame, b.streamId, raw ? (content || " ") : withLinkedTag(a, content || " "), true);
-        }
-        catch (e) {
-            log.warn({ sessionId: a.sessionId, err: e.message }, "brief: bubble finish failed; standalone fallback");
-            if (content.trim())
-                raw ? sendRaw(a, content) : sendStandalone(a, content);
-        }
+        const p = (async () => {
+            try {
+                await client.replyStream(b.frame, b.streamId, raw ? (content || " ") : withLinkedTag(a, content || " "), true);
+                // 给 WeCom 客户端留一点时间完成打字机动画, 再放行 standalone 队列。
+                await new Promise((r) => setTimeout(r, BUBBLE_FINISH_SETTLE_MS));
+            }
+            catch (e) {
+                log.warn({ sessionId: a.sessionId, err: e.message }, "brief: bubble finish failed; standalone fallback");
+                if (content.trim())
+                    raw ? sendRaw(a, content) : sendStandalone(a, content);
+            }
+        })();
+        // 链入 standalonePending, 后续 sendStandalone/sendRaw 自然等 finish 完成。
+        a.standalonePending = a.standalonePending.then(() => p).catch(() => undefined);
+        return p;
     };
     const finishBriefBubble = (a, content, raw = false) => finishBubble(a, a.briefBubble, content, raw);
     // think-style tag: 紧跟在 `<think>` 之后, 不在整条消息最前面 —— `<think>🧙 …`。
@@ -1872,17 +1926,36 @@ export const startMirror = (deps) => {
     // think-style: 把当前累积的 thinking 作为 `<think>🧙 …` 流进活着的 loading 气泡
     // (finish=false, 气泡不关)。收口时再补 `</think>\n\n<final>` 并 finish。
     // raw 发送: tag 已在 <think> 内, 不再经 withSessionTag 外包。
-    const streamThink = (a) => {
+    // streamPending → 首次调用时才真正开流 (fix: off-by-one race)。
+    // fix: 加去抖 (FLUSH_MS) + 背压 (await 上一次完成), 消除 SDK 串行队列积压。
+    const doStreamThink = async (a) => {
         const b = a.briefBubble;
         const think = a.briefThinking?.trim();
         if (!b || b.done || !think)
             return;
-        client
-            .replyStream(b.frame, b.streamId, openThink(a.target, think), false)
-            .catch((e) => log.warn({ sessionId: a.sessionId, err: e.message }, "brief: think stream failed"));
+        // 首条 replyStream 延迟到这里发出 (streamPending), 携带真实内容, 避免空开流竞态。
+        b.streamPending = false;
+        try {
+            await client.replyStream(b.frame, b.streamId, openThink(a.target, think), false);
+            log.debug({ sessionId: a.sessionId, streamId: b.streamId, thinkLen: think.length }, "brief: think stream ok");
+        }
+        catch (e) {
+            log.warn({ sessionId: a.sessionId, err: e.message }, "brief: think stream failed");
+        }
+    };
+    const scheduleThinkFlush = (a) => {
+        if (!a.briefBubble || a.briefBubble.done || a.thinkFlushTimer || a.thinkFlushing)
+            return;
+        a.thinkFlushTimer = setTimeout(() => {
+            a.thinkFlushTimer = undefined;
+            if (a.thinkFlushing)
+                return; // 上一次还在飞 → 下次 pushThink 再排
+            a.thinkFlushing = true;
+            void doStreamThink(a).finally(() => { a.thinkFlushing = false; });
+        }, FLUSH_MS);
     };
     // think-style 单一入口: 一段中间过程 (reasoning / 中途文本 / 工具调用) 进 think。
-    // 气泡还活 → 累积进 briefThinking 并全量刷进气泡; 否则 (无气泡 turn / 气泡已收口)
+    // 气泡还活 → 累积进 briefThinking 并排一次去抖 flush; 否则 (无气泡 turn / 气泡已收口)
     // 只累积, 绝不单独 standalone —— 中间纯思考过程不下发消息, 等正式文本回复出现时
     // 与正文拼成一条 `<think>…</think>\n\n正文` 整段下发 (见 concludeBriefTurn)。
     const pushThink = (a, chunk) => {
@@ -1891,7 +1964,7 @@ export const startMirror = (deps) => {
             return;
         a.briefThinking = a.briefThinking ? `${a.briefThinking}\n\n${c}` : c;
         if (a.briefBubble && !a.briefBubble.done)
-            streamThink(a);
+            scheduleThinkFlush(a);
     };
     // 让一个已建好记录的 turn 成为活跃 turn。turn 级状态在这里统一归零 —— 唯一入口。
     const openBriefTurn = (a, q) => {
@@ -1902,6 +1975,32 @@ export const startMirror = (deps) => {
         a.briefConcluded = false;
         a.briefLastText = undefined;
         a.briefThinking = undefined;
+        if (a.thinkFlushTimer) {
+            clearTimeout(a.thinkFlushTimer);
+            a.thinkFlushTimer = undefined;
+        }
+        a.thinkFlushing = false;
+        if (a.thinkRescueTimer) {
+            clearTimeout(a.thinkRescueTimer);
+            a.thinkRescueTimer = undefined;
+        }
+        if (thinkStyle) {
+            a.thinkRescueTimer = setTimeout(() => {
+                if (a.briefTurnId === q.turnId && !a.briefConcluded) {
+                    log.warn({ sessionId: a.sessionId, turnId: q.turnId, hasThinking: !!a.briefThinking }, "brief: thinkStyle rescue timeout — forcing close");
+                    // 立即刷一次最新 thinking 到气泡 (跳过去抖), 让用户看到完整积累内容,
+                    // 而不是停在上一次 250ms 去抖窗口的快照。
+                    if (a.thinkFlushTimer) {
+                        clearTimeout(a.thinkFlushTimer);
+                        a.thinkFlushTimer = undefined;
+                    }
+                    if (a.briefBubble && !a.briefBubble.done && a.briefThinking?.trim()) {
+                        void doStreamThink(a);
+                    }
+                    closeBriefTurn(a, true);
+                }
+            }, THINK_RESCUE_TIMEOUT_MS);
+        }
         log.info({ sessionId: a.sessionId, turnId: q.turnId, isSlash: q.isSlash }, "brief: turn started");
     };
     // WeCom 侧发起一个 turn: 立刻挂 loading 气泡当 ack, 再决定是马上激活还是排队。
@@ -1936,10 +2035,18 @@ export const startMirror = (deps) => {
                 log.warn({ sessionId: a.sessionId, turnId }, "brief: queued turn timed out — force-closing the stuck one");
                 closeBriefTurn(a);
             }
-            // think-style: 到点也不发链接或纯 think 孤消息（a.briefThinking 属于当前活跃
-            // turn, 不是本排队 turn 的）。超时只收空气泡防止悬挂。
+            // think-style: WeCom ~6min stream 窗口快到, 必须 finish=true 收口。
+            // 保留当前已流进气泡的 thinking 内容作为最终快照 (用户看到的内容不变),
+            // 后续正文走 standalone。如果 turn 尚未结论, 标记 done 让 concludeBriefTurn
+            // 知道气泡已收口、走 else 分支 (sendRaw / sendStandalone)。
             if (thinkStyle) {
-                void finishBubble(a, bubble, withSessionTag(a.target, " "), true);
+                // 活跃 turn 的 thinking 才是本气泡的内容; 排队 turn 没有 thinking, 空收即可。
+                const think = (a.briefBubble === bubble) ? a.briefThinking?.trim() : undefined;
+                const content = think ? openThink(a.target, think) : withSessionTag(a.target, " ");
+                // 标记: thinking 快照已写进气泡, 后续 concludeBriefTurn 走 else 分支时不再重复发 thinking。
+                if (think)
+                    bubble.thinkSnapshotFlushed = true;
+                void finishBubble(a, bubble, content, true);
             }
             else {
                 void finishBubble(a, bubble, briefDetailLink(turnId, a.target), true);
@@ -1949,7 +2056,11 @@ export const startMirror = (deps) => {
         // 首条 item 到达时清除 (handleBriefItem 路径)。用显式 bubble ref 而非 a.briefBubble,
         // 因为排队中的 turn 还没成为活跃 turn, a.briefBubble 指向的是前一个。
         // think-style: 不设 earlyTimer —— 不发链接, 气泡留着等 thinking / 答复流进来。
-        if (!thinkStyle)
+        // codebuddy: jsonl 按完整消息落盘 (status:"completed"), 不像 Claude Code 增量写,
+        // 首条 item 常在 3s 之后才到达 → earlyTimer 提前收口气泡 → 结论被迫走 standalone。
+        // 跳过 earlyTimer, 让气泡等到真正的内容写入 (hardTimer 兜底 6min 窗口)。
+        const skipEarly = thinkStyle || backendForPath(a.jsonlPath).name === "codebuddy";
+        if (!skipEarly)
             bubble.earlyTimer = setTimeout(() => {
                 if (bubble.done)
                     return;
@@ -1963,10 +2074,12 @@ export const startMirror = (deps) => {
             openBriefTurn(a, q);
         }
         try {
-            // think-style: 用户一发消息立刻回 `<think>🧙 ` 开头 (tag 在 <think> 内), 不再先占位 `…`。
-            // 后续 thinking / 中途文本经 streamThink 全量替换续写, 收口时补 `</think>\n\n<final>`。
+            // think-style: 延迟首条 replyStream 到首个内容到达 (streamPending=true),
+            // 避免空 `<think>` 与紧随的 pushThink 产生两次快速 replyStream 触发 WeCom
+            // 服务端合并/丢弃 (off-by-one)。flushStreamPending 在 pushThink/doStreamThink 首次
+            // 调用时开流, 保证只有一次 replyStream 携带真实内容。
             if (thinkStyle) {
-                await client.replyStream(frame, streamId, openThink(a.target, ""), false);
+                bubble.streamPending = true;
             }
             else {
                 await client.replyStream(frame, streamId, withSessionTag(a.target, "…"), false); // 挂住 loading 气泡, 不关闭
@@ -2038,7 +2151,10 @@ export const startMirror = (deps) => {
             else {
                 // 无气泡 turn / 气泡已收口: 中间 thinking 不单独 standalone, 累积的整段思考与
                 // 正式正文拼成一条下发 (think 取自 stripTrailingBody, 已摘掉尾部等于正文的重复段)。
-                const t = think;
+                // fix #1: 若 hardTimer 已把 thinking 快照写进气泡 (thinkSnapshotFlushed), 只发 body,
+                // 不再重复发 thinking —— 用户已经在气泡里看到了完整 thinking。
+                const snapshotFlushed = a.briefBubble?.thinkSnapshotFlushed;
+                const t = snapshotFlushed ? undefined : think;
                 if (t)
                     sendRaw(a, `${openThink(a.target, t)}</think>\n\n${body}`);
                 else
@@ -2062,19 +2178,35 @@ export const startMirror = (deps) => {
             return;
         if (soft)
             concludeBriefTurn(a, a.briefLastText ?? "");
+        // ──── thinkStyle 兜底: turn 将收口但 concludeBriefTurn 未生效 ────
+        // 正常路径 (final===true / 软收口 + briefLastText) 上面已经 conclude 过了;
+        // 这里只处理"有 thinking 但正文为空"的漏网之鱼: 从 briefThinking 尾部摘出最后
+        // 一段非工具行当作正文, 再试一次 conclude。保证 thinking 内容不被静默丢弃。
+        if (thinkStyle && !a.briefConcluded && a.briefThinking) {
+            const rescued = rescueBodyFromThinking(a.briefThinking);
+            if (rescued) {
+                log.info({ sessionId: a.sessionId, turnId: a.briefTurnId }, "brief: thinkStyle rescue — concluding with last text from thinking");
+                concludeBriefTurn(a, rescued);
+            }
+        }
         // 气泡还开着 (有工具的 turn: 结论只发了 standalone, 气泡留到这里收链接; 或空 turn
         // 没有结论) —— 收口: 统一写详情链接, 保证每个 turn 都有可点入口。
         if (a.briefBubble && !a.briefBubble.done) {
             if (thinkStyle) {
                 // 已结论 → 气泡已在 concludeBriefTurn 的 else 分支通过 sendRaw 发出
                 //   think+body 整条消息，这里只需收掉气泡（避免重复下发）。
-                // 未结论 → 不发纯 think 孤消息。streamThink 已提供实时预览，
-                //   标记 done 阻止后续 streamThink，等 concludeBriefTurn 合并下发。
+                // 未结论 → doStreamThink 可能已把半成品 thinking 流进气泡 (无 </think> 闭合),
+                //   用闭合的 thinking 快照收口, 避免 WeCom 渲染标签未闭合的乱排版。
+                //   如果连 thinking 都没有 (streamPending 还在), 空收。
                 if (a.briefConcluded) {
                     void finishBriefBubble(a, withSessionTag(a.target, " "), true);
                 }
                 else {
-                    a.briefBubble.done = true;
+                    const think = a.briefThinking?.trim();
+                    const content = think
+                        ? `${openThink(a.target, think)}</think>`
+                        : withSessionTag(a.target, " ");
+                    void finishBriefBubble(a, content, true);
                 }
             }
             else {
@@ -2090,6 +2222,15 @@ export const startMirror = (deps) => {
         a.briefConcluded = false;
         a.briefLastText = undefined;
         a.briefThinking = undefined;
+        if (a.thinkFlushTimer) {
+            clearTimeout(a.thinkFlushTimer);
+            a.thinkFlushTimer = undefined;
+        }
+        a.thinkFlushing = false;
+        if (a.thinkRescueTimer) {
+            clearTimeout(a.thinkRescueTimer);
+            a.thinkRescueTimer = undefined;
+        }
         // 放行下一个排队的 turn —— 它的气泡早在 ack 时就挂出去了, 这里只是激活。
         const next = a.briefQueue?.shift();
         if (next)
@@ -2108,8 +2249,8 @@ export const startMirror = (deps) => {
         // 一个僵尸 turn 上来当活跃 turn, 白收一遍。
         for (const q of a.briefQueue ?? []) {
             closed++;
-            // think-style: 不发链接, 排队气泡直接空收。
-            void finishBubble(a, q.bubble, thinkStyle ? " " : briefDetailLink(q.turnId, a.target), thinkStyle);
+            // think-style: 不发链接, 排队气泡收为"已取消"提示 (避免空白气泡闪过)。
+            void finishBubble(a, q.bubble, thinkStyle ? withSessionTag(a.target, "⏳ (queued, cancelled)") : briefDetailLink(q.turnId, a.target), thinkStyle);
             recordTurnClose(q.turnId);
         }
         a.briefQueue = [];
@@ -2128,7 +2269,7 @@ export const startMirror = (deps) => {
         }
         if (a.standaloneBuf) {
             clearTimeout(a.standaloneBuf.timer);
-            flushStandalone(a);
+            flushStandalone(a, true);
         }
         if (a.liveStream && !a.liveStream.closed) {
             closed++;
@@ -2270,10 +2411,15 @@ export const startMirror = (deps) => {
             if (item.quiet)
                 return;
             // slash 命令 (/context…) 的 skill_output 即本轮答案 (无 final text 收口) —— 写进
-            // loading 气泡。非 slash 场景的 skill_output 是中间反馈, 照旧 standalone。
+            // loading 气泡。非 slash 场景的 skill_output 是中间反馈:
+            //   think-style → 进 think 流 (与工具调用等中间过程一致);
+            //   非 think-style → standalone。
             if (a.briefIsSlash && !a.briefHadTool && a.briefBubble && !a.briefBubble.done) {
                 void finishBriefBubble(a, item.body);
             }
+            else if (thinkStyle) {
+                pushThink(a, item.body);
+            }
             else {
                 sendStandalone(a, item.body);
             }
@@ -2636,7 +2782,7 @@ export const startMirror = (deps) => {
             void finalizeStream(a, a.liveStream);
         if (a.standaloneBuf) {
             clearTimeout(a.standaloneBuf.timer);
-            flushStandalone(a);
+            flushStandalone(a, true);
         }
         a.tail.stop();
         bySessionId.delete(a.sessionId);
@@ -4123,7 +4269,7 @@ export const startMirror = (deps) => {
             // 3) standalone 防抖里 (3s 默认) 还压着的合并文案 — 强制立刻发。
             if (a.standaloneBuf) {
                 clearTimeout(a.standaloneBuf.timer);
-                flushStandalone(a);
+                flushStandalone(a, true);
             }
             // 4) liveStream 半成品: 当前 acc 里有内容但还没 flush 出去 — 同步刷一刀,
             //    保留 stream 不 finalize (后续 tool_result 还要继续 append 同一气泡)。
@@ -4181,18 +4327,13 @@ export const startMirror = (deps) => {
             }
             // 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;
             const r = await inject({
                 text, images: [], cfg, log: log.child({ principal: target, sessionId: sid, sub: "init-demo" }),
                 sessionId: sid, jsonlPath: a.jsonlPath, tmuxTarget: a.tmuxPane, freshSpawn: true,
             });
-            // 与 dispatch 同一约定: 首条 inject 落地 = 解除新 pane 的初始输出静默。
-            // 漏掉这一步的后果不只是少几条气泡 —— onItem 在 mute 分支整体早退, 连
-            // recordTurnStart 都不会跑, 于是 graph/send_peer 拉起来的节点在 chat 列表
-            // 和 chat 详情里彻底不存在(它从来没被 WeCom 侧 dispatch 过, 没有第二次机会)。
-            if (r.ok) {
-                a.muteUntilInject = false;
-                a.justSpawned = false;
-            }
             return r;
         },
         interruptPane: async (target, opts) => {
@@ -4479,7 +4620,7 @@ export const startMirror = (deps) => {
             // race against the new stream's first content (Path B).
             if (a.standaloneBuf) {
                 clearTimeout(a.standaloneBuf.timer);
-                flushStandalone(a);
+                flushStandalone(a, true);
             }
             // /clear produces no assistant output; opening a stream would leave a
             // stale "…" + quoted-user bubble in WeCom. Skip the stream entirely on
@@ -4590,12 +4731,18 @@ export const startMirror = (deps) => {
                     return;
                 }
                 rememberInject(text);
+                // 解除静默必须在 inject 之前: inject 内部的 freshSpawn 验证循环可达 10+s
+                // (paste-verify + settle + waitForCleared + retry), 而 LLM 的回复可能在 Enter
+                // 发出后 2-3s 就落盘 —— tail 在 mute 期间读到的 item 会被 onItem 永久丢弃,
+                // 导致 turn_end 丢失, brief turn 无法收口, 后续消息全部错位 (off-by-one)。
+                // 安全性: newSession 的 fresh pane 在 inject 前只写过 system/init (→ 无 item),
+                // 用户行有 isOwnInject 过滤 —— 提前解除不会泄漏脏数据。
+                a.muteUntilInject = false;
                 const r = await inject({
                     text, images, cfg, log: log.child({ principal, sessionId: sid }),
                     sessionId: sid, jsonlPath: a.jsonlPath, tmuxTarget: a.tmuxPane, freshSpawn,
                 });
                 if (!r.ok) {
-                    a.muteUntilInject = false;
                     if (s) {
                         s.acc = s.acc ? `${s.acc}\n\n[mirror] ✗ ${r.reason ?? "failed"}` : `[mirror] ✗ ${r.reason ?? "failed"}`;
                         await finalizeStream(a, s);
@@ -4619,8 +4766,6 @@ export const startMirror = (deps) => {
                     }
                     return;
                 }
-                // inject 成功 → 解除初始输出静默, 后续 onItem 正常流转。
-                a.muteUntilInject = false;
                 // Inject "succeeded" but the input box never cleared — the target
                 // session may be busy / not consuming input (long task, full context).
                 // Hint the user once so a silently-dropped message isn't mistaken for a