wezard 2.1.4 → 2.2.1

package/dist/daemon/mirror-bridge.js

@@ -13,7 +13,7 @@
 // Caveat: the user shouldn't be hammering the same session in their local TTY
 // while a `--resume` injection is in flight; Claude Code locks aren't strict.
 import { spawn } from "node:child_process";
-import { existsSync, readdirSync, statSync, watch, openSync, readSync, closeSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync, statSync, watch, openSync, readSync, closeSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { expandHome, sanitizeId } from "../shared/paths.js";
 import { augmentedPath } from "../shared/exec-path.js";
@@ -26,15 +26,17 @@ import { noticeSuffixFor } from "./notices.js";
 import { dangerOf } from "./danger.js";
 import { runTmux, spawnTmuxClaude } from "./spawn-tmux.js";
 import { selectModel } from "./model-select.js";
-import { hasRegistry, markTranscript, probeOf, sessionOnPane, sessionPanes, submittedSince } from "./cc-session.js";
+import { hasRegistry, markTranscript, probeOf, sessionOnPane, sessionPanes, submittedSince, watchRegistry } from "./cc-session.js";
+import { waitForIdle } from "./graph.js";
 import { wizardStore } from "./wizard.js";
 import { startSubagentWatch } from "./subagent-tail.js";
-import { recordTool, recordToolResult, recordMark, recordTurnStart, recordTurnQuery, recordTurnItem, recordTurnUsage, recordTurnClose, recordCloseOpenTurns, lastChannelOf, buildDetailUrl, buildChatUrl, roleUniq } from "./detail.js";
+import { knowsToolUse, recordTool, recordToolResult, recordMark, recordTurnStart, recordTurnQuery, recordTurnItem, recordTurnUsage, recordTurnClose, recordCloseOpenTurns, lastChannelOf, buildDetailUrl, buildChatUrl, roleUniq } from "./detail.js";
 import { labelFor, tagOfKey, baseOfKey, keyOf, stripSigil, displayName, withTagHeader, withLinkedTagHeader, linkedTagHead, linkTags, parseTagHeader, MAX_BODY_LINKS } from "../shared/session-label.js";
 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, unwrapPasted, lastContextTokens, keepaliveStamps, openKeepalivePing, keepalivePingSigs, isKeepalivePingText, talkRounds, openToolUses, renderDialog } from "./peers.js";
+import { stripAnsi, paneIsBusy, transcriptStalled, summarizeTail, lastAssistantText, lastReply, replyToPeer as replyToPeerIn, unwrapPasted, lastContextTokens, keepaliveStamps, openKeepalivePing, 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).
 // Backend resolution is per-transcript, not global: `backendForPath` recovers
@@ -433,6 +435,43 @@ const renderToolUseGroupBody = (calls, deps) => {
     });
     return [header, ...lines].join("\n");
 };
