wezard 1.1.5 → 1.2.1

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, tailTurns } 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,153 @@ 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. The whole schedule is
+    // anchored to the last REAL (non-ping) activity, NOT to our own pings — so a
+    // dead session is never kept warm forever, and once real work is older than
+    // `maxIdleSec` we stop and let the cache die.
+    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;
+    // Seed the keepalive anchor. If the transcript's last user turn IS one of our
+    // pings, the session has been idling under keepalive — anchor realMtime in the
+    // past so a daemon restart doesn't resume pinging a stale session (it waits for
+    // genuine activity). Otherwise anchor to the current mtime (fresh real work).
+    const initKeepalive = (jsonlPath, mtime, pingText, ttlMs) => {
+        let stale = false;
+        try {
+            const users = tailTurns(jsonlPath, 8).filter((t) => t.role === "user");
+            const last = users[users.length - 1]?.text ?? "";
+            const sig = normAssistant(pingText).slice(0, 40);
+            stale = sig.length > 0 && normAssistant(last).includes(sig);
+        }
+        catch { /* unreadable tail — treat as fresh */ }
+        return { realMtime: stale ? mtime - ttlMs : mtime, seenMtime: mtime, pinging: false, pingMtime: 0 };
+    };
+    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);
+            if (a.keepalive)
+                a.keepalive.pinging = false; // roll back so the next tick can retry
+            log.warn({ target: a.target, reason: r.reason }, "keepalive: inject failed");
+            return;
+        }
+        const tokens = lastContextTokens(a.jsonlPath);
+        const size = tokens > 0 ? `~${fmtTokens(tokens)} tokens` : "未知";
+        log.info({ target: a.target, 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, `KeepAlive · ${size}`);
+    };
+    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 maxIdleMs = Math.max(kc.ttlSec, kc.maxIdleSec) * 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 ??= initKeepalive(a.jsonlPath, mtime, kc.ping, ttlMs));
+                // Growth since the previous tick — computed BEFORE updating seenMtime.
+                // A real turn writing between ticks trips this; our own ping's growth is
+                // absorbed by the pinging-branch ticks (which update seenMtime too), so it
+                // never looks like real activity here — that's the whole fix.
+                const grewSinceLast = mtime > k.seenMtime + 1000;
+                k.seenMtime = mtime;
+                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. realMtime is NEVER advanced by
+                    // a ping — a ping is not real work.
+                    if (busy || mtime <= k.pingMtime)
+                        continue;
+                    k.pinging = false;
+                    continue;
+                }
+                // Real activity re-anchors the schedule and lifts a `/stop` pause: the pane
+                // is busy on a genuine turn, or the transcript grew since last tick (a turn
+                // that completed between ticks). Only a busy pane keeps looping.
+                if (busy || grewSinceLast) {
+                    k.realMtime = mtime;
+                    if (a.keepaliveOff && (busy ? now - (a.keepaliveOffAt ?? 0) > RESUME_GRACE_MS : true))
+                        a.keepaliveOff = false;
+                    if (busy)
+                        continue;
+                }
+                if (a.keepaliveOff)
+                    continue; // paused by /stop until real activity returns
+                const idleSinceTouch = now - mtime; // cache warmth: last touch (real OR ping)
+                const realIdle = now - k.realMtime; // user cutoff: last REAL work only
+                if (idleSinceTouch < idleTriggerMs)
+                    continue; // cache still comfortably warm
+                if (idleSinceTouch >= ttlMs)
+                    continue; // cache already cold — a ping would cold-rewrite for nothing
+                if (realIdle >= maxIdleMs)
+                    continue; // real work too old — stop, let it die (你的「超5分钟不保活」)
+                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 +3460,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 = undefined; // re-anchors cleanly on resume
+            // 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 +3522,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 +3552,14 @@ export const startMirror = (deps) => {
                 }
                 return;
             }
+            // A real inbound is a new conversation → lift any `/stop` keepalive pause
+            // and re-anchor to now (this turn is real work). Pane-side new turns
+            // re-anchor via the tick's busy branch; this covers the WeCom-driven path.
+            a.keepaliveOff = false;
+            if (a.keepalive) {
+                a.keepalive.realMtime = Date.now();
+                a.keepalive.seenMtime = Date.now();
+            }
             // 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.