wezard 2.7.4 → 2.7.7

package/dist/daemon/index.js

@@ -26,8 +26,8 @@ import { applyHot, cfgSeenBy, patchedTop, pinChatKeys, configGet, fromLegacy, le
 import { computeUsage, costOf, fmtCost, fmtTokens, sumTotal } from "./usage.js";
 import { installInboundRouter } from "./inbound.js";
 import { loadMirrorStore } from "./mirror-store.js";
-import { cancelOps, deadlineOf, eventRef, isEventRef, makeOutcome, openRouter, ops, pickPair } from "./router.js";
-import { createMessageEvents, messageId, finalId } from "./message-events.js";
+import { cancelOps, deadlineOf, eventRef, finalKind, isEventRef, makeOutcome, openRouter, ops, pickPair } from "./router.js";
+import { createMessageEvents, messageId, finalId, reportSource, receiptCoverage, receiptFacts } from "./message-events.js";
 import { startMirror, installMirrorEventListener } from "./mirror-bridge.js";
 import { backendFor, runTmux, setTmuxTimeoutReporter, spawnTmuxClaude } from "./spawn-tmux.js";
 import { bindCardChannel, installApprovalEventListener, makeApproveHandler, requestConfirm } from "./approval.js";
@@ -207,6 +207,13 @@ const main = async () => {
     let deliverFinal;
     let handoffAllowed = () => false;
     let handoffFinalSuppressed = (e) => !!e.handoffCut && !e.handoffRestored;
+    const ownsReplyEvent = (e) => {
+        const row = e.serves ? router.get(e.serves) : undefined;
+        if (row && row.owner !== e.target)
+            return false;
+        const latest = e.serves ? events.latestTransfer(e.serves) : undefined;
+        return !latest || latest.id === e.id || latest.at < e.at;
+    };
     const events = createMessageEvents(join(cfg.daemon.stateDir, "message-events.json"), {
         resource: (target) => bridge.sessionInfo(target)?.tmuxPane || target,
         transcript: (target) => bridge.inputSessionInfo(target)?.jsonlPath ?? bridge.sessionInfo(target)?.jsonlPath,
@@ -226,7 +233,7 @@ const main = async () => {
                 events.result(e.id, body, finalId(e.id, e.channel, body));
                 // A canceled, unexposed input has a terminal response owned by its original channel.
                 events.delivery({ id: finalId(e.id, e.channel, body), eventId: e.id, target: e.target, turn: e.turn || e.id,
-                    channel: e.channel, revision: finalId(e.id, e.channel, body), body, chunks: bridge.formatFinal(e.target, e.turn || e.id, e.channel, body) });
+                    channel: e.channel, revision: finalId(e.id, e.channel, body), body, purpose: "cancellation", reportKind: "canceled", chunks: bridge.formatFinal(e.target, e.turn || e.id, e.channel, body) });
             }
         },
         // 人话 (非 peer) 不再问「pane 闲不闲」: 忙就贴进去, 顺序交给 backend CLI 自己的输入队列
@@ -281,8 +288,9 @@ const main = async () => {
                 // 一轮以 CLI 报错收尾: 那段报错不是定论, 但要作为中途态 (error) 报给 receiver ——
                 // 所以照旧不落成 result, 只把原文交给 final (见 §9.4)。
                 return { consumed: true, interjected: !!turns[start].queued,
-                    ...(next >= 0 ? { closedAt: turns[next].ms ?? Date.now() } : {}),
-                    ...(ended && last && !last.mid
+                    ...(next >= 0 ? { closedAt: turns[next].ms ?? Date.now() }
+                        : last?.end && !last.text ? { closedAt: last.ms ?? Date.now() } : {}),
+                    ...(ended && last?.text && !last.mid
                         ? last.apiError ? { body: last.text, error: true } : { body: last.text, revision: finalId(e.id, e.channel, last.text) }
                         : {}) };
             }
@@ -296,6 +304,18 @@ const main = async () => {
         format: (d) => ({ ...d, chunks: d.chunks.map((c) => responseTracker.freeze(d.channel.replace(/^(user|chat|group):/, ""), c)) }),
         send: async (d, n) => {
             await bridge.settleFinalProgress(d.id);
+            const allowed = () => {
+                const source = d.eventId ? events.authorityOf(d.eventId) : undefined;
+                if (!source)
+                    return !d.eventId || d.purpose === "task";
+                const row = source.serves ? router.get(source.serves) : undefined;
+                const cancellation = d.purpose === "cancellation" && source.canceled && source.unexposedHuman;
+                return source.target === d.target && !source.interjected && !handoffFinalSuppressed(source) && ownsReplyEvent(source)
+                    && (cancellation || !source.canceled && row?.outcome?.status !== "canceled" && row?.status !== "held")
+                    && (d.purpose !== "progress" || !!row && ["open", "need", "error"].includes(row.status));
+            };
+            if (!allowed())
+                return { failed: "delivery authority withdrawn before transport" };
             const chat = d.channel.replace(/^(user|chat|group):/, "");
             if (wx.owns(chat)) {
                 const result = wx.sendFinal(chat, wxMarkdown(d.chunks[n]), `${d.id}:${n}`);
@@ -304,7 +324,7 @@ const main = async () => {
                     failed: result.state === "failed" ? result.reason ?? "Weixin final rejected" : undefined };
             }
             const stream = d.stream && n === 0 && Date.now() < d.stream.expires ? d.stream : undefined;
-            const ack = await responseTracker.sendFrozen(chat, d.chunks[n], stream, events.running);
+            const ack = await responseTracker.sendFrozen(chat, d.chunks[n], stream, () => events.running() && allowed());
             return ack && typeof ack === "object" && "errcode" in ack && ack.errcode === 0 ? { ack: JSON.stringify(ack) }
                 : { ack: JSON.stringify(ack), uncertain: "final transport returned no explicit success ACK" };
         },
@@ -1237,13 +1257,6 @@ const main = async () => {
                 ...(p.job ? { job: p.job } : {}), ...(p.asker ? { asker: p.asker } : {}), ...(p.after?.length ? { after: p.after } : {}),
             });
         };
-        const ownsReplyEvent = (e) => {
-            const row = e.serves ? router.get(e.serves) : undefined;
-            if (row && row.owner !== e.target)
-                return false;
-            const latest = e.serves ? events.latestTransfer(e.serves) : undefined;
-            return !latest || latest.id === e.id || latest.at < e.at;
-        };
         // Acceptance projects ownership only after the input is durable. A rejected
         // acceptance retains the human's route and bubble for the original owner.
         const acceptPeerDispatch = (input, transfer = false) => {
@@ -1335,14 +1348,15 @@ const main = async () => {
                 return;
             // 挂起账 / 工单账本跟着定论走 (§9.5 / §9.6): 每一份定论都从这儿过 (onFinal 的 answer、
             // 失败级联的 canceled、boot 的重投), 所以放这里而不是 commitRoute。收给群的根行不进账。
-            if (row.receiver.kind === "wizard") {
+            const noticeOnly = (out.status === "need" || out.status === "error") && !!row.outcome;
+            if (row.receiver.kind === "wizard" && !noticeOnly) {
                 ledger.outcome(row.receiver.to, event, out.status, parseClosing(out.body).text || out.body);
                 // 带 workflow 追踪的那件活: 执行态/正文/摘要跟着定论走 (计划节点据此推进) ——
                 // 这一份原来只挂在旧回执 watcher 的 onOutcome 上, T10b 随它一起在这里重建。
                 workflow.outcome(row.receiver.to, event, out.status, out.body);
                 advancePlans();
-                // 追述 (row.late) 不是工单成员的第二份结局: 账只记第一次落定。
-                if (row.job && isTerminal(out.status) && !row.late)
+                // 追述更新最新结果, 首次落定计数由工单保持。
+                if (row.job && isTerminal(out.status))
                     jobs.settle(row.job, row.owner, out.status, parseClosing(out.body).artifacts, { turn: event });
             }
             postRoute(row, out, router.escalate(event, (k) => !!wizards.get(k)), `rcpt:${event}:${out.rev}`);
@@ -1360,8 +1374,9 @@ const main = async () => {
                 // Persist it through the same final outbox before handing the route off.
                 const transferred = events.latestTransfer(event);
                 if (out.status !== "done" && transferred?.target === row.owner)
-                    m.deliverTransferredFinal(transferred, out.body);
-                router.commit(ops.hand({ event, inbox: `chat:${receiver.message}:${out.rev}` }));
+                    m.deliverTransferredFinal(transferred, out.body, out.status);
+                if (isTerminal(out.status) && row.outcome?.rev === out.rev)
+                    router.commit(ops.hand({ event, inbox: `chat:${receiver.message}:${out.rev}` }));
                 return;
             }
             // 回执那一轮服务的就是收方自己欠的那一笔 (`receiver.event`) —— 它的终句又一次落到那一笔上,
@@ -1381,6 +1396,13 @@ const main = async () => {
                 : undefined;
             const job = row.job ? jobs.get(row.job) : undefined;
             const tally = row.job ? jobs.tally(row.job) : undefined;
+            const envelope = renderReceiptEnvelope(displayName(row.owner), channel ? chatNameOf(cfg, channel) : undefined, row.job ? { job: row.job, done: tally?.done ?? 0, total: tally?.total ?? 0, closed: job?.status !== "open", ...(job?.kind === "req" ? { req: true } : {}) } : undefined, out.status, event, { ...(row.asker ? { asker: row.asker } : {}),
+                ...(served?.kind === "wizard" ? { up: true } : {}),
+                ...(audienceName(channel, row.asker) ? { audience: audienceName(channel, row.asker) } : {}),
+                ...(via.length ? { via: via.join(", ") } : {}),
+                ...(late ? { late: true } : {}),
+                ...(retellTo ? { retellTo } : {}),
+                ...(row.late ? { retold: true } : {}) });
             events.accept({
                 id: inbox, identity: JSON.stringify([to, event, out.status, out.rev]),
                 target: to, speaker: row.owner, channel, serves,
@@ -1388,26 +1410,35 @@ const main = async () => {
                 priority: "normal", deadline: Date.now() + 12 * 3600_000,
                 // 行首 RESULT:/NEED: 只是判定记号, 语义已由信封的 status 携带 —— 投递时剥掉
                 // (ARTIFACT 行保留: 路径对收方 wizard 有实际用途)。
-                payload: { text: clipMiddle(stripClosingMark(out.body)), peer: {
+                payload: { text: clipMiddle(stripClosingMark(out.body)), receipts: [{ event, version: out.rev, status: out.status,
+                            receiver, body: out.body, speaker: row.owner, envelope,
+                            source: row.reports?.[out.rev]?.source
+                                ?? (row.outcome?.rev === out.rev ? row.outcome.report?.source : row.notice?.rev === out.rev ? row.notice.report?.source : undefined) }], peer: {
                         // 回执不是一件新活: `job` 留空 (否则 jobs.account 会把它当成工单的第二份派活数一遍)。
                         from: { kind: "peer", from: row.owner, receipt: true, status: out.status, event },
                         job: "", kind: "fyi",
-                        envelope: renderReceiptEnvelope(displayName(row.owner), channel ? chatNameOf(cfg, channel) : undefined, row.job ? { job: row.job, done: tally?.done ?? 0, total: tally?.total ?? 0, closed: job?.status !== "open", ...(job?.kind === "req" ? { req: true } : {}) } : undefined, out.status, event, { ...(row.asker ? { asker: row.asker } : {}),
-                            ...(served?.kind === "wizard" ? { up: true } : {}),
-                            ...(audienceName(channel, row.asker) ? { audience: audienceName(channel, row.asker) } : {}),
-                            ...(via.length ? { via: via.join(", ") } : {}),
-                            ...(late ? { late: true } : {}),
-                            ...(retellTo ? { retellTo } : {}),
-                            ...(row.late ? { retold: true } : {}) }),
+                        envelope,
                     } },
             }, retire);
-            router.commit(ops.hand({ event, inbox }));
+            if (isTerminal(out.status) && row.outcome?.rev === out.rev)
+                router.commit(ops.hand({ event, inbox }));
         };
         /** 收件箱里那份回执投不到了 (`gone`: 收方没有绑定, 按 store 也恢复不了) —— 投进去时它还在
          *  注册表上, 升级没跳过它。现在把它当不在, 沿 receiver 边重走一次升级: 能收的上层 wizard /
          *  群根 (Dead Letter) 收下。链上无处可升 (根行的收方自己没了): canceled 是收掉它的那一方自己
          *  发起的, 没人在等, 不再投; 别的定论退到收方的家群 (Dead Letter)。账本不再记第二遍。 */
         const rerouteGone = (e) => {
+            const facts = receiptFacts(e);
+            if (facts.length <= 1) {
+                rerouteReceipt(e, e.id);
+                return;
+            }
+            facts.forEach((f, i) => rerouteReceipt({ ...e, id: `rcpt:${f.event}:${f.version}`,
+                speaker: f.speaker, payload: { ...e.payload, text: f.body, receipts: [f],
+                    peer: { ...e.payload.peer, from: { kind: "peer", from: f.speaker, event: f.event,
+                            receipt: true, status: f.status }, envelope: f.envelope } } }, i === facts.length - 1 ? e.id : undefined));
+        };
+        const rerouteReceipt = (e, retire) => {
             const from = e.payload.peer?.from;
             const event = from?.receipt ? from.event : undefined;
             const row = event ? router.get(event) : undefined;
@@ -1429,7 +1460,7 @@ const main = async () => {
             // Replaying a torn reroute must target the same durable inbox entry.
             const inbox = `${e.id}~${finalId(e.id, JSON.stringify(esc?.receiver ?? row.receiver), rev)}`;
             log.info({ id: e.id, target: e.target, event, to: esc?.receiver ?? row.receiver, inbox }, "receipt reroute: 收方已不在, 改投");
-            postRoute(row, { status: from.status, body: e.payload.text, rev }, esc, inbox, e.id);
+            postRoute(row, { status: from.status, body: e.payload.text, rev }, esc, inbox, retire);
         };
         /** 一条路由 op: 先落盘, 再投该投的 (need / error 带正文入箱; answer 按 receiver 投递)。这里
          *  只管 `re` (`mark open`) 把那一行拉回在飞 —— 账本与工单跟着 deliverRoute 走。 */
@@ -1471,7 +1502,7 @@ const main = async () => {
         };
         /** 一轮的终句落到它服务的那一行上 (定论 / 中途态), 验收不合规格就打回续问。 */
         const settleFinal = (e, verdict) => {
-            const plans = router.onFinal(e.target, e.serves, verdict);
+            const plans = router.onFinal(e.target, e.serves, { ...verdict, source: reportSource(e) });
             const answer = plans.flatMap((op) => (op.op === "answer" && op.outcome.status === "done" ? [op] : []))[0];
             const row = answer ? router.get(answer.event) : undefined;
             const why = answer && row ? acceptanceOf(row, answer.outcome.body) : undefined;
@@ -1537,9 +1568,12 @@ const main = async () => {
          *  先留这个调用位。 */
         const releaseHeld = (_row) => { };
         /** §4.5 boot: fold 之后 `answered` 还没 `hand` 的行重投一次 —— rcpt 的 id 幂等, 重放不双投。 */
-        const replayAnswered = () => router.rows()
-            .filter((r) => r.status === "answered" && r.outcome !== undefined)
-            .forEach((r) => deliverRoute(r.event, r.outcome));
+        const replayAnswered = () => router.rows().forEach((r) => {
+            if (r.status === "answered" && r.outcome)
+                deliverRoute(r.event, r.outcome);
+            if (r.notice && r.outcome?.status !== "canceled")
+                deliverRoute(r.event, r.notice);
+        });
         const currentAsk = (target) => {
             const env = openingAsk(target);
             if (!env)
@@ -1801,8 +1835,43 @@ const main = async () => {
                 return;
             }
             const asker = askerOf(self);
+            const activeId = openingOfSelf(self)?.env?.eventId;
+            const active = activeId ? events.get(activeId) : undefined;
+            const receipt = !!active?.payload.peer?.from.receipt;
+            const leading = receipt ? /^(RESULT|Result|result|结论|NEED)[ \t]*[:：]/.exec(content) : null;
+            const closing = receipt ? parseClosing(content).kind : "none";
+            if (receipt && active) {
+                const row = active.serves ? router.get(active.serves) : undefined;
+                if (active.canceled || active.interjected || handoffFinalSuppressed(active) || !ownsReplyEvent(active) || row?.outcome?.status === "canceled") {
+                    json(res, 409, { ok: false, reason: "这笔任务已取消或归属已变更，回执报告不再公开。" });
+                    return;
+                }
+                if (closing === "none" && (!row || !["open", "need", "error"].includes(row.status))) {
+                    json(res, 409, { ok: false, reason: "这笔任务已收口或无在途任务，回执确认不公开；新结果用 RESULT:，新问题用 NEED:。" });
+                    return;
+                }
+            }
+            const shown = receipt && (leading || closing !== "none") ? stripForChat(content) : content;
+            if (!shown.trim()) {
+                json(res, 400, { ok: false, reason: "markdown body required" });
+                return;
+            }
+            const deliveries = [];
             for (const dest of dests) {
-                postAs(self, dest, content);
+                if (active?.payload.peer?.from.receipt) {
+                    const purpose = closing === "none" ? "progress" : "report";
+                    const reportKind = closing === "need" ? "need" : "done";
+                    const coverage = purpose === "report" ? receiptCoverage(active, dest, closing === "need", content) : undefined;
+                    const revision = finalId(active.id, dest, content);
+                    const id = events.delivery({ id: finalId(active.id, dest, revision), eventId: active.id, target: self,
+                        turn: active.turn ?? active.id, channel: dest, revision, body: shown, purpose, reportKind,
+                        chunks: m.formatFinal(self, active.turn ?? active.id, dest, shown), ...(coverage ? { coverage } : {}) });
+                    const claims = events.deliveryClaims(coverage);
+                    deliveries.push({ channel: dest, id, states: claims.length ? claims.flatMap((c) => c.states) : events.deliveryStatus(id),
+                        ...(claims.length > 1 ? { claims } : {}) });
+                }
+                else
+                    postAs(self, dest, content);
                 recordPost({ target: self, channel: dest, body: content, ...(asker ? { asker } : {}) });
             }
             // 微信群聊: 人超过 ctxTtlSec 没说话时微信会静默丢弃, 消息只能压着等他下次开口 —— 如实告诉调用方, 别回「已发送」。
@@ -1811,7 +1880,8 @@ const main = async () => {
             const name = (d) => chatNameOf(cfg, d) || d;
             json(res, 200, {
                 ok: true,
-                sent: dests.filter((d) => !held.includes(d)).map(name),
+                sent: dests.filter((d) => !held.includes(d) && !deliveries.some((x) => x.channel === d)).map(name),
+                ...(deliveries.length ? { deliveries, note: "已持久化；相同事实复用既有投递，实际状态见 states，不确定 ACK 不自动重发。" } : {}),
                 ...(held.length ? { held: held.map(name), note: `微信群聊 ${held.map(name).join("、")} 那头超过 ${cfg.weixin.ctxTtlSec}s 没说话: 微信会静默丢弃主动推送, 这条已压着, 对方下次在微信里开口时送达 (定时提醒做不到准点)` } : {}),
             });
         });
@@ -2170,12 +2240,21 @@ const main = async () => {
         // 已落定的那一笔只放追述 (§4.3): 判据与 onFinal 的 retellOps 同源 (router.finalReleased)。
         // 调用方可能拿着 result 落定前的快照, 正文按事件库现读。
         m.setEventOwnerGate(ownsReplyEvent);
+        m.setEventProgressGate((e) => {
+            if (handoffFinalSuppressed(e) || e.quiet || e.canceled || e.interjected || !ownsReplyEvent(e))
+                return false;
+            const row = e.serves ? router.get(e.serves) : undefined;
+            if (!row || row.owner !== e.target || row.status !== "open")
+                return false;
+            const kind = finalKind(router.table(), e.serves, e.result?.body ?? "");
+            return !e.result || kind === "progress" || kind === "wait";
+        });
         m.setEventFinalGate((e) => {
             if (handoffFinalSuppressed(e))
                 return false;
-            if (e.canceled || e.interjected || !ownsReplyEvent(e))
+            if (e.quiet || e.canceled || e.interjected || !ownsReplyEvent(e))
                 return false;
-            return router.finalReleased(e.target, e.serves, (events.get(e.id) ?? e).result?.body ?? "");
+            return router.finalReleased(e.target, e.serves, (events.get(e.id) ?? e).result?.body ?? "", reportSource(events.get(e.id) ?? e));
         });
         // boot 的路由表侧恢复 (T8): held 重查前置、answered 重投一次; 二者幂等, 与 events.resume
         // 重放的注入/回执撞上无害。
@@ -2192,7 +2271,8 @@ const main = async () => {
             // 自己就是计数器, 不另落一份。一次 tick 扫一遍收件箱就够 (这一轮不会再产新事件)。
             const fruitless = new Map();
             events.status().events.forEach((e) => {
-                if (!e.serves || e.result || e.canceled || e.execution !== "complete")
+                if (!e.serves || e.result || e.canceled || e.payload.peer?.from.receipt
+                    || !(e.execution === "complete" || e.execution === "uncertain" && e.exposure === "consumed" && e.turnClosedAt))
                     return;
                 fruitless.set(e.serves, (fruitless.get(e.serves) ?? 0) + 1);
             });
@@ -2645,22 +2725,29 @@ const main = async () => {
             const results = uniq.map((h, i) => {
                 const wr = wrs[i];
                 // 同一对并发多笔是允许的 (§4.1): 先取**还在排队**的那份 (那份还没进过你的会话); 都取过了就
-                // 报最新那件已交付 —— 绝不把已经 paste 过的那份当成新答案交回来。
+                // 报最新那件的投递状态 —— 绝不把已经 paste 过的那份当成新答案交回来。
                 const mine = router.settledTo(self).filter((r) => r.owner === h.target).reverse() // byAt → 新在前
-                    .map((row) => { const box = receiptOf(row); const execution = events.executionOf(box.id); return { row, box, ev: execution && { execution } }; });
-                const pick = mine.find((x) => x.ev?.execution === "queued") ?? mine[0];
+                    .map((row) => {
+                    const box = receiptOf(row);
+                    return { row, box,
+                        execution: events.executionOf(box.id), exposure: events.exposureOf(box.id) };
+                });
+                const pick = mine.find((x) => x.execution === "queued" && x.exposure === "none") ?? mine[0];
                 if (!pick)
                     return { name: h.address, idle: wr.idle, ...(wr.reason ? { reason: wr.reason } : {}),
                         ...(wr.idle ? { stale: true, reason: "它停下了, 但路由表上没有交回给你的定论 —— 多半停在一个等人点的弹窗上, 或那句话没被接住; peek_peer 看一眼" } : {}) };
-                // 回执早一步到了: 这段话已经作为新的一轮进过你的会话, 别处理第二遍。
-                if (pick.ev && pick.ev.execution !== "queued")
+                // Only an unexposed queued input can be claimed. Execution state alone
+                // proves neither consumption nor non-delivery, including old tombstones.
+                if (pick.execution !== "queued" || pick.exposure !== "none")
                     return { name: h.address, idle: wr.idle,
-                        ...(pick.ev.execution === "uncertain"
-                            ? { delivery: "uncertain", reason: "回执可能已递交，需按 receipt eventId 对账；没有自动重投或再次领取。" }
-                            : { delivered: true }) };
+                        eventId: pick.box.id, delivered: pick.exposure === "consumed", exposure: pick.exposure ?? "unknown",
+                        delivery: pick.exposure === "consumed" ? "consumed"
+                            : pick.execution === "uncertain" || !pick.exposure || pick.exposure === "possible" ? "uncertain" : pick.execution,
+                        reason: pick.exposure === "consumed" ? "回执已由会话消费，不重复领取。"
+                            : "结果已保存，尚未确认回执消费；按 eventId 对账，不自动重投或再次领取。" };
                 // 取走就撤单: 这一笔在收件箱里排着的**全部**回执一起作废 (need 之后又答完时排着两份, 取走
                 // 的那一份就是新结论, 旧的那份不再 paste 第二遍); `hand` 确认已交付 (已 handed 的是 no-op)。
-                if (pick.ev) {
+                if (pick.execution === "queued") {
                     events.cancel((x) => x.id.startsWith(`rcpt:${pick.row.event}:`) && x.execution === "queued", "taken by wait_peer");
                     router.commit(ops.hand({ event: pick.row.event, inbox: pick.box.id }));
                 }
@@ -4863,7 +4950,7 @@ const main = async () => {
                         const eventId = `quiet:${t}:${turn}`;
                         const revision = finalId(eventId, base, text);
                         events.delivery({ id: finalId(eventId, base, revision), eventId, target: t, turn, channel: base,
-                            revision, body: text, chunks: m.formatFinal(t, turn, base, text) });
+                            revision, body: text, purpose: "task", chunks: m.formatFinal(t, turn, base, text) });
                     }
                     log.info({ target: t, quiet: isQuiet(reply), len: reply.length }, "quiet task: 一轮结束");
                     quietRelays.drop(turn);