wezard 1.3.2 → 1.3.6

package/dist/daemon/mirror-bridge.js

@@ -465,11 +465,17 @@ const renderLine = (raw, deps) => {
             const goal = goalStartOf(c);
             if (goal)
                 return [goal];
-            if (!deps.includeUser)
-                return [];
             const text = cleanUserText(c);
             if (!text)
                 return []; // pure slash-command meta / stdout — drop
+            // Keepalive ping user line: judged by CONTENT, before every other gate
+            // (includeUser / isOwnInject's 60s TTL) — the ping never echoes, and
+            // the reply turn is swallowed by content in onItem. Timer windows can't
+            // cover reloads or replays; the user message itself always can.
+            if (deps.isKeepalivePing?.(text))
+                return [{ kind: "keepalive_start", body: text }];
+            if (!deps.includeUser)
+                return [];
             if (deps.isOwnInject(text))
                 return []; // dedupe WeCom→CLI echo
             const quoted = text.split("\n").map((l) => `> ${l}`).join("\n");
@@ -1414,6 +1420,19 @@ export const startMirror = (deps) => {
         recentAssistantSends.splice(i, 1); // one-shot: a genuine later re-say still streams
         return true;
     };
+    // Keepalive ping detector for the tail's user-line judgment — the SAME
+    // normalized-prefix signature set keepaliveTick feeds keepaliveStamps
+    // (every configured form + the bare "ping" legacy streak form), so
+    // renderLine, the tick and the transcript parser all agree on what counts
+    // as a ping. Content is the source of truth for the swallow: timers and
+    // echo-TTLs lose it across reloads/replays.
+    const keepalivePingSigs = [cfg.wrc.mirror.keepalive.ping, cfg.wrc.mirror.keepalive.resumePing]
+        .map((p) => normAssistant(p).slice(0, 40))
+        .filter((s) => s.length > 0);
+    const isKeepalivePing = (text) => {
+        const n = normAssistant(text);
+        return n.toLowerCase() === "ping" || keepalivePingSigs.some((sig) => n.includes(sig));
+    };
     // ── Typewriter stream lifecycle ────────────────────────────────────
     // WeCom spec: server polls us for stream refreshes for up to 6 min from the
     // original inbound. SDK queues replyStream calls per req_id, sends serially
@@ -1818,7 +1837,7 @@ export const startMirror = (deps) => {
     // 每个 turn 挂一条气泡: ack 时就写进 `tag 详情链接 …` (finish=false, 不立刻关掉),
     // 让群里从收到消息那一刻起就有详情页入口。收口时:
     //   • 正文到位 → 以 `链接 正文` 覆盖这条气泡。
-    //   • 始终没正文 / 过 6min 窗口 → 以 ack 时那条纯 `链接` 收口。
+    //   • 始终没正文 / 过 6min 窗口 → 以最新 CoT 进度行 (没有则纯 `链接`) 收口。
     //   • 气泡已收口或无气泡 turn (CLI 侧发起) → 正文另发一条 standalone。
     // 其它所有 item 只写入 turn detail store。
     // 能证明"assistant 已经在产出"的 item —— 见到它们才补开无气泡 turn。
@@ -1857,6 +1876,7 @@ export const startMirror = (deps) => {
         // 收口后这一路全部失效: 气泡要么已 done, 要么 turn 已经换人/清空。
         if (!text || !b || b.done || !turnId || a.briefConcluded)
             return;
+        a.cotLastSent = text;
         try {
             await client.replyStream(b.frame, b.streamId, `${briefDetailLink(turnId, a.target)} \`${text}\``, false);
         }
@@ -1951,8 +1971,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 收口。
-            void finishBubble(a, bubble, briefDetailLink(turnId, a.target), true);
+            // 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);
         }, HARD_TIMEOUT_MS);
         // 新消息 = 对话边界: 立刻收掉上一 turn, 新 turn 直接激活、不排队。收口语义见
         // closeBriefTurn: 有正文收入旧气泡, 没正文不写一个字 (绝不因边界结束凭空新发/
@@ -2232,13 +2255,41 @@ 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;
+    // End the keepalive swallow — the ping turn is over (turn_end / genuine
+    // user line / inject failure), so real items flow through onItem again.
+    // Clears BOTH the timer window and the content flag.
+    const endKeepaliveSwallow = (a) => {
+        if (a.keepaliveQuiet) {
+            clearTimeout(a.keepaliveQuiet);
+            a.keepaliveQuiet = undefined;
+        }
+        if (a.keepaliveContentTimer) {
+            clearTimeout(a.keepaliveContentTimer);
+            a.keepaliveContentTimer = undefined;
+        }
+        a.keepaliveByContent = undefined;
+    };
+    // Content-based swallow entry: the tailed user line IS a configured ping.
+    // Belt to the inject-time timer window — this one keys on the user message
+    // itself, so it holds across daemon reloads, tail replays and replies
+    // slower than the 60s fail-safe. Reuses the detail turn the timer flow may
+    // have opened (fireKeepalive skips opening when this got there first).
+    const KEEPALIVE_CONTENT_FAILSAFE_MS = 5 * 60_000;
+    const beginKeepaliveByContent = (a, text) => {
+        a.keepaliveByContent = true;
+        if (a.keepaliveContentTimer)
+            clearTimeout(a.keepaliveContentTimer);
+        // Fail-safe: a ping turn whose reply never emits turn_end (crash/hang)
+        // must not mute a later real turn forever.
+        a.keepaliveContentTimer = setTimeout(() => {
+            a.keepaliveContentTimer = undefined;
+            a.keepaliveByContent = undefined;
+        }, KEEPALIVE_CONTENT_FAILSAFE_MS);
+        if (!a.keepaliveTurnId) {
+            const turnId = newTurnId();
+            a.keepaliveTurnId = turnId;
+            recordTurnStart({ id: turnId, target: a.target, sessionId: a.sessionId, userQuery: text });
+        }
     };
     // A keepalive ping turn is swallowed wholesale — the reply content doesn't
     // matter (model may add extra commentary beyond "pong", that's fine).
@@ -2246,12 +2297,24 @@ export const startMirror = (deps) => {
         // 新 spawn 的 pane 在首次 inject 落地前吞掉所有初始输出 (greeting/system)。
         if (a.muteUntilInject)
             return;
-        // 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, 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.
-        if (a.keepaliveQuiet) {
+        // Keepalive ping turns are cache-warmers: swallow every item from every
+        // WeCom path so the ping/pong never reaches chat. Two triggers, either
+        // suffices — the timer window opened at inject (keepaliveQuiet) OR the
+        // user line itself matching a configured ping (keepaliveByContent; the
+        // reload/replay/slow-reply-proof one). The REAL exchange is recorded
+        // into its chat-detail turn — the actual assistant reply, the tool calls
+        // if any, and the usage — so the detail page shows the genuine heartbeat.
+        if (item.kind === "keepalive_start") {
+            beginKeepaliveByContent(a, item.body);
+            return;
+        }
+        // A genuine user line (not our inject, not a ping) is a hard turn
+        // boundary — any keepalive swallow still holding never got its turn_end
+        // (crashed reply). Release BEFORE the swallow gate so this real line (and
+        // its reply) mirror normally instead of being eaten by the stale swallow.
+        if (item.kind === "user_text")
+            endKeepaliveSwallow(a);
+        if (a.keepaliveQuiet || a.keepaliveByContent) {
             const id = a.keepaliveTurnId;
             if (id) {
                 const now = Date.now();
@@ -2270,7 +2333,7 @@ export const startMirror = (deps) => {
                 }
             }
             if (item.kind === "turn_end") {
-                endKeepaliveQuiet(a);
+                endKeepaliveSwallow(a);
             }
             return;
         }
@@ -2610,6 +2673,7 @@ export const startMirror = (deps) => {
             toolUseInlineMaxChars: cfg.wrc.mirror.toolUseInlineMaxChars,
             isOwnInject,
             isOwnAssistantSend,
+            isKeepalivePing,
             onItem: (item) => onItem(a, item),
             detailUrlFor,
             sessionId,
@@ -2991,6 +3055,7 @@ export const startMirror = (deps) => {
             toolUseInlineMaxChars: cfg.wrc.mirror.toolUseInlineMaxChars,
             isOwnInject,
             isOwnAssistantSend,
+            isKeepalivePing,
             onItem: (item) => onItem(a, item),
             detailUrlFor,
             sessionId: newSessionId,
@@ -3289,33 +3354,13 @@ export const startMirror = (deps) => {
     // from the running cwd). Decoupling means /pwd can show truth even after
     // the AI sets a new path but the user hasn't /new'd yet.
     const expandedDefaultCwd = expandHome(cfg.wrc.cwd);
-    // Long absolute paths wrap in the WeCom bubble — show only the trailing
-    // three segments, which is enough to identify the project.
-    const shortCwd = (p) => p.split("/").filter(Boolean).slice(-3).join("/");
-    const renderProjectInfo = (target) => {
-        const a = byTarget.get(target);
-        const rec = a ? undefined : deps.store.get(target);
-        const running = (a?.runningCwd?.trim()) || rec?.cwd?.trim() || expandedDefaultCwd;
-        // pendingCwd is chat-scoped — the queued switch applies to every session
-        // in this chat, so read it from the shared base slot rather than the
-        // caller's own (now-empty) attachment record.
-        const pending = chatCwdFallback(target).pending;
-        const lines = [`📂 cwd: \`${shortCwd(running)}\``];
-        if (pending && pending !== running) {
-            lines.push(`下次切换: \`${shortCwd(pending)}\` (使用 /new 或 /clear 生效)`);
-        }
-        // Session-boundary footer — `/new` and `/clear` are the only two callers,
-        // so the tip lands exactly once per fresh context, never mid-conversation.
-        lines.push(randomTip());
-        return lines.join("\n");
-    };
     // `header` folds the caller's ack ("created") into this same bubble — /new
     // must land as exactly ONE WeCom message, not card + separate reply.
-    // slashAckFirstLine: 会话边界回执只保留首行 ack, 📂 项目信息与 💡 tip 省去。
+    // 会话边界回执一律不携带 cwd 信息 (📂 项目行 / 下次切换), 需要时 `/pwd` 可查。
+    // slashAckFirstLine 进一步省去 💡 tip, 只剩首行 ack。
     const pushProjectInfo = (target, header) => {
         const concise = cfg.wrc.mirror.slashAckFirstLine && !!header;
-        const info = concise ? "" : renderProjectInfo(target);
-        const md = header ? (info ? `${header}\n\n${info}` : header) : info;
+        const md = header ? (concise ? header : `${header}\n\n${randomTip()}`) : randomTip();
         const a = byTarget.get(target);
         if (a) {
             sendStandalone(a, md);
@@ -3332,7 +3377,7 @@ export const startMirror = (deps) => {
     // (default + any `#tag` siblings) share one cwd/pendingCwd, tracked on the
     // BASE principal's byTarget/store record. Tagged sessions still have their
     // own `runningCwd` (the tmux pane's actual working dir at spawn time), but
-    // cwd fallbacks and `cd` pendingCwd writes always resolve against the base.
+    // cwd fallbacks and `set_workspace` pendingCwd writes always resolve against the base.
     const chatCwdFallback = (target) => {
         const base = basePrincipalOf(target);
         const baseA = byTarget.get(base);
@@ -3351,7 +3396,7 @@ export const startMirror = (deps) => {
         //   base.pending > caller.pending > target.running > base.running > default
         // A fresh tagged session inherits the chat's current cwd; re-`/new`ing a
         // live tagged session keeps its pane cwd unless the base session queued a
-        // `cd`. This keeps siblings aligned by default without forcibly clobbering
+        // cwd switch. This keeps siblings aligned by default without forcibly clobbering
         // an already-spawned tagged pane on every base-cwd change.
         const chat = chatCwdFallback(target);
         const rec = !prev ? deps.store.get(target) : undefined;
@@ -3449,9 +3494,9 @@ export const startMirror = (deps) => {
         return { ok: true, sessionId: r.sessionId, cwd: r.cwd };
     };
     const getCwd = (target) => {
-        // pendingCwd is chat-scoped — a `cd` from any sibling session queues the
-        // switch for the whole chat. runningCwd stays per-session (each pane has
-        // its own spawn dir).
+        // pendingCwd is chat-scoped — a `set_workspace` from any sibling session
+        // queues the switch for the whole chat. runningCwd stays per-session (each
+        // pane has its own spawn dir).
         const chat = chatCwdFallback(target);
         const pending = chat.pending;
         const a = byTarget.get(target);
@@ -3463,9 +3508,9 @@ export const startMirror = (deps) => {
         return { runningCwd: chat.running || expandedDefaultCwd, pendingCwd: pending, defaultCwd: expandedDefaultCwd };
     };
     // Write `pendingCwd` to the BASE principal so the switch applies chat-wide —
-    // the next /new in any tagged/untagged session picks it up. `cd` from a
-    // tagged session still writes to the shared slot, not the tagged session's
-    // own record, matching "sessions share the chat's cwd".
+    // the next /new in any tagged/untagged session picks it up. `set_workspace`
+    // from a tagged session still writes to the shared slot, not the tagged
+    // session's own record, matching "sessions share the chat's cwd".
     const setPendingCwd = (target, cwd) => {
         const trimmed = (cwd ?? "").trim();
         if (!trimmed)
@@ -3627,6 +3672,34 @@ export const startMirror = (deps) => {
         const p = jsonlOf(target);
         return p ? lastAssistantText(p) : "";
     };
+    // ── 未收口气泡的引用判定 ────────────────────────────────────────────
+    // tag 会话的 last stream 未收口时, 群里最新那条气泡是瞬态的: 详情链接 URL +
+    // 最新一条实时 CoT/工具行 (brief) 或累积中的 acc (非 brief)。引用它要的是路由,
+    // 不是把这些中间态贴回 prompt —— 判定命中 ⇒ 调用方只保留 tag, 正文丢弃。
+    // URL 必须先于 canon 剥掉: canonForCompare 只剩字母数字, host/path 的字符会
+    // 永远卡住比对。两侧同剥, 才在同一层级上比。
+    const OPEN_QUOTE_URL_RE = /https?:\/\/\S+/g;
+    const quoteCanon = (s) => s.replace(OPEN_QUOTE_URL_RE, " ").replace(/[^\p{L}\p{N}]/gu, "");
+    const openBubbleBodies = (a) => {
+        if (a.briefBubble && !a.briefBubble.done && !a.briefConcluded) {
+            return [a.cotLastSent, a.cotText].filter((s) => !!s);
+        }
+        const s = a.liveStream;
+        return s && !s.closed && !s.dead ? [s.acc, s.lastSent] : [];
+    };
+    const isOpenBubbleQuote = (target, quoted) => {
+        const a = byTarget.get(target);
+        if (!a)
+            return false;
+        const bodies = openBubbleBodies(a);
+        if (bodies.length === 0)
+            return false;
+        const qc = quoteCanon(quoted);
+        // 剥掉 URL 后什么都不剩 ⇒ 引用的只是链接头 + "…" 这类纯 chrome, 直接命中。
+        if (!qc)
+            return true;
+        return bodies.some((b) => quoteCanon(b).includes(qc));
+    };
     // 一个 target 的完整画像。本 chat 的兄弟和外 chat 的 peer 走同一条,只有
     // `self` / `address` 因观察者而异 —— 地址本来就是相对调用方说的话。
     const peerInfoOf = async (t, self) => {
@@ -3756,7 +3829,7 @@ export const startMirror = (deps) => {
             sessionId: a.sessionId, jsonlPath: a.jsonlPath, tmuxTarget: a.tmuxPane,
         });
         if (!r.ok) {
-            endKeepaliveQuiet(a);
+            endKeepaliveSwallow(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");
@@ -3769,9 +3842,13 @@ export const startMirror = (deps) => {
         // 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: text });
+        // The tail's keepalive_start (content match on the user line) may have
+        // opened this turn already — only open when it hasn't.
+        if (!a.keepaliveTurnId) {
+            const turnId = newTurnId();
+            a.keepaliveTurnId = turnId;
+            recordTurnStart({ id: turnId, target: a.target, sessionId: a.sessionId, userQuery: text });
+        }
     };
     let keepaliveTicking = false;
     const keepaliveTick = async () => {
@@ -3891,6 +3968,7 @@ export const startMirror = (deps) => {
         peekTurns,
         isBusy,
         lastText,
+        isOpenBubbleQuote,
         status: () => {
             const list = Array.from(bySessionId.values()).map((a) => ({
                 sessionId: a.sessionId,
@@ -3917,7 +3995,7 @@ export const startMirror = (deps) => {
         },
         targetForSession: (sessionId) => {
             // Live attach is the fast path. Fall back to scanning persisted store:
-            // an MCP tool (e.g. `cd`) called from a claude that isn't mirror-attached
+            // an MCP tool (e.g. `set_workspace`) called from a claude that isn't mirror-attached
             // would otherwise miss here and silently retarget to defaultChat — that
             // bug stranded pendingCwd on the wrong principal. Store keeps each
             // target's sessionId in sync via migrate/attach/setPendingCwd writes.
@@ -4572,10 +4650,10 @@ export const startMirror = (deps) => {
                 // and surface a standalone "cleared" so the user gets explicit
                 // feedback (the skip-stream path otherwise leaves WeCom silent).
                 if (armMigration) {
-                    // slashAckFirstLine: 只回首行 ack, 项目信息/tip 省去 (与 /new 一致)。
+                    // cwd 不随回执下发 (/pwd 可查); slashAckFirstLine 连 tip 也省去 (与 /new 一致)。
                     sendStandalone(a, cfg.wrc.mirror.slashAckFirstLine
                         ? "cleared"
-                        : `cleared\n\n${renderProjectInfo(a.target)}`);
+                        : `cleared\n\n${randomTip()}`);
                     a.clearRebind = { baseline: preClearBaseline };
                     startMigrationWatcher(a, preClearBaseline, jsonlIsPostClearChild, 0, true);
                 }