wezard 1.3.6 → 1.3.7

package/dist/daemon/mirror-bridge.js

@@ -20,12 +20,13 @@ import { activeBackends, backendForPath, projectDirFor, projectDirsFor, } from "
 import { isModalPane, isAskqSubmitPage, parseModalOptions, pickModalAnswer } from "../shared/modal-pane.js";
 import { hasMirrorAskq, runMirrorAskqFlow, hasMirrorPlan, mootMirrorPlan, runMirrorPlanFlow } from "./approval.js";
 import { runTmux as runTmuxCmd, spawnTmuxClaude } from "./spawn-tmux.js";
+import { startSubagentWatch } from "./subagent-tail.js";
 import { recordTool, recordToolResult, recordTurnStart, recordTurnItem, recordTurnUsage, recordTurnClose, recordCloseOpenTurns, buildDetailUrl, buildChatUrl } from "./detail.js";
-import { labelFor, tagOfKey, baseOfKey, keyOf, withTagHeader } from "../shared/session-label.js";
+import { labelFor, tagOfKey, baseOfKey, keyOf, withTagHeader, parseTagHeader } from "../shared/session-label.js";
 import { splitMarkdown } from "../shared/md-chunk.js";
 import { randomTip } from "./tips.js";
 import { chatBaseOf, chatNameOf, listChatNames, normChatName, parsePeerRef, peerAddress } from "./chat-name.js";
-import { stripAnsi, compactPane, paneIsBusy, paneIsStalled, transcriptStalled, summarizeTail, lastAssistantText, lastContextTokens, keepaliveStamps, tailTurns, renderDialog } from "./peers.js";
+import { stripAnsi, compactPane, paneIsBusy, paneIsStalled, transcriptStalled, limitResetAt, summarizeTail, lastAssistantText, lastContextTokens, keepaliveStamps, tailTurns, renderDialog } from "./peers.js";
 // Same PATH augmentation logic as cc-bridge: launchd / systemd start the daemon
 // with a stripped PATH that often lacks nvm / homebrew, breaking spawn(claudeBin).
 const NODE_BIN_DIR = dirname(process.execPath);
@@ -776,6 +777,7 @@ export const startMirrorTail = (deps) => {
             clearInterval(poll);
         },
         drain,
+        livePath: resolveLive,
     };
 };
 // Run a tmux subcommand, capturing stdout/stderr. Delegates to spawn-tmux's
