wezard 1.1.4 → 1.2.0

package/dist/daemon/mirror-bridge.js

@@ -23,7 +23,7 @@ import { recordTool, recordToolResult, recordTurnStart, recordTurnItem, recordTu
 import { labelFor, tagOfKey, baseOfKey, withTagHeader } from "../shared/session-label.js";
 import { splitMarkdown } from "../shared/md-chunk.js";
 import { randomTip } from "./tips.js";
-import { stripAnsi, compactPane, paneIsBusy, summarizeTail, lastAssistantText } from "./peers.js";
+import { stripAnsi, compactPane, paneIsBusy, summarizeTail, lastAssistantText, lastContextTokens } 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);
@@ -1910,7 +1910,47 @@ export const startMirror = (deps) => {
         if (a.liveStream && !a.liveStream.closed)
             void finalizeStream(a, a.liveStream);
     };
+    // Close the keepalive quiet window — the ping turn is over (or the fail-safe
+    // fired), so subsequent real items flow through onItem normally again.
+    const endKeepaliveQuiet = (a) => {
+        if (!a.keepaliveQuiet)
+            return;
+        clearTimeout(a.keepaliveQuiet);
+        a.keepaliveQuiet = undefined;
+    };
     const onItem = (a, item) => {
+        // Keepalive ping turns are cache-warmers: swallow every item from the WeCom
+        // paths so the ping/pong never reaches chat. But record the REAL exchange
+        // into its chat-detail turn — the actual assistant reply (expected: just
+        // "pong"), the tool calls if any, and the usage (proof it was a cheap
+        // cache-read) — so the detail page shows the genuine heartbeat, not a
+        // synthetic summary. Closed on the terminal signal (hard or soft turn_end).
+        if (a.keepaliveQuiet) {
+            const id = a.keepaliveTurnId;
+            if (id) {
+                const now = Date.now();
+                if (item.kind === "text") {
+                    recordTurnItem(id, { t: "text", body: item.body, ts: now, final: item.final === true });
+                }
+                else if (item.kind === "tool_use") {
+                    for (const c of item.calls)
+                        recordTurnItem(id, { t: "tool_use", toolUseId: c.toolUseId, toolName: c.name, toolInput: c.input, ts: now });
+                }
+                else if (item.kind === "tool_result") {
+                    recordTurnItem(id, { t: "tool_result", toolUseId: item.toolUseId, body: item.full, ts: now });
+                }
+                else if (item.kind === "turn_usage") {
+                    recordTurnUsage(id, { model: item.model, messageId: item.messageId, usage: item.usage });
+                }
+                else if (item.kind === "turn_end") {
+                    recordTurnClose(id);
+                    a.keepaliveTurnId = undefined;
+                }
+            }
+            if (item.kind === "turn_end")
+                endKeepaliveQuiet(a);
+            return;
+        }
         // 任何新 item 到达 = 上一条"消息写完了"并不代表这一轮结束 → 撤销待确认的软收口。
         // 硬信号 (end_turn / turn_duration) 的后端永远不会走到这里。
         if (a.softEnd) {
@@ -3060,6 +3100,145 @@ export const startMirror = (deps) => {
         const raw = await capturePaneTail(pane, Math.max(8, rows) + 12);
         return { ok: true, pane: compactPane(raw, rows), busy: paneIsBusy(raw) };
     };
+    // ── 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. Budget-capped so an
+    // abandoned pane isn't pinged forever; the counter refreshes on real activity.
+    const fmtTokens = (n) => n >= 1000 ? `${(n / 1000).toFixed(n >= 10_000 ? 0 : 1)}k` : String(n);
+    // 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;
+    const fireKeepalive = async (a) => {
+        const kc = cfg.wrc.mirror.keepalive;
+        // 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(kc.ping);
+        a.keepaliveQuiet = setTimeout(() => {
+            a.keepaliveQuiet = undefined;
+            if (a.keepaliveTurnId) {
+                recordTurnClose(a.keepaliveTurnId);
+                a.keepaliveTurnId = undefined;
+            }
+        }, 60_000);
+        const r = await inject({
+            text: kc.ping, images: [], cfg,
+            log: log.child({ target: a.target, sessionId: a.sessionId, sub: "keepalive" }),
+            sessionId: a.sessionId, jsonlPath: a.jsonlPath, tmuxTarget: a.tmuxPane,
+        });
+        if (!r.ok) {
+            endKeepaliveQuiet(a);
+            // Roll the ping back so a failed attempt doesn't burn the budget.
+            if (a.keepalive) {
+                a.keepalive.pinging = false;
+                a.keepalive.count = Math.max(0, a.keepalive.count - 1);
+            }
+            log.warn({ target: a.target, reason: r.reason }, "keepalive: inject failed");
+            return;
+        }
+        const n = a.keepalive?.count ?? 1;
+        const tokens = lastContextTokens(a.jsonlPath);
+        const size = tokens > 0 ? `~${fmtTokens(tokens)} tokens` : "未知";
+        log.info({ target: a.target, count: n, tokens }, "keepalive: ping injected");
+        // Open a chat-detail turn for the real heartbeat exchange: userQuery is the
+        // actual ping we injected; the assistant reply (expected: just "pong"), any
+        // tool calls, and usage are grafted on from the swallowed items in onItem;
+        // closed on the ping's turn_end (or the fail-safe). Kept out of chat.
+        const turnId = newTurnId();
+        a.keepaliveTurnId = turnId;
+        recordTurnStart({ id: turnId, target: a.target, sessionId: a.sessionId, userQuery: kc.ping });
+        if (kc.notify)
+            sendStandalone(a, `❤️ 保活 · context ${size} · ${n}/${kc.maxPings}`);
+    };
+    let keepaliveTicking = false;
+    const keepaliveTick = async () => {
+        const kc = cfg.wrc.mirror.keepalive;
+        if (!kc.enabled || keepaliveTicking)
+            return;
+        keepaliveTicking = true;
+        try {
+            const idleTriggerMs = Math.max(30, kc.ttlSec - kc.marginSec) * 1000;
+            const ttlMs = kc.ttlSec * 1000;
+            const now = Date.now();
+            for (const a of byTarget.values()) {
+                if (!a.tmuxPane)
+                    continue; // spawn-mode: no live pane to warm
+                if (a.migrationWatcher)
+                    continue; // session rotating — skip
+                if (a.liveStream && !a.liveStream.closed)
+                    continue; // mid typewriter — don't inject
+                if (!(await tmuxPaneAlive(a.tmuxPane)))
+                    continue; // dead pane — nothing to keep alive
+                let mtime = 0;
+                try {
+                    mtime = statSync(a.jsonlPath).mtimeMs;
+                }
+                catch {
+                    continue;
+                }
+                if (!mtime)
+                    continue;
+                const k = (a.keepalive ??= { count: 0, settledMtime: 0, pinging: false, pingMtime: 0 });
+                const busy = paneIsBusy(await capturePaneTail(a.tmuxPane, 12));
+                if (k.pinging) {
+                    // Waiting for our own ping to land and settle. Not written yet, or the
+                    // ping turn still running → keep waiting. Once written AND idle again,
+                    // snapshot the settled mtime; the next idle window accrues from here.
+                    if (busy || mtime <= k.pingMtime)
+                        continue;
+                    k.settledMtime = mtime;
+                    k.pinging = false;
+                    continue;
+                }
+                // Real turn running → full budget again. If `/stop` paused us, resume ONLY
+                // after a grace window: the ping that may have been mid-flight when /stop
+                // landed makes the pane busy too, and must NOT be mistaken for the human
+                // coming back. After the grace, a busy pane is a genuine new turn → resume.
+                if (busy) {
+                    k.count = 0;
+                    k.settledMtime = 0;
+                    if (a.keepaliveOff && now - (a.keepaliveOffAt ?? 0) > RESUME_GRACE_MS)
+                        a.keepaliveOff = false;
+                    continue;
+                }
+                // Transcript grew past the last settled ping while we weren't pinging =
+                // a real turn happened → reset the budget so idle after work re-earns it.
+                if (k.settledMtime && mtime > k.settledMtime + 1000) {
+                    k.count = 0;
+                    k.settledMtime = 0;
+                }
+                if (a.keepaliveOff)
+                    continue; // paused by /stop until a real turn returns (busy branch / dispatch lift it)
+                const idle = now - mtime;
+                if (idle < idleTriggerMs)
+                    continue; // still warm — too early to bother
+                // Hard upper bound: past the TTL the cache is already gone, so a ping
+                // would pay a full 1.25x cold re-write of the whole context for a no-op
+                // turn — the exact waste we're avoiding. Only warm a cache that's still
+                // hittable; a genuinely stale session waits for a real turn to pay it.
+                if (idle >= ttlMs)
+                    continue;
+                if (k.count >= kc.maxPings)
+                    continue; // budget spent — let it go cold
+                k.count += 1;
+                k.pinging = true;
+                k.pingMtime = mtime;
+                await fireKeepalive(a);
+            }
+        }
+        catch (e) {
+            log.warn({ err: e.message }, "keepalive tick failed");
+        }
+        finally {
+            keepaliveTicking = false;
+        }
+    };
+    const keepaliveTimer = setInterval(() => void keepaliveTick(), 15_000);
     return {
         attach,
         peers,
@@ -3273,7 +3452,17 @@ export const startMirror = (deps) => {
             const r = await tmuxRun(["send-keys", "-t", a.tmuxPane, "Escape"]);
             if (r.code !== 0)
                 return { ok: false, reason: `send-keys Escape failed: ${r.stdout.slice(-200) || r.code}` };
-            log.info({ target, sessionId: a.sessionId, pane: a.tmuxPane }, "mirror /stop — Esc sent to pane");
+            // /stop also pauses keepalive: the user is deliberately quieting this
+            // session, so stop poking it too. A real turn (WeCom inbound, or the pane
+            // going busy AFTER the resume grace) lifts the pause and re-earns the
+            // budget. Stamping keepaliveOffAt gates the busy-resume so the ping that
+            // may be mid-flight right now can't immediately self-resume.
+            a.keepaliveOff = true;
+            a.keepaliveOffAt = Date.now();
+            a.keepalive = { count: 0, settledMtime: 0, pinging: false, pingMtime: 0 };
+            // Any in-flight ping's quiet window + detail turn are left to close on their
+            // own turn_end (or the 60s fail-safe), so the interrupted pong stays out of chat.
+            log.info({ target, sessionId: a.sessionId, pane: a.tmuxPane }, "mirror /stop — Esc sent to pane, keepalive paused");
             return { ok: true };
         },
         submitPane: async (target) => {
@@ -3325,6 +3514,7 @@ export const startMirror = (deps) => {
         newSession,
         shutdown: () => {
             clearInterval(paneDriftTimer);
+            clearInterval(keepaliveTimer);
             for (const a of bySessionId.values()) {
                 if (a.outbound?.kind === "deferred")
                     clearTimeout(a.outbound.timer);
@@ -3354,6 +3544,14 @@ export const startMirror = (deps) => {
                 }
                 return;
             }
+            // A real inbound is a new conversation → lift any `/stop` keepalive pause
+            // and re-earn the budget. (Pane-side new turns resume via the tick's busy
+            // branch; this covers the WeCom-driven path.)
+            a.keepaliveOff = false;
+            if (a.keepalive) {
+                a.keepalive.count = 0;
+                a.keepalive.settledMtime = 0;
+            }
             // Finalize prior live stream (if any) so this new turn renders into its
             // own message bubble. Then open a fresh stream tied to the new frame and
             // ack immediately so WeCom doesn't time out while inject queues.