+// 从尾往前, 逐个产出含 needle 的整行 —— 只切命中的那几行, 不把整份 transcript 拆成数组。
+function* linesWithFromEnd(text, needle) {
+    let at = text.lastIndexOf(needle);
+    while (at >= 0) {
+        const s = text.lastIndexOf("\n", at) + 1;
+        const e = text.indexOf("\n", at);
+        yield text.slice(s, e < 0 ? undefined : e);
+        at = s > 0 ? text.lastIndexOf(needle, s - 1) : -1;
+    }
+}
+// tail 漏看了某次 tool_use (daemon 停机窗口里落盘的行 —— 恢复后的 tail 从 EOF 起读;
+// 一个挂了几小时的审批最常撞上), 结果却到了: 回 transcript 按 id 把调用本身捞回来。
+const recoverToolUse = (toolUseId, deps) => {
+    let text;
+    try {
+        text = readFileSync(deps.jsonlPath, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+    for (const raw of linesWithFromEnd(text, toolUseId)) {
+        let line;
+        try {
+            line = JSON.parse(raw);
+        }
+        catch {
+            continue;
+        }
+        if (deps.normalizeLine)
+            line = deps.normalizeLine(line);
+        const blocks = line?.type === "assistant" ? line.message?.content : undefined;
+        const b = Array.isArray(blocks) ? blocks.find((x) => x?.type === "tool_use" && x.id === toolUseId) : undefined;
+        if (b)
+            return { toolUseId, name: b.name ?? "tool", input: b.input };
+    }
+    return undefined;
+};
 // Render one transcript line into tagged items. Caller decides batching.
 const renderLine = (raw, deps) => {
     let line;
@@ -533,6 +572,12 @@ const renderLine = (raw, deps) => {
                     continue;
                 const toolUseId = b.tool_use_id ?? "";
                 const full = truncateWithCount(raw, DETAIL_RESULT_MAX);
+                // 孤儿 result: 先补发它的调用, 下游 (turn store / 气泡) 就和 tail 当场看到时一样配对。
+                const lost = toolUseId && deps.includeTools && !knowsToolUse(toolUseId) ? recoverToolUse(toolUseId, deps) : undefined;
+                if (lost) {
+                    recordTool({ id: lost.toolUseId, toolName: lost.name, toolInput: lost.input, sessionId: deps.sessionId, target: deps.target });
+                    out.push({ kind: "tool_use", calls: [lost], body: renderToolUseGroupBody([lost], deps) });
+                }
                 // 始终把完整 result 落 detail 库 + 作为 tool_result item 发出 — 与
                 // includeToolResults(气泡推送开关)彻底解耦: 关掉气泡时 detail 页与 brief
                 // turn 页(handleBriefItem 消费本 item 写 turn store)都仍要看到 result。
@@ -3596,17 +3641,18 @@ export const startMirror = (deps) => {
     const RESTORE_CONC = 8;
     const persisted = deps.store.all();
     const persistedKeys = Object.keys(persisted);
+    let restored = Promise.resolve();
     if (persistedKeys.length > 0) {
         // 裸 fan-out 会把 2N 次 tmux 同时压下去 —— 几百个绑定就是七百个 client 一起
         // 撞 10s 超时, spawn 风暴顺带把事件循环压住, :17890 要 25s 才 bind, 而 CLI 的
         // reload 探测早放弃了 (「reload issued but /status not responding」的真身)。
         // 一张快照 + 封顶并发; await 立刻让出, startHttp 先绑端口。
-        void (async () => {
+        restored = (async () => {
             const snap = await runTmux(["list-panes", "-a", "-F", "#{pane_id}\t#{pane_current_path}"]);
             const panes = snap.ok ? parsePaneList(snap.stdout) : undefined;
             await mapLimit(persistedKeys, RESTORE_CONC, (principal) => restoreFromStore(principal, panes));
             log.info({ restored: persistedKeys.length, panes: panes?.size ?? -1 }, "mirror: boot restore done");
-        })();
+        })().catch((e) => { log.warn({ err: e.message }, "mirror: boot restore failed"); });
     }
     else if (cfg.wrc.mirror.sessionId.trim()) {
         // Pinned-sessionId fallback: only honor when the store is empty (otherwise
@@ -4243,7 +4289,7 @@ export const startMirror = (deps) => {
             // Pause keepalive like /stop; the first real turn (WeCom inbound, or the
             // pane going busy after the resume grace) re-earns the budget. Mirrors
             // interruptPane so /new can't strand a ping loop on an idle blank session.
-            spawned.keepaliveOff = true;
+            spawned.keepaliveOff = !opts?.warm;
             spawned.keepaliveOffAt = Date.now();
             spawned.keepalive = undefined; // re-anchors cleanly on resume
             persistPause(spawned);
@@ -4573,6 +4619,57 @@ export const startMirror = (deps) => {
     // and it keeps a graph step from blocking forever on a session that vanished.
     const paneBusy = async (pane) => !!pane && (await tmuxPaneAlive(pane)) && paneIsBusy(await capturePaneTail(pane, 12));
     const isBusy = (target) => paneBusy(paneOf(target));
+    // 「它这一轮结束了、可以投了」。注册表认得这个 pane 时以它为准: status 在整轮里
+    // (工具调用之间、PreToolUse 审批 hook 挂着时) 一直是 busy, 只在轮结束那一刻翻成
+    // idle —— 所以不必抽样 spinner, 也不必连数几次安静来排除工具间隙。idle 却悬着工具
+    // 调用 = 停在本地审批框上等人点, 不算闲。注册表不认得 (codebuddy / 旧版 CC /
+    // 会话已退出) 返回 undefined, 交给 pane 裁决。
+    const idleVerdict = (target) => {
+        const pane = paneOf(target);
+        const live = pane ? activeBackends().map((b) => sessionOnPane(b.homeDir, pane)).find(Boolean) : undefined;
+        if (!live)
+            return undefined;
+        if (live.status === "busy")
+            return false;
+        if (live.status !== "idle")
+            return undefined;
+        const bound = jsonlOf(target);
+        // resume / fork 会换 sid: 悬着的工具调用记在注册表报的当前那份 transcript 里。
+        const jsonl = bound ? join(dirname(bound), `${live.sessionId}.jsonl`) : "";
+        return !(jsonl && existsSync(jsonl) && openToolUses(jsonl).length > 0);
+    };
+    const idleNow = async (target) => idleVerdict(target) ?? !(await isBusy(target));
+    // 等到它闲下来, 事件驱动: 注册表目录一有写入就重判, 翻成 idle 的那一刻即返回。
+    // 兜底轮询只防 watch 漏事件 (以及悬着的审批被点掉后 status 没再动的边角)。
+    const IDLE_SAFETY_POLL_MS = 1000;
+    const untilIdle = (target, timeoutMs) => {
+        if (idleVerdict(target) === undefined)
+            return waitForIdle(target, isBusy, timeoutMs, () => false, { rampMs: 0, confirm: 2 });
+        return new Promise((resolve) => {
+            let done = false;
+            const finish = (r) => {
+                if (done)
+                    return;
+                done = true;
+                unwatch.forEach((f) => f());
+                clearInterval(tick);
+                clearTimeout(timer);
+                resolve(r);
+            };
+            // 会话中途退出 (注册表不认得了): pane 也不忙就是「那里什么都没在跑」, 与 isBusy 同一口径。
+            const check = async () => {
+                if (done)
+                    return;
+                const v = idleVerdict(target);
+                if (v ?? !(await isBusy(target)))
+                    finish({ idle: true });
+            };
+            const unwatch = activeBackends().map((b) => watchRegistry(b.homeDir, () => void check()));
+            const tick = setInterval(() => void check(), IDLE_SAFETY_POLL_MS);
+            const timer = setTimeout(() => finish({ idle: false, reason: "idle wait timed out" }), timeoutMs);
+            void check();
+        });
+    };
     const lastText = (target) => {
         const p = jsonlOf(target);
         return p ? lastAssistantText(p, 4000, warmerSigs) : "";
@@ -4581,6 +4678,15 @@ export const startMirror = (deps) => {
         const p = jsonlOf(target);
         return p ? lastReply(p, sinceMs, warmerSigs) : "";
     };
+    const replyToPeerSince = (target, fromName, sinceMs = 0) => {
+        const p = jsonlOf(target);
+        return p ? replyToPeerIn(p, fromName, sinceMs, warmerSigs) : undefined;
+    };
+    /** 绑着的 pane 还能用 (存在、且不是别人的窗口) —— 不重生、不猜。 */
+    const paneLiveOf = async (target) => {
+        const a = byTarget.get(target);
+        return a?.tmuxPane ? paneUsable(a.tmuxPane, a.jsonlPath) : false;
+    };
     // ── 未收口气泡的引用判定 ────────────────────────────────────────────
     // tag 会话的 last stream 未收口时, 群里最新那条气泡是瞬态的: 详情链接 URL +
     // 最新一条实时 CoT/工具行 (brief) 或累积中的 acc (非 brief)。引用它要的是路由,
@@ -5043,6 +5149,8 @@ export const startMirror = (deps) => {
         chatRoster,
         peekTurns,
         isBusy,
+        idleNow,
+        untilIdle,
         setModel: async (target, wanted, scope) => {
             const a = byTarget.get(target);
             if (!a?.tmuxPane || !(await tmuxPaneAlive(a.tmuxPane)))
@@ -5069,6 +5177,9 @@ export const startMirror = (deps) => {
         }),
         lastText,
         lastReply: replySince,
+        replyToPeer: replyToPeerSince,
+        paneLive: paneLiveOf,
+        restored,
         isOpenBubbleQuote,
         status: () => {
             const list = Array.from(bySessionId.values()).map((a) => ({
@@ -5238,8 +5349,12 @@ export const startMirror = (deps) => {
             if (!text.trim())
                 return { ok: false, reason: "empty text" };
             // 出处改写要早于 inject: tail 可能在 promise resolve 之前就开出 turn。
-            if (opts?.fromChat)
-                a.turnFromChat = true;
+            // 守护进程注入的一轮 (回执 / peer / 定时任务 / graph) 不是人在 CLI 手敲的: 可见性
+            // 只由频道定 ("" 私聊才静默)。pendingFromCli 必须一并清 —— 它是粘性的, 不开轮的
+            // CLI 行 (spawn 时 model-select 按下的 `/model`) 会把它一直挂到下一轮, 让紧跟着的
+            // 注入轮被认成 CLI 发起, 公开频道里的回复因此被出处门吞掉。
+            a.pendingFromCli = false;
+            a.turnFromChat = true;
             // 名册增量搭这趟车进去 —— 同伴派活 / 定时任务 / graph 步骤都走这里, 所以
             // 一个从不被人直接说话的分身也能知道群里多了谁、少了谁。人说的话那一条
             // 路径在 inbound.send 上挂 (dispatch 有自己的 inject)。
@@ -5262,9 +5377,6 @@ export const startMirror = (deps) => {
             // 注入的那一行会被 recentInjects 当回显吞掉, 走不到 user_text —— 本轮的 query
             // (rolepage 上「谁对它说了什么」那一半) 只能在这里记。
             a.pendingBriefQuery = text;
-            // 公开频道里说的话, 回复就该在群里看得见 —— 哪怕上一轮是人在 CLI 里敲的。
-            if (opts?.channel)
-                a.turnFromChat = true;
             const sid = a.sessionId;
             const paneAlive = a.tmuxPane ? await paneUsable(a.tmuxPane, a.jsonlPath) : false;
             if (!paneAlive) {
@@ -5287,10 +5399,22 @@ export const startMirror = (deps) => {
             // 同 dispatch: 在 inject 之前解除静默, 防止验证循环中 LLM 回复被永久吞掉。
             a.muteUntilInject = false;
             a.justSpawned = false;
+            // 同 dispatch 的 /clear 与静默分叉跟随: self-handoff / 同伴 / 定时任务也走这里注入,
+            // 漏了它 tail 就钉在旧 jsonl 上, 直到下一条人话经 dispatch 才把它拽回来。
+            const clearing = isClearCommand(text);
+            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,
             });
+            if (r.ok && a.tmuxPane) {
+                if (preClearBaseline) {
+                    a.clearRebind = { baseline: preClearBaseline };
+                    startMigrationWatcher(a, preClearBaseline, jsonlIsPostClearChild, 0, true);
+                }
+                else
+                    armSilentForkRebind(a, full);
+            }
             return r;
         },
         interruptPane: async (target, opts) => {