@@ -1499,6 +1501,9 @@ export const startMirror = (deps) => {
         if (s.closed)
             return;
         s.closed = true;
+        // 非 brief 路径的父 turn 收口 — subagent turns 一并关 (brief 路径在
+        // closeBriefTurn 关, 双关幂等)。
+        closeSubagentTurns(a);
         if (s.flushTimer) {
             clearTimeout(s.flushTimer);
             s.flushTimer = undefined;
@@ -1577,7 +1582,14 @@ export const startMirror = (deps) => {
         }
         return withSessionTag(a.target, content, seq);
     };
+    // 空正文一票否决 (近源拦截): 剥掉可能存在的路由头 (`🦊 #tag` / `[🧙](url)`)
+    // 后没有可见内容就不发。中央 chat-gate (last-response 的 SDK 包装) 是最后一道
+    // 防线; 这里拦在源头 —— 空内容不进 standalonePending FIFO、不占防抖 buf、
+    // 不重置计时器, 免得"空 part 入队 → flush 时 join 出空串"的死角。
+    const hasVisibleBody = (content) => parseTagHeader(content).body.length > 0;
     const sendStandalone = (a, content) => {
+        if (!hasVisibleBody(content))
+            return;
         const chatId = stripPrincipalPrefix(a.target);
         const pieces = splitChunks(content, Math.max(200, cfg.wrc.mirror.chunkBytes - TAG_HEADER_BUDGET));
         const chunks = pieces.map((p, i) => withLinkedTag(a, p, pieces.length > 1 ? `${i + 1}/${pieces.length}` : undefined));
@@ -1596,6 +1608,8 @@ export const startMirror = (deps) => {
     };
     // Like sendStandalone but skips withSessionTag — content already contains the tag header (e.g. as a link).
     const sendRaw = (a, content) => {
+        if (!hasVisibleBody(content))
+            return;
         const chatId = stripPrincipalPrefix(a.target);
         a.standalonePending = a.standalonePending
             .then(async () => {
@@ -1633,16 +1647,20 @@ export const startMirror = (deps) => {
     };
     // Debounce 聚合: 仅 standalone 路径用。窗口内 onItem 多次落入 → 合并成单条 markdown。
     // 0 关闭时退化为透传。flushStandalone 也用于 detach / teardown 时的 drain。
+    // parts 在 enqueue 时已过 hasVisibleBody, flush 端再过滤一遍是纵深防御 ——
+    // 防的是绕过 enqueue 直写 buf 的未来代码路径。
     const flushStandalone = (a) => {
         const buf = a.standaloneBuf;
         if (!buf)
             return;
-        const merged = buf.parts.join("\n\n");
         a.standaloneBuf = undefined;
+        const merged = buf.parts.filter((p) => hasVisibleBody(p)).join("\n\n");
         if (merged)
             sendStandalone(a, merged);
     };
     const enqueueStandalone = (a, content) => {
+        if (!hasVisibleBody(content))
+            return;
         const ms = cfg.wrc.mirror.standaloneDebounceMs;
         if (ms <= 0) {
             sendStandalone(a, content);
@@ -2015,7 +2033,9 @@ export const startMirror = (deps) => {
         a.briefConcluded = false;
         a.briefLastText = undefined;
         clearCot(a);
-        sendRaw(a, briefDetailLink(turnId, a.target));
+        // 链接暂存, 不再单独发 — 让首条 standalone body 取走拼到前缀, 一条消息解决。
+        // turn 始终会通过 concludeBriefTurn / closeBriefTurn 收口, header 不会泄漏。
+        a.pendingBriefHeader = briefDetailLink(turnId, a.target);
         log.info({ sessionId: a.sessionId, turnId }, "brief: turn started (CLI-side, no bubble)");
     };
     // 本轮出现过工具调用 / tool_result / 非 final 文本 —— 只记状态: 详情链接从 ack 起
@@ -2026,19 +2046,28 @@ export const startMirror = (deps) => {
         a.briefHadTool = true;
     };
     // 本轮结论落地, 只生效一次:
-    //   • 气泡仍开 (ack 时的 `链接 …` 还在) → 以 `链接 正文` 覆盖收口;
-    //   • 气泡已收 (过 6min 窗口 / 已收口) 或无气泡 turn (CLI 侧发起) → body 走 standalone,
-    //     那条 standalone 自带 `链接` 头 (withLinkedTag / ensureBriefTurn 已发过详情链接)。
+    //   • 气泡仍开 (ack 时的 `链接 …` 还在) → 以 `链接 正文` 覆盖收口; ensureBriefTurn
+    //     暂存的 header 跟着 bubble 收口一并丢 (气泡内已自带链接)。
+    //   • 气泡已收 (过 6min 窗口 / 已收口) 或无气泡 turn (CLI 侧发起) → 把暂存 header
+    //     拼到 body 前缀一并 standalone, 一条消息含详情入口 + 正文。
+    //   • body 为空 → 一个字不发, 顺手清掉 header, 不留"只有链接"的空消息。
     const concludeBriefTurn = (a, body) => {
         const turnId = a.briefTurnId;
-        if (!turnId || a.briefConcluded || !body.trim())
+        if (!turnId || a.briefConcluded)
+            return;
+        if (!body.trim()) {
+            a.pendingBriefHeader = undefined;
             return;
+        }
         a.briefConcluded = true;
         if (a.briefBubble && !a.briefBubble.done) {
             void finishBriefBubble(a, `${briefDetailLink(turnId, a.target)} ${body}`, true);
+            a.pendingBriefHeader = undefined;
         }
         else {
-            sendStandalone(a, body);
+            const header = a.pendingBriefHeader;
+            a.pendingBriefHeader = undefined;
+            sendStandalone(a, header ? `${header} ${body}` : body);
         }
         // 只保留当前 turn: 其余仍开着的 turn 记录是漏收的 close, 一并扫掉。
         recordCloseOpenTurns({ target: a.target, sessionId: a.sessionId, exceptIds: [turnId] });
@@ -2060,8 +2089,123 @@ export const startMirror = (deps) => {
         a.briefIsSlash = false;
         a.briefConcluded = false;
         a.briefLastText = undefined;
+        a.pendingBriefHeader = undefined;
+        closeSubagentTurns(a); // 父 turn 收口 = 它派出的 subagent 都已结束
         clearCot(a);
     };
+    // ── Subagent turns ─────────────────────────────────────────────────
+    // Task/Agent 工具派出的子 agent 在自己的转录文件里跑 (主 jsonl 只有派发与最终
+    // 总结)。subagent-tail 把过程流式吐到这里: 记成带 agent 标记的 turn (chat
+    // detail 时间轴内联展示), 并在 brief 气泡里以 `🤖 label · 最新活动` 驱动 CoT
+    // 进度行 —— 父 agent 阻塞在 Agent 调用上时, 子 agent 就是唯一的进度来源,
+    // last-writer-wins 让"最后的消息是 agent 调用"期间气泡展示的正是 agent 内状态。
+    // agent 类型归属: claude 的 meta.json 优先; codebuddy 没有 meta — 用父侧捕获的
+    // Task/Agent 入参按 prompt 原文对上 (子文件首行 user 内容 == input.prompt,
+    // codebuddy 实测逐字一致), 对不上再退到最近一次调用。
+    // 返回值同喂两条消费方: detail 记录的 agent.type/description 与 brief 进度行的
+    // label —— 二者必须同源, 否则"支持 codebuddy"时页面上叫 `🤖 subagent`、气泡里却
+    // 叫解析出的类型, 自相矛盾。undefined = 无从归属 (老文件无 meta 且父侧无调用)。
+    const resolveSubagentMeta = (a, task, meta) => {
+        if (meta.type || meta.description)
+            return { ...meta, label: meta.type ?? meta.description.slice(0, 24) };
+        const calls = a.agentCalls ?? [];
+        const hit = calls.find((c) => c.prompt && (c.prompt === task || task.startsWith(c.prompt) || c.prompt.startsWith(task)));
+        const m = hit ?? [...calls].reverse().find((c) => Date.now() - c.at < 10 * 60_000);
+        if (!m)
+            return undefined;
+        const { type, description } = m;
+        return { type, description, label: type ?? description?.slice(0, 24) ?? "subagent" };
+    };
+    const closeSubagentRun = (a, agentId) => {
+        const run = a.subagents?.get(agentId);
+        if (!run || run.closed)
+            return;
+        run.closed = true;
+        recordTurnClose(run.turnId);
+    };
+    // 关掉该 attachment 所有开着的 subagent turn。父 turn 收口 (closeBriefTurn /
+    // finalizeStream / detach / migrate) 时调用 — subagent 必然先于父 turn 结束,
+    // 父都收了, 子的开着只会让页面永远「运行中」。
+    const closeSubagentTurns = (a) => {
+        for (const id of a.subagents?.keys() ?? [])
+            closeSubagentRun(a, id);
+    };
+    const handleSubagentItem = (a, agentId, item) => {
+        if (!a.subagents)
+            a.subagents = new Map();
+        let run = a.subagents.get(agentId);
+        const now = Date.now();
+        // 首个 item 懒建 turn — task 行建在开头 (userQuery=任务原文), EOF 起步的存量
+        // agent 任何 item 都能建 (userQuery 缺省), 不丢过程。
+        if (!run && item.kind !== "end") {
+            const task = item.kind === "task" ? item.body : undefined;
+            const meta = item.kind === "task" ? item.meta : {};
+            const resolved = resolveSubagentMeta(a, task ?? "", meta);
+            const turnId = newTurnId();
+            run = { turnId, label: resolved?.label ?? "subagent", closed: false };
+            a.subagents.set(agentId, run);
+            recordTurnStart({
+                id: turnId,
+                target: a.target,
+                sessionId: a.sessionId,
+                cwd: a.runningCwd || undefined,
+                userQuery: task,
+                agent: { id: agentId, type: resolved?.type, description: resolved?.description },
+            });
+            log.info({ agentId, turnId, label: run.label }, "subagent: turn started");
+            if (item.kind === "task")
+                return;
+        }
+        if (!run || run.closed)
+            return;
+        switch (item.kind) {
+            case "task":
+                return; // 已在建 turn 时消费
+            case "text":
+                recordTurnItem(run.turnId, { t: "text", body: item.body, ts: now, final: item.final });
+                break;
+            case "tool_use":
+                for (const c of item.calls) {
+                    recordTurnItem(run.turnId, { t: "tool_use", toolUseId: c.toolUseId, toolName: c.name, toolInput: c.input, ts: now });
+                }
+                break;
+            case "tool_result":
+                recordTurnItem(run.turnId, { t: "tool_result", toolUseId: item.toolUseId, body: item.full, ts: now });
+                break;
+            case "usage":
+                recordTurnUsage(run.turnId, { model: item.model, messageId: item.messageId, usage: item.usage });
+                break;
+            case "end":
+                closeSubagentRun(a, agentId);
+                return;
+        }
+        // brief 气泡的实时进度: 静默窗 (keepalive 吞没 / 新 pane 未注入) 不推;
+        // updateBriefProgress 自身会检查气泡是否仍开。final text 之后的 end 会很快
+        // 收口气泡, 进度行不会残留。
+        if (a.muteUntilInject || a.keepaliveQuiet || a.keepaliveByContent)
+            return;
+        const activity = item.kind === "tool_use"
+            ? cotToolLabel(item.calls)
+            : item.kind === "thinking" || item.kind === "text"
+                ? item.body
+                : "";
+        if (activity)
+            updateBriefProgress(a, `🤖 ${run.label} · ${activity}`);
+    };
+    // (重新) 挂上 subagent watch — attach 与 migrateAttachment 共用; 会话轮换后
+    // sessionId 变了, 旧 watch 的目录定位随之作废, 必须重建。
+    const startSubagentsFor = (a) => {
+        a.subagentWatch?.stop();
+        closeSubagentTurns(a);
+        a.subagents = new Map();
+        a.subagentWatch = startSubagentWatch({
+            log: log.child({ sub: "subagents", sessionId: a.sessionId }),
+            sessionId: a.sessionId,
+            liveJsonlPath: () => a.tail.livePath(),
+            normalizeLine: backendForPath(a.jsonlPath).normalizeTranscriptLine,
+            onAgentItem: (agentId, item) => handleSubagentItem(a, agentId, item),
+        });
+    };
     // 强制收口一个 attachment 的全部出站通道, 并返回收掉的气泡/流条数。
     //
     // 关键约束: **一个 tmux 调用都不许有**。它的两个调用方 (`/stop` 和 inject
@@ -2080,6 +2224,7 @@ export const startMirror = (deps) => {
             clearTimeout(a.softEnd);
             a.softEnd = undefined;
         }
+        closeSubagentTurns(a); // brief/liveStream 都不在的收口路径也把 subagent 关掉
         if (a.outbound) {
             if (a.outbound.kind === "deferred")
                 clearTimeout(a.outbound.timer);
@@ -2192,9 +2337,14 @@ export const startMirror = (deps) => {
             // loading 气泡。非 slash 场景的 skill_output 是用户可见的中间反馈, 走 standalone。
             if (a.briefIsSlash && !a.briefHadTool && a.briefBubble && !a.briefBubble.done) {
                 void finishBriefBubble(a, item.body);
+                a.pendingBriefHeader = undefined;
             }
             else {
-                sendStandalone(a, item.body);
+                // CLI-driven turn: 把 ensureBriefTurn 暂存的详情链接拼到 body 前缀, 避免
+                // "只发了一条 link 渲染成空文本" 的前置消息。
+                const header = a.pendingBriefHeader;
+                a.pendingBriefHeader = undefined;
+                sendStandalone(a, header ? `${header} ${item.body}` : item.body);
             }
             return;
         }
@@ -2373,6 +2523,17 @@ export const startMirror = (deps) => {
                         break;
                     a.recentToolSigs.delete(oldest);
                 }
+                // Task/Agent 派发入参留档 — subagent 文件本身不带类型信息 (codebuddy),
+                // subagentLabel 拿它按 prompt 匹配出 agent 类型。
+                if (c.name === "Task" || c.name === "Agent") {
+                    const inp = c.input;
+                    a.agentCalls = [...(a.agentCalls ?? []).slice(-8), {
+                            prompt: typeof inp?.prompt === "string" ? inp.prompt : "",
+                            type: typeof inp?.subagent_type === "string" && inp.subagent_type ? inp.subagent_type : undefined,
+                            description: typeof inp?.description === "string" && inp.description ? inp.description : undefined,
+                            at: Date.now(),
+                        }];
+                }
                 // codebuddy 的 ExitPlanMode 完全不过 PreToolUse hook (实测: 由
                 // interruption-service 本地对话框裁决, HookExecutor 零调用)。mirror 从
                 // jsonl 看到 function_call → 发计划审批卡; 点选后 send-keys 裁决本地
@@ -2605,6 +2766,9 @@ export const startMirror = (deps) => {
             clearTimeout(a.standaloneBuf.timer);
             flushStandalone(a);
         }
+        a.subagentWatch?.stop();
+        a.subagentWatch = undefined;
+        closeSubagentTurns(a);
         a.tail.stop();
         bySessionId.delete(a.sessionId);
         if (byTarget.get(a.target) === a)
@@ -2659,7 +2823,7 @@ export const startMirror = (deps) => {
             // collapsing to cfg.wrc.cwd (which would mislabel /pwd, /clear, /new).
             runningCwd: expandHome(((cwd ?? "").trim()) || readCwdFromJsonl(jsonlPath) || cfg.wrc.cwd),
             pendingCwd: carryPending,
-            tail: { stop: () => undefined, drain: () => undefined }, // placeholder; replaced below
+            tail: { stop: () => undefined, drain: () => undefined, livePath: () => undefined }, // placeholder; replaced below
             standalonePending: Promise.resolve(),
             recentToolSigs: new Map(),
         };
@@ -2682,6 +2846,7 @@ export const startMirror = (deps) => {
             // what lets a claude session and a codebuddy session be mirrored at once.
             normalizeLine: backendForPath(jsonlPath).normalizeTranscriptLine,
         });
+        startSubagentsFor(a);
         bySessionId.set(sessionId, a);
         byTarget.set(target, a);
         // Preserve a persisted `/stop` pause across the re-attach: restore rebuilds the
@@ -3065,6 +3230,8 @@ export const startMirror = (deps) => {
             // path, not by CLI) — re-derive the dialect from the destination.
             normalizeLine: backendForPath(newJsonlPath).normalizeTranscriptLine,
         });
+        // 会话轮换 = 新 <sid>/subagents/ 目录; 旧 run 的 turn 一并收口。
+        startSubagentsFor(a);
         deps.store.set(a.target, {
             sessionId: newSessionId,
             jsonlPath: newJsonlPath,
@@ -3942,8 +4109,10 @@ export const startMirror = (deps) => {
                 // Stall recovery, decided by RULE only (no model self-judgment): the last
                 // transcript turn is a synthetic API-error/limit line, or the idle pane
                 // still shows an error banner ⇒ a turn died mid-work. Send the resume
-                // instruction instead of the plain warmer.
-                const stalled = kc.resumeOnStall && (transcriptStalled(a.jsonlPath) || paneIsStalled(paneTail));
+                // instruction instead of the plain warmer. A limit-parked episode is
+                // excluded: retrying before resetsAt only buys another 429 line —
+                // limitResumeTick owns that recovery, anchored on the reset moment.
+                const stalled = kc.resumeOnStall && !a.limitResume && (transcriptStalled(a.jsonlPath) || paneIsStalled(paneTail));
                 k.pinging = true;
                 k.pingMtime = k.lastMs; // settles when a newer turn (the ping's own) appears
                 await fireKeepalive(a, stalled);
@@ -3957,6 +4126,83 @@ export const startMirror = (deps) => {
         }
     };
     const keepaliveTimer = setInterval(() => void keepaliveTick(), 15_000);
+    // ── Rate-limit auto-resume ────────────────────────────────────────────
+    // Detection is poll-derived from the transcript tail every tick (limitResetAt:
+    // "last message turn IS a 429 line"), so there is nothing to persist — a
+    // daemon reload, a human retry in the TTY, or our own inject all converge
+    // naturally: any newer turn makes detection stop firing and drops the state.
+    const fmtClock = (ms) => {
+        const d = new Date(ms);
+        return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
+    };
+    let limitResumeTicking = false;
+    const limitResumeTick = async () => {
+        const lr = cfg.wrc.mirror.limitResume;
+        if (!lr.enabled || limitResumeTicking)
+            return;
+        limitResumeTicking = true;
+        try {
+            const now = Date.now();
+            for (const a of byTarget.values()) {
+                const resetsAt = limitResetAt(a.jsonlPath, now);
+                if (!resetsAt) {
+                    a.limitResume = undefined;
+                    continue;
+                }
+                if (a.migrationWatcher)
+                    continue; // session rotating — judge after it settles
+                if (a.keepaliveOff)
+                    continue; // /stop = deliberately quieted; honor it
+                if (a.limitResume?.resetsAt !== resetsAt)
+                    a.limitResume = { resetsAt, notified: false, retried: false };
+                const st = a.limitResume;
+                const dueAt = resetsAt + lr.delaySec * 1000;
+                if (!st.notified) {
+                    st.notified = true;
+                    log.info({ target: a.target, resetsAt, dueAt }, "limit-resume: parked, retry scheduled");
+                    sendStandalone(a, `[mirror] ⏳ 已触限额 (reset ${fmtClock(resetsAt)}) — ${fmtClock(dueAt)} 自动注入 \`${lr.text}\` 续跑`);
+                }
+                if (st.retried || now < dueAt)
+                    continue;
+                if (a.liveStream && !a.liveStream.closed)
+                    continue; // mid typewriter — don't inject
+                if (a.tmuxPane) {
+                    // Pane mode: a dead pane means the human closed shop — auto-respawning
+                    // a TUI at 3am would be a surprise, not a service. Busy means someone
+                    // (human, or another turn) is already driving; detection clears itself
+                    // once their turn lands. Spawn-mode has no pane and no such hazards —
+                    // inject's `claude --resume -p` fallback IS its normal operation.
+                    if (!(await tmuxPaneAlive(a.tmuxPane)))
+                        continue;
+                    if (paneIsBusy(await capturePaneTail(a.tmuxPane, 16)))
+                        continue;
+                }
+                st.retried = true;
+                // Unlike keepalive there is no swallow: the resumed work is real work —
+                // the tail mirrors its output to chat normally. rememberInject only
+                // suppresses the echo of the injected user line itself.
+                rememberInject(lr.text);
+                const r = await inject({
+                    text: lr.text, images: [], cfg,
+                    log: log.child({ target: a.target, sessionId: a.sessionId, sub: "limit-resume" }),
+                    sessionId: a.sessionId, jsonlPath: a.jsonlPath, tmuxTarget: a.tmuxPane,
+                });
+                if (!r.ok) {
+                    st.retried = false; // roll back so the next tick retries the inject
+                    log.warn({ target: a.target, reason: r.reason }, "limit-resume: inject failed");
+                    continue;
+                }
+                log.info({ target: a.target, resetsAt }, "limit-resume: resume injected");
+            }
+        }
+        catch (e) {
+            log.warn({ err: e.message }, "limit-resume tick failed");
+        }
+        finally {
+            limitResumeTicking = false;
+        }
+    };
+    const limitResumeTimer = setInterval(() => void limitResumeTick(), 30_000);
     return {
         attach,
         chatTargets,
@@ -4347,6 +4593,7 @@ export const startMirror = (deps) => {
         shutdown: () => {
             clearInterval(paneDriftTimer);
             clearInterval(keepaliveTimer);
+            clearInterval(limitResumeTimer);
             for (const a of bySessionId.values()) {
                 if (a.outbound?.kind === "deferred")
                     clearTimeout(a.outbound.timer);