wezard 2.0.1 → 2.0.3

package/dist/daemon/mirror-bridge.js

@@ -1655,6 +1655,9 @@ export const startMirror = (deps) => {
     // for >60s mid-turn and we don't want to drop the bubble while it's chewing.
     const FLUSH_MS = 250;
     const HARD_TIMEOUT_MS = 350_000;
+    /** hard cap 到点时的中间结束语: 气泡必须 finish=true, 但 turn 还在跑 —— 明说
+     *  「没完, 去链接看」, 而不是让气泡停在一句看似说完的话 / 一行过期的进度上。 */
+    const STILL_WORKING = "⏳ 仍在处理中, 点击链接查看详情…";
     /** 软收口静默期。后端只能说"这条消息写完了"(codebuddy) 时, 等这么久没有新 item
      *  才认定一轮结束。取值只需盖住"叙述消息落盘 → 紧随其后的 function_call 落盘"
      *  这一段, 与模型思考/工具执行时长无关。
@@ -1721,7 +1724,7 @@ export const startMirror = (deps) => {
             return;
         s.flushTimer = setTimeout(() => void flushStream(s), FLUSH_MS);
     };
-    const finalizeStream = async (a, s) => {
+    const finalizeStream = async (a, s, timedOut = false) => {
         if (s.closed)
             return;
         s.closed = true;
@@ -1743,17 +1746,20 @@ export const startMirror = (deps) => {
         // 没正文不写: finish=true 是整条覆盖, 空正文只会把 "…" ack 覆盖成光秃秃的
         // 链接头, 结束处理自己制造错发。气泡保持现有内容, 由 WeCom 6min 窗口自然
         // 到期。dead 流同理只做本地清理。
-        if (!s.dead && s.acc.trim()) {
+        // 例外是 hard cap 超时: turn 还在跑, 收口时缀上中间结束语 —— 这时即使没正文
+        // 也有话可说, 不算空覆盖。
+        const body = timedOut ? [s.acc, STILL_WORKING].filter((x) => x.trim()).join("\n\n") : s.acc;
+        if (!s.dead && body.trim()) {
             const card = detailCardFor(s, a.target);
             try {
                 if (card) {
                     s.cardSent = true;
-                    await client.replyStreamWithCard(s.frame, s.streamId, withLinkedTag(a, s.acc, undefined, s.turnId), true, { templateCard: card });
+                    await client.replyStreamWithCard(s.frame, s.streamId, withLinkedTag(a, body, undefined, s.turnId), true, { templateCard: card });
                 }
                 else {
-                    await client.replyStream(s.frame, s.streamId, withLinkedTag(a, s.acc, undefined, s.turnId), true);
+                    await client.replyStream(s.frame, s.streamId, withLinkedTag(a, body, undefined, s.turnId), true);
                 }
-                log.info({ sessionId: a.sessionId, turnId: s.turnId, accLen: s.acc.length, tools: s.tools.length, withCard: !!card }, "stream finalize");
+                log.info({ sessionId: a.sessionId, turnId: s.turnId, accLen: s.acc.length, tools: s.tools.length, withCard: !!card, timedOut }, "stream finalize");
             }
             catch (e) {
                 log.warn({ sessionId: a.sessionId, turnId: s.turnId, err: e.message }, "stream finalize failed");
@@ -1783,7 +1789,7 @@ export const startMirror = (deps) => {
             capped: false, closed: false, dead: false, cardSent: false,
             tools: [], sawTool: false,
         };
-        s.hardTimer = setTimeout(() => void finalizeStream(a, s), HARD_TIMEOUT_MS);
+        s.hardTimer = setTimeout(() => void finalizeStream(a, s, true), HARD_TIMEOUT_MS);
         log.info({ sessionId: a.sessionId, turnId: s.turnId, streamId }, "stream open");
         return s;
     };
@@ -2261,11 +2267,11 @@ export const startMirror = (deps) => {
         const bubble = { frame, streamId, hardTimer: undefined, done: false };
         const q = { turnId, bubble, isSlash };
         bubble.hardTimer = setTimeout(() => {
-            // WeCom ~6min stream 窗口快到, 必须 finish=true 收口。没正文时不能拿光链接
-            // 覆盖 —— finish 是整条替换, 会把屏幕上的 CoT 进度行抹成光秃秃的链接; 改用
-            // 最新进度行定格 (a 上的 CoT 只在气泡仍是本轮活跃气泡时才可信, 换轮后归新轮)。
-            const cot = a.briefBubble === bubble && !a.briefConcluded ? a.cotText ?? a.cotLastSent : undefined;
-            void finishBubble(a, bubble, `${briefDetailLink(turnId, a.target)}${cot ? ` \`${cot}\`` : ""}`, true);
+            // WeCom ~6min stream 窗口快到, 必须 finish=true 收口。finish 是整条替换 ——
+            // 定格在一行过期的 CoT 进度上看着像卡死, 光链接又像说完了; 气泡仍是本轮活跃
+            // 气泡 (turn 还在跑) 就明说「仍在处理中」, 已被顶替的旧轮只留链接。
+            const live = a.briefBubble === bubble && !a.briefConcluded;
+            void finishBubble(a, bubble, `${briefDetailLink(turnId, a.target)}${live ? ` ${STILL_WORKING}` : ""}`, true);
         }, HARD_TIMEOUT_MS);
         // 新消息 = 对话边界: 立刻收掉上一 turn, 新 turn 直接激活、不排队。收口语义见
         // closeBriefTurn: 有正文收入旧气泡, 没正文不写一个字 (绝不因边界结束凭空新发/
@@ -4023,6 +4029,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 会以为自己还在
     // 旧工作区里。
@@ -4143,6 +4152,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 ───────────────────────────────────────────────────────────
@@ -4253,6 +4263,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 / 交接判断要用的那几个数。 */
@@ -5209,45 +5220,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);
@@ -5257,10 +5287,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 };
         },
@@ -5351,6 +5382,7 @@ export const startMirror = (deps) => {
         cloneSession,
         sessionInfo,
         setCharterProvider,
+        onSpawn,
         shutdown: () => {
             clearInterval(paneDriftTimer);
             clearInterval(keepaliveTimer);