wezard 2.7.1 → 2.7.3

package/dist/daemon/index.js

@@ -51,7 +51,6 @@ import { baseOfKey, bindMultiBot, bindTagLinker, botOfKey, headed, ownHead, isIn
 import { appendEpisode, clipForCharter, cwdOfMd, episodePath, inboxPath, mdsOf, proposedCwds, memoryPath, memoryRoot, proposeMemory, readMemory } from "./wizard-memory.js";
 import { retireStewardTask, startSteward, stewardEnvelope, STEWARD_ID, STEWARD_RUN_MS, STEWARD_TARGET } from "./memory-steward.js";
 import { applyChatNames, chatBaseOf, chatNameOf, chatPolicyOf, clearChatName, listChatNames, normChatName, peerAddress, planChatNames, setChatName, stewardTierOf } from "./chat-name.js";
-import { createTopOnlyNudge, gcNudge, policyKeyOf, renderNudge } from "./top-only-nudge.js";
 import { bindWizardStore, loadWizardStore, wizardStore, settleName, settleAll, backfillBorn, sweepUnborn, BOOT_ID, evictStaleName, childrenOf, ancestorsOf, renderCharter, renderLead, renderLeadPlaybook, ROSTER_FRESH_MS, renderRoster, handoffAt, memoryNudgeAt, MEMORY_NUDGE_FLOOR, MEMORY_MAX, NOTE_MAX, } from "./wizard.js";
 import { activeRows, bindNoticeBox, createNoticeBox, createSeenRing, gcSeen, chatAudience, hears } from "./notices.js";
 import { createLedger, digest, pendingGc, renderDigest, renderTable, renderAwaiting, renderStalled, renderShelved, ago as agoMs, HEARD_EVERY_MS } from "./pending-items.js";
@@ -67,7 +66,7 @@ import { returnOpOf } from "./dispatch.js";
 import { isTerminal, renderInFlight, turnState } from "../shared/turn-state.js";
 import { startIdleNudge } from "./idle-nudge.js";
 import { askerFromEnvelope, renderReminder, withMsg } from "../shared/reminder.js";
-import { createHandoffs, handedOff, handingOff } from "./handoff.js";
+import { createHandoffs, cuttingTurn, handedOff, handingOff } from "./handoff.js";
 import { coldGateOf, decide, rankCandidates, renderCandidates, routeDutiesOf, tierFor, wakeCostOf } from "./route.js";
 import { parseWhen, renderChatLog, UNKNOWN_HUMAN } from "./chat-log.js";
 import { audienceOf } from "../shared/role-view.js";
@@ -214,6 +213,8 @@ const main = async () => {
             peerEvents?.accepted(e); },
         committed: (e) => { if (e.payload.peer)
             peerEvents?.committed(e); },
+        gone: (e) => { if (e.payload.peer)
+            peerEvents?.gone?.(e); },
         canceled: (e) => {
             if (e.payload.peer)
                 peerEvents?.canceled(e);
@@ -521,6 +522,11 @@ const main = async () => {
         const m = bridge;
         installMirrorEventListener(ws.client, m, log.child({ mod: "mirror" }));
         http.register("GET /message-events/status", (_req, res) => json(res, 200, events.status()));
+        // 单条 event 的 status 视图 (`?id=`; id 里带冒号, 不走路径段) —— 轮询单条不必把全表算一遍。
+        http.register("GET /message-events/event", (_req, res, url) => {
+            const e = events.event(url.searchParams.get("id") ?? "");
+            json(res, e ? 200 : 404, e ?? { error: "unknown event" });
+        });
         // 路由表的诊断视图 (`?owner=` = 那个 wizard 名下的行, 缺省 = 全表)。
         http.register("GET /routes", (_req, res, url) => {
             const owner = url.searchParams.get("owner")?.trim();
@@ -924,17 +930,6 @@ const main = async () => {
         const relayLabel = (t) => ((h) => (h ? tagLink(t, h) : ""))(tagHead(t));
         /** 以 `self` 的名义往 `dest` 群发一条: 头独占一行; 头怎么写 (群默认 wizard 报不报名) 归 ownHead。 */
         const postAs = (self, dest, text) => notifyChat(dest, headed(ownHead(self, dest), text, "\n\n"));
-        // 没开顶层模式的群里公开气泡多了 → 往那个群的管家 (群默认会话, target 就是 base principal) 信箱挂一行,
-        // 让它问人要不要开顶层模式 (见 top-only-nudge.ts)。路径里写聊天名: 管家照抄就能 config_set。
-        const topOnlyNudge = createTopOnlyNudge({
-            store: loadJsonMap("~/.wezard/top-only-nudge.json", gcNudge),
-            policy: () => ((p) => ({ windowMs: p.windowMin * 60_000, threshold: p.threshold, cooldownMs: p.cooldownH * 3_600_000 }))(cfg.wrc.mirror.topOnlyNudge),
-            nudge: (chat, n) => {
-                const p = cfg.wrc.mirror.topOnlyNudge;
-                notices.post([chat], renderNudge(policyKeyOf(chatNameOf(cfg, chat), chat), n, p.windowMin, p.cooldownH));
-                log.info({ chat, n }, "top-only nudge: 已提醒管家问人要不要开顶层模式");
-            },
-        });
         /** 公开的 wizard 间对话: 落在 `channel` 这个群。 */
         const relayPeer = (from, to, body, channel) => {
             const text = body.trim();
@@ -945,8 +940,6 @@ const main = async () => {
             // 头独占一行, 正文自成一个块 —— 只隔一个换行的话, markdown 会把正文首行
             // 当成头那一段的续行; 表格因此整张塌成一行带竖线的文字 (表格不能打断段落)。
             notifyChat(channel, `${head}\n\n${clipped}`);
-            if (!chatPolicyOf(cfg, channel).topOnly)
-                topOnlyNudge.count(baseOfKey(channel));
         };
         /** 调用方这一轮所在的公开频道: 人从哪个群叫的它 / 公开 peer 轮的那个群;
          *  私聊轮或无记录 → 它的 home 群。notify 与 public send_peer 默认发到这里。 */
@@ -986,8 +979,8 @@ const main = async () => {
         };
         /** 一笔活第几个来回 (§3.2): 同一行上已经注入过的续问数 + 1 —— 现算, 不落第二份数据。
          *  续问的注入事件 id 是 `route:<event>:r<legs>`, 所以从它自己就能数回来 (reload 也在盘上)。 */
-        const legsOf = (event) => events.status().events.reduce((n, e) => {
-            const m = e.id.startsWith(`route:${event}:r`) ? Number(e.id.slice(`route:${event}:r`.length)) : NaN;
+        const legsOf = (event) => events.ids().reduce((n, id) => {
+            const m = id.startsWith(`route:${event}:r`) ? Number(id.slice(`route:${event}:r`.length)) : NaN;
             return Number.isInteger(m) && m > n ? m : n;
         }, 1);
         /** 同一笔活上的一句续问 (idle-nudge 追问 / 工单打回): 不新开行, 注入事件 id
@@ -1008,8 +1001,9 @@ const main = async () => {
                     } } });
             return true;
         };
-        /** 已经因为不合工单验收被打回过的那些笔 (行状态会随打回留在 `open`, 光看它认不出「打回过」)。 */
-        const bounced = new Set();
+        /** 已经因为不合工单验收被打回过的那些笔 (行状态会随打回留在 `open`, 光看它认不出「打回过」)
+         *  → 被打回的那一轮的注入事件 id: 同一轮的终句重放 (见 deliverFinal) 认得出不是补交。 */
+        const bounced = new Map();
         /** 工单验收 (§9.6, 从 receipts 的 watcher 重建): 交的活不合规格 → 这一份不算交差。
          *  计划节点有自己的验收 (workflow), 不经这里。 */
         const acceptanceOf = (row, body) => {
@@ -1022,8 +1016,8 @@ const main = async () => {
             return j?.status === "open" ? rejectReason(j.accept ?? "result", parseClosing(body)) : undefined;
         };
         /** 以工单 owner 的名义在同一笔上打回一次: 不新开行, 行留在 `open` 等它按约定再交一份。 */
-        const rebound = (row, why) => {
-            bounced.add(row.event);
+        const rebound = (row, why, eventId) => {
+            bounced.set(row.event, eventId);
             const from = ledgerOwnerOf(row.event) || row.owner;
             acceptContinuation({
                 from, to: row.owner, channel: "", event: row.event, legs: legsOf(row.event) + 1,
@@ -1059,6 +1053,16 @@ const main = async () => {
             // 交接是生命周期事件, 不进群; 失败只捎给它自己 (它调完 handoff_self 拿到的是
             // scheduled:true, 不说的话它不知道上下文其实没换)。
             notify: (t, text) => notices.post([t], text),
+            // 交接没做成: 切断那一轮扣下的终句按原行补投 —— 走与轮终同一条 onFinal (行已被合成失败落定的, 照追述规则处理)。
+            uncut: (t, ids) => ids.forEach((id) => {
+                const e = events.get(id);
+                if (!e?.result) {
+                    log.warn({ target: t, event: id }, "handoff: 扣下的终句已不在事件库, 补投不了");
+                    return;
+                }
+                log.info({ target: t, event: id, serves: e.serves }, "handoff: 交接没做成, 补投切断那一轮的终句");
+                settleFinal(e, { text: e.result.body });
+            }),
             log,
             store: loadJsonMap(cfg.wrc.mirror.handoffsFile),
             archive: (e) => {
@@ -1082,7 +1086,7 @@ const main = async () => {
             const waiting = r.kind === "wizard" ? r.to : baseOfKey(r.channel); // 等着它交代的那一方 (信封挂在它名下)
             const channel = r.kind === "chat" ? r.channel : ""; // 结论要落回群里时才带频道 (§9.4)
             const base = `route:${event}:resume`;
-            const id = events.status().events.some((e) => e.id === base) ? `${base}:${at}` : base;
+            const id = events.known(base) ? `${base}:${at}` : base;
             try {
                 events.accept({
                     id, identity: JSON.stringify([t, event, "resume", at]),
@@ -1250,7 +1254,12 @@ const main = async () => {
                 if (row.job && isTerminal(out.status) && !row.late)
                     jobs.settle(row.job, row.owner, out.status, parseClosing(out.body).artifacts, { turn: event });
             }
-            const esc = router.escalate(event, (k) => !!wizards.get(k));
+            postRoute(row, out, router.escalate(event, (k) => !!wizards.get(k)), `rcpt:${event}:${out.rev}`);
+        };
+        /** 一份定论的投递 (账本已记过): 投给升级后的收方 `esc` (没有 = 行上的 receiver)。群收方只落
+         *  `hand`; wizard 收方 (含 Dead Letter 退到的群默认 wizard) 进收件箱, id = `inbox`。 */
+        const postRoute = (row, out, esc, inbox) => {
+            const event = row.event;
             const receiver = esc?.receiver ?? row.receiver;
             const via = (esc?.via ?? []).map(displayName);
             // 升级落在 chat 根 = Dead Letter: 退到那个群, 由它的默认 wizard 收下这份结论。
@@ -1274,7 +1283,6 @@ const main = async () => {
             const retellTo = late && servedRow && servedRow.owner === to && servedRow.outcome?.status !== "canceled"
                 ? servedRow.receiver.kind === "wizard" ? displayName(servedRow.receiver.to) : chatNameOf(cfg, servedRow.receiver.channel) || servedRow.receiver.channel
                 : undefined;
-            const inbox = `rcpt:${event}:${out.rev}`;
             const job = row.job ? jobs.get(row.job) : undefined;
             const tally = row.job ? jobs.tally(row.job) : undefined;
             events.accept({
@@ -1299,6 +1307,34 @@ const main = async () => {
             });
             router.commit(ops.hand({ event, inbox }));
         };
+        /** 收件箱里那份回执投不到了 (`gone`: 收方没有绑定, 按 store 也恢复不了) —— 投进去时它还在
+         *  注册表上, 升级没跳过它。现在把它当不在, 沿 receiver 边重走一次升级: 能收的上层 wizard /
+         *  群根 (Dead Letter) 收下。链上无处可升 (根行的收方自己没了): canceled 是收掉它的那一方自己
+         *  发起的, 没人在等, 不再投; 别的定论退到收方的家群 (Dead Letter)。账本不再记第二遍。 */
+        const rerouteGone = (e) => {
+            const from = e.payload.peer?.from;
+            const event = from?.receipt ? from.event : undefined;
+            const row = event ? router.get(event) : undefined;
+            if (!event || !row || !from?.status) {
+                log.warn({ id: e.id, target: e.target }, "receipt reroute: 认不出回执的那一行, 投不出去");
+                return;
+            }
+            const reachable = (k) => k !== e.target && !!wizards.get(k) && !!mirrorStore.get(k);
+            const home = baseOfKey(e.target);
+            const esc = router.escalate(event, reachable)
+                ?? (row.receiver.kind === "wizard" && reachable(row.receiver.to) ? undefined
+                    : from.status === "canceled" || home === e.target ? null
+                        : { receiver: { kind: "chat", channel: home, message: "" }, serves: "", via: [e.target] });
+            if (esc === null) {
+                log.info({ id: e.id, target: e.target, event, status: from.status }, "receipt reroute: 收方已不在且无处可升, 不再投");
+                return;
+            }
+            const rev = e.id.slice(`rcpt:${event}:`.length).split("~")[0];
+            const prefix = `rcpt:${event}:${rev}~`;
+            const inbox = `${prefix}${events.ids().filter((id) => id.startsWith(prefix)).length + 1}`;
+            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);
+        };
         /** 一条路由 op: 先落盘, 再投该投的 (need / error 带正文入箱; answer 按 receiver 投递)。这里
          *  只管 `re` (`mark open`) 把那一行拉回在飞 —— 账本与工单跟着 deliverRoute 走。 */
         const commitRoute = (op) => {
@@ -1320,6 +1356,23 @@ const main = async () => {
          *  也最多再多打回一次)。**这是「轮终 evidence → onFinal」那条主触发链的落点**: 没有它,
          *  answer 就只能靠 sweeper / 级联取消 / boot 重放合成, 谁答完都不会有回执。 */
         deliverFinal = (e, verdict) => {
+            // 同一轮的终句会递进来两次: result() 当场递一次, 泵见 complete 未 finalized 再补判一次
+            // (message-events)。被打回那一轮的重放不是补交 —— 丢掉; 否则 bounced 已记着这一笔,
+            // 第二次就把被打回的原文照收成 done (打回的续问还没注入, 定论先落了)。
+            if (e.serves && bounced.get(e.serves) === e.id)
+                return;
+            // 自我交接切断的那一轮: 收尾那句不是欠着的那几笔的答案 —— 行留 open, 交给新会话的「继续 <event>」。
+            // 扣下记在这场交接上: 交接没做成 (新会话没起来), 它就是那几笔仅有的交代, 由 uncut 补投。
+            if (cuttingTurn(e.target)) {
+                log.info({ event: e.id, target: e.target, serves: e.serves }, "handoff: 交接切断的那一轮终句不落定");
+                if (!verdict.error)
+                    handoffs.cut(e.target, e.id);
+                return;
+            }
+            settleFinal(e, verdict);
+        };
+        /** 一轮的终句落到它服务的那一行上 (定论 / 中途态), 验收不合规格就打回续问。 */
+        const settleFinal = (e, verdict) => {
             const plans = router.onFinal(e.target, e.serves, verdict);
             const answer = plans.flatMap((op) => (op.op === "answer" && op.outcome.status === "done" ? [op] : []))[0];
             const row = answer ? router.get(answer.event) : undefined;
@@ -1327,7 +1380,7 @@ const main = async () => {
             if (row && why) {
                 if (row.status === "need" || row.status === "error")
                     commitRoute(ops.mark({ event: row.event, status: "open" }));
-                rebound(row, why);
+                rebound(row, why, e.id);
                 return;
             }
             plans.forEach(commitRoute);
@@ -1879,7 +1932,9 @@ const main = async () => {
             valid: (e) => {
                 const p = e.payload.peer;
                 const attempt = p.attemptId ? workflow.byTurn(e.speaker, p.from.event ?? "") : undefined;
-                return planStore.healthy() && !e.canceled && (!p.from.receipt || planContinuationAllowed(e.target)) && (!p.job || jobs.get(p.job)?.status === "open") && !attempt?.canceled
+                // 单已收但这一笔的行还 open = 收工前就派出去的活, 照投 (见 close_job)。
+                return planStore.healthy() && !e.canceled && (!p.from.receipt || planContinuationAllowed(e.target))
+                    && (!p.job || jobs.get(p.job)?.status === "open" || (!!e.serves && router.get(e.serves)?.status === "open")) && !attempt?.canceled
                     && (!p.after?.length || prereqsOf(e.speaker, p.after).every((r) => r.state === "done" || r.state === "pending"));
             },
             accepted: (e) => {
@@ -1918,6 +1973,15 @@ const main = async () => {
                 if (p.attemptId)
                     workflow.cancel(e.target, e.speaker, p.job, p.from.event);
             },
+            // 收方没了: 回执沿链改投; 派活 / 续问不另做 —— 那一行的 owner 就是它, sweeper 见 pane 不在判 dead 上浮。
+            gone: (e) => {
+                const p = e.payload.peer;
+                log.warn({ id: e.id, target: e.target, receipt: !!p.from.receipt }, "message event: 收方已不在 (无绑定, 恢复失败), 不再重投");
+                if (p.attemptId)
+                    workflow.dispatched(p.attemptId, false);
+                if (p.from.receipt)
+                    rerouteGone(e);
+            },
             ready: async (e) => prereqsOf(e.speaker, e.payload.peer.after ?? []).every((r) => r.state === "done")
                 && (e.priority === "now" || await m.idleNow(e.target) || !(await m.paneLive(e.target)) || (e.priority === "urgent" && !(await othersTurn(e.target, e.speaker)))),
             inject: async (e, boundary) => {
@@ -1956,6 +2020,7 @@ const main = async () => {
                 return false;
             return router.finalReleased(e.target, e.serves, (events.get(e.id) ?? e).result?.body ?? "");
         });
+        m.setEventHandedAway((e) => { const row = e.serves ? router.get(e.serves) : undefined; return !!row && row.owner !== e.target; });
         // boot 的路由表侧恢复 (T8): held 重查前置、answered 重投一次; 二者幂等, 与 events.resume
         // 重放的注入/回执撞上无害。
         void m.restored.then(() => { events.resume(); settleHeld(); replayAnswered(); });
@@ -2273,6 +2338,9 @@ const main = async () => {
             catch (error) {
                 return { status: 409, body: { ok: false, eventId, reason: errText(error) } };
             }
+            // 交出的是人问的那一笔: 那句话的气泡跟着行走, 接手方开轮时接过去续写 (不另开新气泡)。
+            if (handedChat && serves)
+                m.handBubble(self, serves, eventId, target);
             // `re` 把那一笔从 need / error 拉回 open (§3.2 的 need→open / error→open): 行状态是「这份中途态
             // 已经报过了」的去重记号 —— 不拉回去, owner 下一轮交同一个中途态就被静默吞掉 (往返断在这里)。
             if (reTarget && (reTarget.status === "need" || reTarget.status === "error"))
@@ -2424,7 +2492,7 @@ const main = async () => {
                 // 同一对并发多笔是允许的 (§4.1): 先取**还在排队**的那份 (那份还没进过你的会话); 都取过了就
                 // 报最新那件已交付 —— 绝不把已经 paste 过的那份当成新答案交回来。
                 const mine = router.settledTo(self).filter((r) => r.owner === h.target).reverse() // byAt → 新在前
-                    .map((row) => { const box = receiptOf(row); return { row, box, ev: events.get(box.id) }; });
+                    .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];
                 if (!pick)
                     return { name: h.address, idle: wr.idle, ...(wr.reason ? { reason: wr.reason } : {}),
@@ -3284,10 +3352,9 @@ const main = async () => {
                 json(res, 409, { ok: false, reason: "transfer hands over the row this turn owes; a lead dispatch cannot transfer" });
                 return;
             }
-            if (transfer && (!plan.serves || router.get(plan.serves)?.receiver.kind !== "wizard")) {
-                json(res, 409, { ok: false, reason: "这一轮没有欠着的同伴活可以交出去 (transfer 只用于同伴派给你的那一笔)" });
-                return;
-            }
+            // 交出人问的那一笔同样合法 (同 tell_peer): 那一行归 chat receiver, 与同伴派的件走同一条
+            // move —— 接手方终句就是那句人话的答复。没得交 (`serves` 落空 / 已不在手上) 由
+            // transferRefusal 在投递前拦, 不在这里按 receiver 种类预判。
             const force = b.force === true;
             const to = (b.to ?? "").toString().trim();
             const now = Date.now();
@@ -3363,12 +3430,8 @@ const main = async () => {
                 d = { kind: "spawn", why: `${d.why}; 但它被${t.body.gated === "direction" ? "方向闸" : "冷门控"}退回 (${String(t.body.reason)}) —— 改为白板 spawn` };
             }
             const name = (b.name ?? "").toString().trim();
-            const description = (b.description ?? "").toString().trim();
-            if (!name || !description) {
-                settleRoot(false);
-                json(res, 400, { ok: false, decision: "spawn", reason: `${d.why} —— 要新生一个, 带上 name (这件事的短名) 与 description (它的职责) 重发`, ...(shown.length ? { candidates: shown } : {}) });
-                return;
-            }
+            const description = (b.description ?? "").toString().trim() || clipLine(task, 120);
+            // 空 name 交给 bearAs / claimSlot 按职责自动取名避重, 不当作显式点名复用旧记录。
             const tier = taskTier;
             const born = await bearAs(self, { inherit: false, name, description, tier, ...(lead ? { lead: true } : {}) }, undefined, dispatchOrigin?.authority);
             if (born.status !== 200) {
@@ -3478,9 +3541,8 @@ const main = async () => {
                 const plan = b.task?.trim() && !planned ? planReturn(self, body) : undefined;
                 if (plan && !plan.ok)
                     return { status: plan.status, body: { ok: false, reason: plan.reason } };
-                // transfer 只对同伴派给你的那一笔有意义 (要交出去的那一行得真的欠在同伴头上)。
-                if (plan?.ok && plan.op === "transfer" && (!plan.serves || router.get(plan.serves)?.receiver.kind !== "wizard"))
-                    return { status: 409, body: { ok: false, reason: "这一轮没有欠着的同伴活可以交出去 (transfer 只用于同伴派给你的那一笔)" } };
+                // transfer 交出人问的那一笔同样合法 (同 tell_peer, 那一行归 chat receiver) —— 没得交 /
+                // 已不在手上由下面的 transferRefusal 拦, 不在这里按 receiver 种类预判。
                 const askedEffort = parseEffort(b.effort);
                 if (b.effort !== undefined && !askedEffort) {
                     return { status: 400, body: { ok: false, reason: `effort 只有这几档: ${EFFORTS.join(" / ")}` } };
@@ -3654,21 +3716,28 @@ const main = async () => {
                 if (dispatched) {
                     const deadlineAt = deadlineOf(taskAt);
                     const quiet = !!plan?.ok && plan.op === "none";
+                    // transfer 交出的是人问的那一笔 (同 tell_peer): 注入事件得带上那个群, 否则频道为空被当
+                    // 私聊轮扣下, 刚出生的接手方那句终句人永远收不到 (见 mirror-bridge 的 final 通道)。
+                    // 同伴派的件 (receiver 是 wizard) 仍旧私聊 —— handedChat 为空, 行为不变。
+                    const handed = plan?.ok && plan.op === "transfer" && plan.serves ? router.get(plan.serves)?.receiver : undefined;
+                    const handedChat = handed?.kind === "chat" ? handed.channel : "";
                     // 路由行 (§3.1): 生出来的那个领活, 结论回生它的这位。
                     const serves = plan?.ok
                         ? openDispatchRow({ self, target, op: plan.op, deadlineAt, job: jobId, ...(asker ? { asker } : {}), ...(plan.serves ? { serves: plan.serves } : {}) })
                         : "";
                     dispatchedEvent = serves;
                     const eventId = serves ? `route:${serves}` : `p:${self}:${target}:${taskAt}:1`;
-                    const birthTell = { from: self, to: target, channel: "", job: jobId, at: taskAt, event: serves, legs: 1, deadlineAt, asker, dispatchKey: eventId };
-                    events.accept({ id: eventId, target, speaker: self, channel: "", serves, asker, priority: "normal", deadline: deadlineAt,
+                    const birthTell = { from: self, to: target, channel: handedChat, job: jobId, at: taskAt, event: serves, legs: 1, deadlineAt, asker, dispatchKey: eventId };
+                    events.accept({ id: eventId, target, speaker: self, channel: handedChat, serves, asker, priority: "normal", deadline: deadlineAt,
                         payload: { text: task, peer: {
-                                from: { kind: "peer", from: self, event: serves, ...(jobId ? { job: jobId } : {}), ...(asker ? { asker } : {}) },
-                                envelope: envelopeFor(self, "", { asker, ...(quiet ? { quiet: true } : {}) }) + (b.lead === true ? renderReminder({ wezard: "lead" }, renderLeadPlaybook()) : ""),
+                                from: { kind: "peer", from: self, event: serves, ...(jobId ? { job: jobId } : {}), ...(handedChat ? { transferred: true } : {}), ...(asker ? { asker } : {}) },
+                                envelope: envelopeFor(self, handedChat, { asker, ...(quiet ? { quiet: true } : {}) }) + (b.lead === true ? renderReminder({ wezard: "lead" }, renderLeadPlaybook()) : ""),
                                 ...(quiet ? {} : { tell: birthTell }),
                                 job: jobId, kind: "task", spawned: true, role: roleParam(body.role),
                                 ...(plan?.ok && plan.op === "transfer" ? { transferred: true } : {}),
                             } } });
+                    if (handedChat && serves)
+                        m.handBubble(self, serves, eventId, target);
                 }
                 else if (jobId && birthGuard()) {
                     jobs.attach(jobId, { target, task: "", spawned: true, ...(roleParam(body.role) ? { role: roleParam(body.role) } : {}) });
@@ -4018,8 +4087,10 @@ const main = async () => {
                 // 这张单名下还排着没投的 (held: 等前置 / 没轮上) 也不投了 —— 单都关了, 它再也轮不到
                 // (注入的闸要求单还开着)。receipts.cancelHeld 同一条, 那边只做账 (T6)。
                 cancelRoutes(router.rows().filter((r) => r.status === "held" && r.job === j.id).map((r) => r.event), () => `随工单 ${j.id} 收了, 这件排着的活没投。`, j.owner);
-                // 这张单名下还排着没投的 (after 停放) 也不投了。
-                events.cancel((e) => e.speaker === j.owner && e.payload.peer?.job === j.id);
+                // 这张单名下还排着没投的 (after 停放) 也不投了。行还 open 的那笔是已经派出去的活
+                // (出生事件常在冷 pane 上排着没注入): 收工 (accept) 不收活 —— 照投、照答, 回执标「已经收工」;
+                // 行被上面级联落定 (cancel / held) 的、没开行的才撤。
+                events.cancel((e) => e.speaker === j.owner && e.payload.peer?.job === j.id && router.get(e.serves ?? "")?.status !== "open");
                 const closed = jobs.close(j.id, summary, mark);
                 ledger.closeJob(j.id);
                 // 收工结论留档到开单者名下 (与交接简报同一份 jsonl); 空工单 (没人、没结论) 不记。
@@ -4862,9 +4933,14 @@ const main = async () => {
         }
         setTimeout(() => void sweep().catch((e) => log.warn({ err: e.message }, "pane cap sweep failed")), 15_000).unref();
     }
+    let shuttingDown = false;
     const shutdown = async (signal) => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
         log.info({ signal }, "shutdown signal");
-        events.stop();
+        // Pause delivery, but persist arrivals while transports/in-flight handlers drain.
+        events.drain();
         stopSweep();
         scheduler.stop();
         steward?.stop();
@@ -4879,6 +4955,7 @@ const main = async () => {
         setTimeout(() => process.exit(0), 1500).unref();
         await new Promise((r) => setTimeout(r, 200));
         await Promise.allSettled([ws.shutdown(), http.close()]);
+        events.stop();
         process.exit(0);
     };
     http.register("POST /shutdown", (_req, res) => {