wezard 2.7.3 → 2.7.7

package/dist/daemon/index.js

@@ -2,7 +2,7 @@ import { wxMarkdown } from "../shared/wx-text.js";
 // Daemon entry. Resident process — exits only on signal or fatal WS auth failure.
 import { existsSync, readFileSync, renameSync, statSync } from "node:fs";
 import { join } from "node:path";
-import { timingSafeEqual, randomBytes } from "node:crypto";
+import { timingSafeEqual, randomBytes, randomUUID } from "node:crypto";
 import { loadOrCreateSvrToken } from "../shared/svr-token.js";
 import { DAEMON_TOKEN_FILE, DAEMON_TOKEN_HEADER } from "../shared/daemon-token.js";
 import { homedir } from "node:os";
@@ -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";
@@ -47,11 +47,12 @@ import { openTaskRegistry } from "./task-registry.js";
 import { deliverScheduled } from "./scheduled-delivery.js";
 import { describeTrigger, nextFire, parseTrigger, WHEN_HELP } from "../shared/trigger.js";
 import { isQuiet, slugify, uniqueId } from "../shared/task-file.js";
-import { baseOfKey, bindMultiBot, bindTagLinker, botOfKey, headed, ownHead, isInternalKey, keyOf, linkTags, normalizeTag, sameBot, speakerHead, tagFromCwd, tagHead, tagLink, tagOfKey, uniqueTag, withTagHeader } from "../shared/session-label.js";
+import { baseOfKey, bindMultiBot, bindTagLinker, botOfKey, headed, ownHead, isInternalKey, keyOf, linkTags, normalizeTag, sameBot, speakerHead, tagHead, tagLink, tagOfKey, uniqueTag, withTagHeader } from "../shared/session-label.js";
 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 { 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 { applyChatNames, chatBaseOf, chatNameOf, chatPolicyOf, clearChatName, listChatNames, normChatName, peerAddress, planChatNames, setChatName } from "./chat-name.js";
+import { bindWizardStore, loadWizardStore, pickName, 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 { AutoNameExhausted } from "./wizard-names.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";
 import { checkDirection } from "./direction.js";
@@ -204,11 +205,20 @@ const main = async () => {
     let peerEvents;
     /** T4: 路由表的投递层 —— 在 mirror 大块里接线 (要用到 jobs / 回执信封 / 事件泵), 这里先留个口。 */
     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,
         sessionId: (target) => bridge.inputSessionInfo(target)?.sessionId,
-        valid: (e) => e.payload.peer ? !!peerEvents?.valid(e) : true,
+        valid: (e) => (!(e.payload.handoff || (e.id.startsWith("route:") && e.id.includes(":resume:"))) || handoffAllowed(e.target)) && (e.payload.peer ? !!peerEvents?.valid(e) : true),
         accepted: (e) => { if (e.payload.peer)
             peerEvents?.accepted(e); },
         committed: (e) => { if (e.payload.peer)
@@ -223,15 +233,25 @@ 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 自己的输入队列
         // (贴进运行中的一轮记成 queued 轮, 终句照样归到这条 event —— 见 brief 的 seal/bindLine)。
         // 这一句曾是要 idleNow 的, 也就是那个反复 5s 超时的探测源头: 一超时就退避, 把同一 target
         // 后面排着的每一笔 (含后到的人话) 一起钉住十几分钟。交接期间照旧等 —— 那几秒 pane 真是死的。
-        ready: async (e) => !handingOff(e.target) && (e.payload.peer ? !!(await peerEvents?.ready(e)) : true),
+        ready: async (e) => e.payload.handoff ? handoffAllowed(e.target) && bridge.idleNow(e.target) : !handingOff(e.target) && (e.payload.peer ? !!(await peerEvents?.ready(e)) : true),
         inject: async (e, boundary) => {
+            if (e.payload.handoff) {
+                const expected = e.payload.handoff;
+                const same = () => { const info = bridge.sessionInfo(e.target); return info?.tmuxPane === expected.pane && info?.sessionId === expected.sessionId; };
+                if (!same())
+                    return { ok: false, reason: "handoff original pane/session changed; refusing brief injection" };
+                return bridge.injectText(e.target, e.payload.text, undefined, {
+                    channel: e.channel, eventId: e.id, envelope: renderReminder({ wezard: "envelope", kind: "peer", from: wizardStore()?.get(e.target)?.name || e.target, scope: "private", msg: e.id }, []), requireIdle: true, noRespawn: true, handoff: expected.clear,
+                    guard: (phase, identity) => handoffAllowed(e.target) && same() && (!identity?.sessionId || identity.sessionId === expected.sessionId) && boundary(phase, identity),
+                });
+            }
             if (e.payload.peer)
                 return peerEvents.inject(e, boundary);
             if (!bridge.hasMirrorTarget(e.target)) {
@@ -268,20 +288,34 @@ 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) }
                         : {}) };
             }
             return { consumed: false };
         },
-        recovered: (e) => bridge.recoverEventFinal(e),
+        recovered: (e) => { if (!handoffFinalSuppressed(e))
+            bridge.recoverEventFinal(e); },
         // T4: 终句 → 路由表。onFinal 连同投递一起做 —— 定论先落盘 (`answer`), 再按 receiver
         // 投出去 (§9.3/§9.4); 实现在 mirror 大块里 (要 jobs / 信封 / 事件泵)。
         final: (e, verdict) => deliverFinal?.(e, verdict),
         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}`);
@@ -289,8 +323,8 @@ const main = async () => {
                     uncertain: result.state === "uncertain" ? result.reason ?? "Weixin send ACK unknown" : undefined,
                     failed: result.state === "failed" ? result.reason ?? "Weixin final rejected" : undefined };
             }
-            const stream = d.stream && n === 0 && d.chunks.length === 1 && Date.now() < d.stream.expires ? d.stream : undefined;
-            const ack = await responseTracker.sendFrozen(chat, d.chunks[n], stream, events.running);
+            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() && 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" };
         },
@@ -686,24 +720,25 @@ const main = async () => {
                 return;
             }
             const foreign = base !== baseOfKey(self);
-            const slotR = await claimSlot(base, String(body.name ?? body.tag ?? ""), tagFromCwd(cwd) || "peer", [self]);
+            const slotR = await claimSlot(base, String(body.name ?? body.tag ?? ""), [self]);
             if (!slotR.ok) {
                 json(res, slotR.status, slotR.body);
                 return;
             }
-            const { target, slot: tag } = slotR;
-            if (!planStore.allowExternal(target, wizards.get(target)?.name ?? tag)) {
-                json(res, 409, { ok: false, reason: "workflow plan reserves this executor" });
-                return;
-            }
-            const existed = !!wizards.get(target);
-            const name = wizards.rename(target, normalizeTag(String(body.name ?? body.tag ?? "")) || tag);
+            const { target, name } = slotR;
             const model = (body.model ?? "").toString().trim();
             log.child({ mod: "mirror", sub: "sessions-new", target }).info({ self, cwd, foreign, cli: body.cli, model }, "spawning peer session");
             // silent: 新 wizard 就位不进群 (生命周期事件), 同群的 wizard 从名册增量里得知。
-            const r = await m.newSession(target, name, body.cli, { cwd, model, silent: true, guard: () => planStore.allowExternal(target, wizards.get(target)?.name ?? name) });
-            if (!r.ok && !existed)
-                wizards.drop(target);
+            const r = await m.newSession(target, name, body.cli, { cwd, model, silent: true, guard: () => ownsSlot(slotR) && planStore.allowExternal(target, wizards.get(target)?.name ?? name) })
+                .catch((e) => ({ ok: false, reason: `spawn threw: ${String(e)}` }));
+            if (!ownsSlot(slotR)) {
+                json(res, 409, { ok: false, reason: "birth identity replaced during spawn" });
+                return;
+            }
+            if (!r.ok)
+                releaseSlot(slotR);
+            else
+                finishSlot(slotR);
             if (r.ok)
                 postRoster(base, [target, self], { op: "born", name: `.${name}`, by: displayName(self), cwd: r.cwd }, subjectOf(wizards.get(target)));
             json(res, r.ok ? 200 : 500, r.ok
@@ -746,16 +781,7 @@ const main = async () => {
             const r = await m.injectText(target, text, undefined, { guard });
             json(res, r.ok ? 200 : 500, r);
         });
-        // One-shot project switch: bind the chat-wide cwd AND apply it right here.
-        // 活会话走交接 (handoff): 守护进程请它写简报 → 重开 (pendingCwd 在这一步被消费,
-        // 落进新目录, 宪章随之重渲染) → 简报贴回, 上下文跟着过去, 「📂 当前项目」气泡
-        // 照发 (announce —— 那是人看得见的回执)。一律 fire-and-forget: 调用方常常就是被换
-        // 的那个, 它得先拿到这份应答、把这一轮说完, 交接才动得了手 (other 的第一拍就是等它
-        // 闲)。交接没做成 → 捎一条提醒给它, pendingCwd 仍排着队, 人手 /new 照样完成切换
-        // (若它本就在交接中, 那场交接的重开同样会消费这笔 pendingCwd)。冷会话 (pane 不在)
-        // 没有可交接的上下文, 按老路直接新开。Resolved target
-        // precedence: explicit body.target → sessionId-derived (so MCP can omit
-        // it) → tmuxPane (stable across /clear) → cfg.defaultChat.
+        // 工作目录属于 CLI 进程; 活会话只记录 pending, 必须由人显式 /new 应用。
         http.register("POST /mirror/workspace", async (req, res) => {
             const body = (await readBody(req));
             const cwd = (body.cwd ?? "").toString();
@@ -785,12 +811,8 @@ const main = async () => {
                 return;
             }
             if ((await liveOf([target])).length) {
-                const focus = `工作区切到 ${set.pendingCwd}: 简报里点一句手头活在新目录下怎么接着干`;
-                void handoffs.other(target, focus, CHARTER_HANDOFF_MS, { announce: true }).then((r) => {
-                    if (!r.ok)
-                        notices.post([target], `换工作区到 ${set.pendingCwd} 的自动交接没做成: ${r.reason} —— 切换仍排着队, 手上这件告一段落后自己 \`handoff({brief})\`, 或让人在群里 /new 一下`);
-                });
-                json(res, 200, { ok: true, target, cwd: set.pendingCwd, scheduled: true });
+                json(res, 409, { ok: false, target, runningCwd: set.runningCwd, pendingCwd: set.pendingCwd,
+                    reason: "原 CLI 进程不能切换工作目录；请求已保留为 pendingCwd，需要显式 /new 才生效，handoff /clear 不会应用它" });
                 return;
             }
             // Same shape as inbound's /new: windowName = tag for tagged sessions,
@@ -977,6 +999,7 @@ const main = async () => {
                 && !a.canceled && a.acceptance !== "rejected" && jobs.get(r.plan.job)?.status === "open" && ["running", "needs-input", "errored"].includes(a.execution)
                 && (r.plan.nodes.find((x) => x.id === n.id)?.after ?? []).every((id) => workflow.prereq(r.owner, r.nodes.find((x) => x.id === id).turn)?.state === "done");
         };
+        handoffAllowed = (target) => planContinuationAllowed(target) && !planStore.reservation(target, wizards.get(target)?.name);
         /** 一笔活第几个来回 (§3.2): 同一行上已经注入过的续问数 + 1 —— 现算, 不落第二份数据。
          *  续问的注入事件 id 是 `route:<event>:r<legs>`, 所以从它自己就能数回来 (reload 也在盘上)。 */
         const legsOf = (event) => events.ids().reduce((n, id) => {
@@ -1032,21 +1055,67 @@ const main = async () => {
         // 闸、回执清点与断点续做在那边。
         /** 情景记忆 (memory/episodes/<name>.jsonl) 按名字归档; 默认会话没名字时退回 slot / "default"。 */
         const episodeName = (t) => wizards.get(t)?.name || tagOfKey(t) || "default";
+        const handoffStore = loadJsonMap(cfg.wrc.mirror.handoffsFile, undefined, { strict: true });
+        handoffFinalSuppressed = (event) => {
+            const e = events.get(event.id) ?? event;
+            if (e.handoffRestored)
+                return false;
+            if (e.handoffCut)
+                return true;
+            const p = handoffStore.get(e.target);
+            // 先读在飞事务的明确旧事件集合, 覆盖 result 已写而事件 cut 尚未写的崩溃缝。
+            return !!p && p.mode === "self" && !p.failure?.compensated && !!p.cut?.includes(e.id);
+        };
         const handoffs = createHandoffs({
-            isBusy: m.isBusy,
+            currentEvents: (t) => {
+                const info = m.sessionInfo(t);
+                const active = info?.jsonlPath ? openingTurn(expandHome(info.jsonlPath))?.env?.eventId : undefined;
+                return events.ids().filter((id) => {
+                    const e = events.get(id);
+                    return !!e && e.target === t && !e.payload.handoff && (id === active || (!e.finalized && e.execution !== "canceled" && e.exposure !== "none" && (!e.sessionId || e.sessionId === info?.sessionId)));
+                });
+            },
+            suppress: (ids) => ids.forEach((id) => events.suppressHandoffFinal(id)),
+            isBusy: async (t) => {
+                if (!(await m.idleNow(t)))
+                    return true;
+                // TUI 已 idle 不代表旧 final 已被事件泵消费; 先落旧轮结果, 再允许切断上下文。
+                const old = events.ids().map((id) => events.get(id)).filter((e) => !!e && e.target === t && !e.id.startsWith("handoff:") && e.exposure !== "none" && !e.finalized && !e.releasedAt && e.execution !== "canceled" && (!e.sessionId || e.sessionId === m.sessionInfo(t)?.sessionId));
+                await old.reduce(async (before, e) => { await before; await events.reconcile(e.id); }, Promise.resolve());
+                return old.some((e) => { const now = events.get(e.id); return now && !now.finalized && now.execution !== "canceled"; });
+            },
             sessionId: (t) => m.sessionInfo(t)?.sessionId ?? "",
-            restart: (t, p) => restartFresh(t, p),
+            restart: (t, p, submitted) => clearForHandoff(t, p, submitted),
             // 简报是新会话的开场白, 但它不挂任何信封 (服务不着哪一笔) —— 交接前欠着的那几笔由
             // 「继续 <event>」逐笔续答 (见 resume), 别把简报那一轮的回复当成回执。
-            inject: async (t, text, channel) => {
+            inject: async (t, text, channel, id, timeoutMs, clear) => {
                 if (!planContinuationAllowed(t))
                     return { ok: false, reason: "workflow continuation withdrawn" };
                 if (planStore.reservation(t, wizards.get(t)?.name))
                     return { ok: false, reason: "workflow handoff requires the original attempt" };
-                return m.injectText(t, text, undefined, { channel, guard: () => planContinuationAllowed(t) });
+                if (clear && !(await m.verifyClearContext(t, clear)))
+                    return { ok: false, reason: "original cleared CLI process/session changed before carry" };
+                // 事件先落盘; 同一 id 重入只恢复状态, 不重贴。内部事件没有 serves, 不替任何欠账收口。
+                if (!events.known(id)) {
+                    const info = clear ? { tmuxPane: clear.pane, sessionId: clear.nextSid } : m.sessionInfo(t);
+                    if (!info?.tmuxPane || !info.sessionId)
+                        return { ok: false, reason: "original handoff pane/session binding is unavailable" };
+                    events.accept({ id, identity: JSON.stringify({ pane: info.tmuxPane, sid: info.sessionId }), target: t, speaker: t, channel, priority: "now", deadline: Date.now() + timeoutMs,
+                        payload: { text, handoff: { pane: info.tmuxPane, sessionId: info.sessionId, ...(clear ? { clear } : {}) } } });
+                }
+                for (const end = Date.now() + timeoutMs; Date.now() < end; await sleep(200)) {
+                    const e = await events.reconcile(id);
+                    if (e?.execution === "complete" || (!id.endsWith(":summary") && e?.exposure === "consumed"))
+                        return { ok: true };
+                    if (e?.execution === "uncertain" || e?.execution === "canceled")
+                        return { ok: false, reason: e.reason ?? "handoff event delivery is uncertain; not resubmitting" };
+                }
+                events.cancel((e) => e.id === id && e.exposure === "none", "handoff stopped before confirmed delivery");
+                return { ok: false, reason: "handoff event consumption not confirmed; durable event retained" };
             },
             channelOf: m.currentChannel,
             lastText: m.lastText,
+            summary: (id) => { const e = events.get(id); return e?.execution === "complete" && e.exposure === "consumed" && typeof e.result?.body === "string" ? e.result.body : undefined; },
             // 欠账不落盘在交接里: 路由表按 target 记着它欠谁、欠哪几笔, 换会话不影响 (T8)。
             owed: (t) => router.owedBy(t).filter((r) => r.status === "open").map((r) => r.event),
             resume: async (t, event, at) => injectResume(t, event, at),
@@ -1056,15 +1125,20 @@ const main = async () => {
             // 交接没做成: 切断那一轮扣下的终句按原行补投 —— 走与轮终同一条 onFinal (行已被合成失败落定的, 照追述规则处理)。
             uncut: (t, ids) => ids.forEach((id) => {
                 const e = events.get(id);
-                if (!e?.result) {
-                    log.warn({ target: t, event: id }, "handoff: 扣下的终句已不在事件库, 补投不了");
+                if (!e) {
+                    log.warn({ target: t, event: id }, "handoff: 扣下的事件已不在事件库, 补投不了");
                     return;
                 }
+                // 超时可能发生在旧轮尚未产出 final 时; 先释放耐久标记, 让它稍后的真终句正常落定。
+                events.restoreHandoffFinal(id);
+                if (!e.result)
+                    return;
                 log.info({ target: t, event: id, serves: e.serves }, "handoff: 交接没做成, 补投切断那一轮的终句");
                 settleFinal(e, { text: e.result.body });
+                m.recoverEventFinal(events.get(id));
             }),
             log,
-            store: loadJsonMap(cfg.wrc.mirror.handoffsFile),
+            store: handoffStore,
             archive: (e) => {
                 if (!e.brief.trim())
                     return;
@@ -1078,7 +1152,9 @@ const main = async () => {
          *  `serves` 指回那一行 (注入事件 id `route:<event>:resume`), 于是它的终句照旧落定、
          *  照旧投给 receiver —— 换会话丢掉的只是 transcript, 不是这笔账。
          *  id 按这一场交接的起点 (`at`) 区分: 同一场 reload 重放判重不重投, 换一场才配一条新的。 */
-        function injectResume(t, event, at) {
+        async function injectResume(t, event, at) {
+            if (!handoffAllowed(t))
+                return { ok: false, reason: "workflow continuation withdrawn or executor reserved" };
             const row = router.get(event);
             if (!row || row.owner !== t || row.status !== "open")
                 return { ok: false, reason: "no open row to resume" };
@@ -1086,7 +1162,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.known(base) ? `${base}:${at}` : base;
+            const id = `${base}:${at}`;
             try {
                 events.accept({
                     id, identity: JSON.stringify([t, event, "resume", at]),
@@ -1101,7 +1177,15 @@ const main = async () => {
                             envelope: envelopeFor(waiting, channel, { ...(row.asker ? { asker: row.asker } : {}) }),
                         } },
                 });
-                return { ok: true };
+                // accept 仅表示排队; 等该 id 真被消费后才让交接记录收尾。
+                for (const end = Date.now() + 600_000; Date.now() < end; await sleep(200)) {
+                    const e = await events.reconcile(id);
+                    if (e?.exposure === "consumed" || e?.execution === "complete")
+                        return { ok: true };
+                    if (e?.execution === "uncertain" || e?.execution === "canceled")
+                        return { ok: false, reason: e.reason ?? "resume delivery uncertain" };
+                }
+                return { ok: false, reason: "resume consumption not confirmed; handoff retained" };
             }
             catch (e) {
                 return { ok: false, reason: errText(e) };
@@ -1162,11 +1246,8 @@ const main = async () => {
                 return "";
             // 计划节点 / 停放放行: 那一笔在 plan 发起 / 停放那一刻就定了; 其余看本轮服务谁。
             const f = p.serves ?? servesOfTurn(p.self);
-            if (p.op === "transfer") {
-                if (f && router.get(f)?.owner === p.self)
-                    router.commit(ops.move({ event: f, owner: p.target }));
+            if (p.op === "transfer")
                 return f ?? "";
-            }
             const parent = p.op === "self" ? f : undefined;
             return openRow({
                 ...(parent ? { event: `${parent}.${(router.get(parent)?.seq ?? 0) + 1}` } : {}),
@@ -1176,6 +1257,29 @@ const main = async () => {
                 ...(p.job ? { job: p.job } : {}), ...(p.asker ? { asker: p.asker } : {}), ...(p.after?.length ? { after: p.after } : {}),
             });
         };
+        // 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) => {
+            if (!transfer)
+                return events.accept(input);
+            const row = input.serves ? router.get(input.serves) : undefined;
+            if (!row || row.owner !== input.speaker || row.status === "answered" || row.status === "handed")
+                throw new Error("transfer ownership changed before acceptance");
+            try {
+                const accepted = events.accept(input);
+                m.transferReply(events.get(input.id));
+                return accepted;
+            }
+            catch (error) {
+                const accepted = events.get(input.id);
+                if (!accepted || accepted.exposure === "none") {
+                    events.cancel((e) => e.id === input.id, "transfer acceptance failed before exposure");
+                    if (router.get(row.event)?.owner === input.target)
+                        router.commit(ops.move({ event: row.event, owner: input.speaker }));
+                }
+                throw error;
+            }
+        };
         /** 那一笔行上的接收快照 (挂起账投影用): 结论收给谁。没有行 = 不知道 (还是记 nobody)。 */
         const receiverOfEvent = (event) => (event ? router.get(event)?.receiver : undefined);
         /** 挂起账里那一行的 owner = 派活方 = 这一笔的接收方。收给群的根行 (人话 / 定时) 不进账 ——
@@ -1244,28 +1348,35 @@ 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}`);
         };
         /** 一份定论的投递 (账本已记过): 投给升级后的收方 `esc` (没有 = 行上的 receiver)。群收方只落
          *  `hand`; wizard 收方 (含 Dead Letter 退到的群默认 wizard) 进收件箱, id = `inbox`。 */
-        const postRoute = (row, out, esc, inbox) => {
+        const postRoute = (row, out, esc, inbox, retire) => {
             const event = row.event;
             const receiver = esc?.receiver ?? row.receiver;
             const via = (esc?.via ?? []).map(displayName);
             // 升级落在 chat 根 = Dead Letter: 退到那个群, 由它的默认 wizard 收下这份结论。
             const dead = receiver.kind === "chat" && !!esc;
             if (receiver.kind !== "wizard" && !dead) {
-                router.commit(ops.hand({ event, inbox: `chat:${receiver.message}:${out.rev}` }));
+                // A transferred chat reply has no upstream wizard to report failures to.
+                // 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, 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`) —— 它的终句又一次落到那一笔上,
@@ -1285,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,
@@ -1292,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,
                     } },
-            });
-            router.commit(ops.hand({ event, inbox }));
+            }, retire);
+            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;
@@ -1330,10 +1457,10 @@ const main = async () => {
                 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}`;
+            // 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);
+            postRoute(row, { status: from.status, body: e.payload.text, rev }, esc, inbox, retire);
         };
         /** 一条路由 op: 先落盘, 再投该投的 (need / error 带正文入箱; answer 按 receiver 投递)。这里
          *  只管 `re` (`mark open`) 把那一行拉回在飞 —— 账本与工单跟着 deliverRoute 走。 */
@@ -1356,6 +1483,8 @@ const main = async () => {
          *  也最多再多打回一次)。**这是「轮终 evidence → onFinal」那条主触发链的落点**: 没有它,
          *  answer 就只能靠 sweeper / 级联取消 / boot 重放合成, 谁答完都不会有回执。 */
         deliverFinal = (e, verdict) => {
+            if (handoffFinalSuppressed(e) || !ownsReplyEvent(e))
+                return;
             // 同一轮的终句会递进来两次: result() 当场递一次, 泵见 complete 未 finalized 再补判一次
             // (message-events)。被打回那一轮的重放不是补交 —— 丢掉; 否则 bounced 已记着这一笔,
             // 第二次就把被打回的原文照收成 done (打回的续问还没注入, 定论先落了)。
@@ -1364,16 +1493,16 @@ const main = async () => {
             // 自我交接切断的那一轮: 收尾那句不是欠着的那几笔的答案 —— 行留 open, 交给新会话的「继续 <event>」。
             // 扣下记在这场交接上: 交接没做成 (新会话没起来), 它就是那几笔仅有的交代, 由 uncut 补投。
             if (cuttingTurn(e.target)) {
+                handoffs.cut(e.target, e.id);
+                events.suppressHandoffFinal(e.id);
                 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 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;
@@ -1383,6 +1512,11 @@ const main = async () => {
                 rebound(row, why, e.id);
                 return;
             }
+            // Error evidence has no durable event result. Queue the chat reply before
+            // mark:error suppresses replay, so a reload between the two cannot lose it.
+            if (verdict.error && plans.some((op) => op.op === "mark" && op.status === "error")
+                && e.serves && router.get(e.serves)?.receiver.kind === "chat" && e.payload.peer?.transferred)
+                m.deliverTransferredFinal(e, verdict.text);
             plans.forEach(commitRoute);
         };
         // ── 新路由表 (T6): 失败级联 ─────────────────────────────────────────────
@@ -1434,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)
@@ -1554,57 +1691,98 @@ const main = async () => {
          *  - 撞上的 wizard 静默超过一天 (不在 `keep` 里) → 顶掉它, 名字归新的;
          *  - 其余 (还新鲜的) → 409, 附上它的死活, 调用方据此换名或先收掉它。
          *  槽位 (key 里的 `#k`) 只是内部 id: 默认取名字本身, 被占了就加序号, 与名字无关。 */
-        const claimSlot = async (base, want, fallback, keep = [], allowed = (target, name) => planStore.allowExternal(target, name) && planStore.allowExternal(target, target ? wizards.get(target)?.name : undefined)) => {
+        const namingClaims = new Set();
+        const ownsSlot = (s) => wizards.get(s.target)?.birthToken === s.token;
+        const releaseSlot = (s) => {
+            if (!ownsSlot(s))
+                return;
+            if (s.existed)
+                wizards.upsert(s.target, { spawning: undefined, spawnReused: undefined });
+            else
+                wizards.drop(s.target);
+        };
+        const finishSlot = (s) => {
+            if (ownsSlot(s))
+                wizards.upsert(s.target, { spawning: undefined, spawnReused: undefined });
+        };
+        const claimSlot = async (base, want, keep = [], allowed = (target, name) => planStore.allowExternal(target, name) && planStore.allowExternal(target, target ? wizards.get(target)?.name : undefined), internalName) => {
             const asked = normalizeTag(want);
             const denied = { ok: false, status: 409, body: { ok: false, reason: "workflow plan reserves this executor" } };
-            const candidate = asked || normalizeTag(fallback) || "wizard";
-            if (!allowed(keyOf(base, candidate), candidate))
-                return denied;
-            const clash = asked ? wizards.byName(asked) : undefined;
-            // 名字全机唯一, 撞上别的机器人的 wizard 照样拒 —— 但不顶掉它、不复用它的槽, 也不报它的死活:
-            // 那边的 wizard 在这个机器人眼里不存在, 只剩「名字被占了」这一个事实。
-            if (clash && !sameBot(base, clash.target)) {
-                return { ok: false, status: 409, body: { ok: false, reason: `名字 '.${clash.name}' 已被占用 (名字全局唯一) —— 换个名字`, name: clash.name } };
-            }
-            if (clash && !allowed(clash.target, clash.name))
-                return denied;
-            const bound = !!clash && m.chatTargets(baseOfKey(clash.target)).includes(clash.target);
-            if (clash && !bound && baseOfKey(clash.target) === base && tagOfKey(clash.target)) {
-                return { ok: true, target: clash.target, slot: tagOfKey(clash.target) };
-            }
-            if (clash && !(await displace(asked, keep))) {
-                const info = bound ? (await m.peers(clash.target)).find((p) => p.target === clash.target) : undefined;
-                const alive = info?.paneAlive ?? false;
-                const idleForMs = info?.lastActivity ? Date.now() - info.lastActivity : undefined;
-                const idleDesc = idleForMs !== undefined ? `静默 ${Math.round(idleForMs / 60000)} 分钟` : "从没动过";
-                const advice = alive
-                    ? "它的 pane 还活着 —— 除非这就是同一件事的延续, 否则换个名字重新生, 别把不相关的活塞给一个已经有职责的 wizard"
-                    : bound
-                        ? `pane 已经不在了 (${idleDesc}), 真要复用这个名字就先 stop_wizard({name:"${clash.name}", mode:"end"}) 收掉, 再用同一个名字重新生 —— 拿到干净的上下文; 别直接 send_peer 唤醒它接手, 它会带着上一件事的记忆答你这件`
-                        : "这个名字被一个一天内还活动过、眼下没有会话的 wizard 占着 —— 换个名字 (它静默满一天后名字会自动让出)";
-                return {
-                    ok: false,
-                    status: 409,
-                    body: {
-                        ok: false,
-                        reason: `名字 '.${clash.name}' 已经属于一个${alive ? "活着的" : "不再活跃的"} wizard (名字全局唯一) —— ${advice}`,
-                        name: clash.name,
-                        address: clash.name,
-                        alive,
-                        busy: info?.busy ?? false,
-                        idleForMs,
-                    },
+            const claimKey = asked.toLowerCase();
+            if (asked && namingClaims.has(claimKey))
+                return { ok: false, status: 409, body: { ok: false, reason: "wizard name is being claimed" } };
+            if (asked)
+                namingClaims.add(claimKey);
+            try {
+                const candidate = asked || (internalName ? pickName(internalName, wizards.all().map((w) => w.name)) : wizards.nextName());
+                if (!allowed(keyOf(base, candidate), candidate))
+                    return denied;
+                const reserve = (target, existed) => {
+                    // No await between uniqueness check and durable registration.
+                    const token = randomUUID();
+                    wizards.upsert(target, { name: candidate, spawning: BOOT_ID, birthToken: token, spawnReused: existed || undefined });
+                    return { ok: true, target, name: candidate, existed, token };
                 };
+                const clash = asked ? wizards.byName(asked) : undefined;
+                if (clash?.spawning)
+                    return { ok: false, status: 409, body: { ok: false, reason: "wizard is being spawned", name: clash.name } };
+                // 名字全机唯一, 撞上别的机器人的 wizard 照样拒 —— 但不顶掉它、不复用它的槽, 也不报它的死活:
+                // 那边的 wizard 在这个机器人眼里不存在, 只剩「名字被占了」这一个事实。
+                if (clash && !sameBot(base, clash.target)) {
+                    return { ok: false, status: 409, body: { ok: false, reason: `名字 '.${clash.name}' 已被占用 (名字全局唯一) —— 换个名字`, name: clash.name } };
+                }
+                if (clash && !allowed(clash.target, clash.name))
+                    return denied;
+                const bound = !!clash && m.chatTargets(baseOfKey(clash.target)).includes(clash.target);
+                if (clash && !bound && baseOfKey(clash.target) === base && tagOfKey(clash.target)) {
+                    return reserve(clash.target, true);
+                }
+                if (clash && !(await displace(asked, keep))) {
+                    const info = bound ? (await m.peers(clash.target)).find((p) => p.target === clash.target) : undefined;
+                    const alive = info?.paneAlive ?? false;
+                    const idleForMs = info?.lastActivity ? Date.now() - info.lastActivity : undefined;
+                    const idleDesc = idleForMs !== undefined ? `静默 ${Math.round(idleForMs / 60000)} 分钟` : "从没动过";
+                    const advice = alive
+                        ? "它的 pane 还活着 —— 除非这就是同一件事的延续, 否则换个名字重新生, 别把不相关的活塞给一个已经有职责的 wizard"
+                        : bound
+                            ? `pane 已经不在了 (${idleDesc}), 真要复用这个名字就先 stop_wizard({name:"${clash.name}", mode:"end"}) 收掉, 再用同一个名字重新生 —— 拿到干净的上下文; 别直接 send_peer 唤醒它接手, 它会带着上一件事的记忆答你这件`
+                            : "这个名字被一个一天内还活动过、眼下没有会话的 wizard 占着 —— 换个名字 (它静默满一天后名字会自动让出)";
+                    return {
+                        ok: false,
+                        status: 409,
+                        body: {
+                            ok: false,
+                            reason: `名字 '.${clash.name}' 已经属于一个${alive ? "活着的" : "不再活跃的"} wizard (名字全局唯一) —— ${advice}`,
+                            name: clash.name,
+                            address: clash.name,
+                            alive,
+                            busy: info?.busy ?? false,
+                            idleForMs,
+                        },
+                    };
+                }
+                if (!allowed(keyOf(base, candidate), candidate) || (clash && !allowed(clash.target, clash.name)))
+                    return denied;
+                const taken = new Set([
+                    ...m.chatTargets(base).map(tagOfKey),
+                    ...wizards.all().filter((w) => baseOfKey(w.target) === base).map((w) => tagOfKey(w.target)),
+                ].filter(Boolean));
+                const slot = uniqueTag(candidate, taken);
+                const target = keyOf(base, slot);
+                // An identity rename may have claimed the address while stale eviction awaited IO.
+                if (wizards.byName(candidate))
+                    return { ok: false, status: 409, body: { ok: false, reason: "wizard name was claimed during spawn preparation" } };
+                return allowed(target, candidate) ? reserve(target, false) : denied;
+            }
+            catch (e) {
+                if (e instanceof AutoNameExhausted)
+                    return { ok: false, status: 409, body: { ok: false, reason: e.message } };
+                throw e;
+            }
+            finally {
+                if (asked)
+                    namingClaims.delete(claimKey);
             }
-            if (!allowed(keyOf(base, candidate), candidate) || (clash && !allowed(clash.target, clash.name)))
-                return denied;
-            const taken = new Set([
-                ...m.chatTargets(base).map(tagOfKey),
-                ...wizards.all().filter((w) => baseOfKey(w.target) === base).map((w) => tagOfKey(w.target)),
-            ].filter(Boolean));
-            const slot = uniqueTag(asked || normalizeTag(fallback) || "wizard", taken);
-            const target = keyOf(base, slot);
-            return allowed(target, asked || slot) ? { ok: true, target, slot } : denied;
         };
         // ── 给人看的消息 ──────────────────────────────────────────────────
         // send_peer 把话塞进另一个 agent 的输入框 (驱动它干活); 这条把话贴进一个聊天
@@ -1657,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 没说话时微信会静默丢弃, 消息只能压着等他下次开口 —— 如实告诉调用方, 别回「已发送」。
@@ -1667,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 没说话: 微信会静默丢弃主动推送, 这条已压着, 对方下次在微信里开口时送达 (定时提醒做不到准点)` } : {}),
             });
         });
@@ -1934,6 +2148,7 @@ const main = async () => {
                 const attempt = p.attemptId ? workflow.byTurn(e.speaker, p.from.event ?? "") : undefined;
                 // 单已收但这一笔的行还 open = 收工前就派出去的活, 照投 (见 close_job)。
                 return planStore.healthy() && !e.canceled && (!p.from.receipt || planContinuationAllowed(e.target))
+                    && (!p.transferred || !e.serves || events.latestTransfer(e.serves)?.id === e.id)
                     && (!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"));
             },
@@ -1941,6 +2156,15 @@ const main = async () => {
                 if (e.execution !== "queued")
                     return;
                 const p = e.payload.peer;
+                if (p.transferred && e.serves) {
+                    const row = router.get(e.serves);
+                    if (!row || row.owner !== e.speaker && row.owner !== e.target || events.latestTransfer(e.serves)?.id !== e.id)
+                        throw new Error("transfer intent no longer owns this route");
+                    // The input is durable before move. A crash here replays this projection
+                    // in the injector, without dropping the original human route.
+                    if (row.owner !== e.target)
+                        router.commit(ops.move({ event: row.event, owner: e.target }));
+                }
                 // 旧 watcher 的 continuation 代数已退役 (§9.4): 收口由事件自己的 serves 决定。
                 if (p.attemptId)
                     accountWorkflow(workflow.byTurn(e.speaker, p.from.event ?? ""));
@@ -1999,7 +2223,7 @@ const main = async () => {
                 if (p.attemptId && p.tell)
                     workflow.intent(p.attemptId, p.tell);
                 const raw = await m.injectText(e.target, e.payload.text, undefined, {
-                    from: p.from, channel: e.channel, requireIdle: e.priority === "normal",
+                    from: p.from, channel: e.channel, requireIdle: e.priority === "normal", noRespawn: e.id.startsWith("route:") && e.id.includes(":resume:"),
                     envelope: withMsg(p.envelope + (p.after?.length ? afterNote(p.after, Object.fromEntries(p.after.flatMap((t) => { const x = seenOf(t); return x ? [[t, x]] : []; })), e.speaker) : ""), e.id),
                     guard: (phase, identity) => peerEvents.valid(e) && prereqsOf(e.speaker, p.after ?? []).every((r) => r.state === "done") && (!phase || ((!p.attemptId || workflow.boundary(p.attemptId)) && boundary(phase, identity))),
                     eventId: e.id,
@@ -2015,12 +2239,23 @@ const main = async () => {
         // 没有行 (老事件 / 不带 serves 的注入) → 照旧放行。
         // 已落定的那一笔只放追述 (§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 (e.canceled || e.interjected)
+            if (handoffFinalSuppressed(e))
+                return false;
+            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));
         });
-        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(); });
@@ -2036,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);
             });
@@ -2282,11 +2518,11 @@ const main = async () => {
                     ...(afters.length ? { after: afters } : {}), ...(plan.serves ? { serves: plan.serves } : {}) });
             /** 建完行才发现不该派 (计划许可 / 预算在等待期间变了): 把刚开的那一行收掉 —— 不然它一直
              *  挂在 owedBy 上, 名册里也永远「欠着」一件没人干的活。 */
-            const dropRow = () => { if (newRow && serves)
+            const dropRow = () => { if (newRow && serves && plan.op !== "transfer")
                 router.commit(ops.gc({ event: serves })); };
             // 注入事件的 id 就是对那一笔的引用 (§9.3): 派活 = `route:<event>`, 续问 = `route:<event>:r<legs>`;
             // 不开行 (none) 时没有行可指, 退回一句一号的合成 id。
-            const eventId = serves ? `route:${serves}${legs > 1 ? `:r${legs}` : ""}` : `p:${self}:${target}:${at}:${legs}`;
+            const eventId = serves ? plan.op === "transfer" ? `route:${serves}:transfer:${at}:${target}` : `route:${serves}${legs > 1 ? `:r${legs}` : ""}` : `p:${self}:${target}:${at}:${legs}`;
             let attemptId;
             const beginNode = (queued) => {
                 if (!planAllowed() || (planned && !planned.alive()))
@@ -2306,7 +2542,8 @@ const main = async () => {
             // urgent 只打断你自己派的那一轮 (或它自己的回执轮): 手上若是别的 wizard / 人 / 定时任务的活,
             // 打断就误伤了那件 —— 降成 normal, 等它这一轮做完再投。
             const others = asked === "urgent" && wasBusy ? await othersTurn(target, self) : undefined;
-            const policy = others ? "normal" : asked;
+            // Transfers need a separate input turn, including when the receiver becomes busy.
+            const policy = others || plan.op === "transfer" ? "normal" : asked;
             if (canceledBeforeDispatch() || !actorStillValid()) {
                 dropRow();
                 return { status: 409, body: { ok: false, reason: "caller authority or dispatch permit changed before acceptance" } };
@@ -2325,7 +2562,7 @@ const main = async () => {
             }
             let accepted;
             try {
-                accepted = events.accept({ id: eventId, target, speaker: self, channel, serves, asker, priority: policy, deadline: deadlineAt,
+                accepted = acceptPeerDispatch({ id: eventId, target, speaker: self, channel, serves, asker, priority: policy, deadline: deadlineAt,
                     payload: { text, peer: {
                             from: { kind: "peer", from: self, event: serves, ...(jobId ? { job: jobId } : {}), ...(isPublic ? { public: true } : {}), ...(handedChat ? { transferred: true } : {}), ...(asker ? { asker } : {}) },
                             envelope: envelopeFor(self, channel, { asker, legs, ...(legs > 1 ? { re: true } : {}),
@@ -2333,14 +2570,12 @@ const main = async () => {
                             ...(wantReceipt ? { tell } : {}), job: jobId, kind, attemptId, after: afters,
                             role: roleParam(body.role), free: freed,
                             ...(plan.op === "transfer" ? { transferred: true } : {}),
-                        } } });
+                        } } }, plan.op === "transfer");
             }
             catch (error) {
+                dropRow();
                 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"))
@@ -2490,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 }));
                 }
@@ -2530,30 +2772,19 @@ const main = async () => {
                 ? { ok: true, ...results[0] }
                 : { ok: true, need, done, satisfied: done >= need, results });
         });
-        // 交接的「重开」一步: 走 /new (杀旧 pane、起新进程) 而不是往原 pane 注入 /clear。
-        // /clear 只换会话不换进程 —— MCP 子进程、charter 都还是旧的, 新工具拿不到; 镜像
-        // 还得靠 sid 轮换探测才跟得上。CLI 使用 cfg 的默认 backend; cwd 照旧沿用
-        // (排着队的 pendingCwd —— set_workspace 先落的那笔 —— 在这一步被消费, 重开落进新目录)。
-        // 同 backend 时模型也沿用, 管家除外 ——
-        // 它换上此刻的 router 档 (newSession 里定), 改了 models.router 后交接一次就是让它生效的那一下。
-        // `announce` (换工作区) 时那条「📂 当前项目」气泡照发 —— 那是人看得见的回执; 普通交接静默。
-        const restartFresh = (target, p) => {
-            const info = m.sessionInfo(target);
-            const cli = cfg.wrc.defaultCli ?? primary.name;
-            const model = stewardTierOf(cfg, target) || info?.cli !== cli ? undefined : info?.model || undefined;
-            if (!planContinuationAllowed(target))
-                return Promise.resolve({ ok: false, reason: "workflow continuation withdrawn" });
-            return m.newSession(target, displayName(target) || tagOfKey(target) || target, cli, { model, silent: !p?.announce, guard: () => planContinuationAllowed(target) });
+        // handoff 只清空原 pane 的原生上下文; 不更新 CLI 进程、工作目录或出生时的宪章。
+        const clearForHandoff = (target, p, submitted) => {
+            if (!handoffAllowed(target))
+                return Promise.resolve({ ok: false, reason: "workflow continuation withdrawn or executor reserved" });
+            if (!p.clear && m.sessionInfo(target)?.sessionId !== p.sid)
+                return Promise.resolve({ ok: false, reason: "native session changed before the clear attempt; refusing another clear" });
+            return m.clearContext(target, p.clear, submitted, () => handoffAllowed(target));
         };
-        // POST /handoff — 交接一个 pane 的会话给一个全新会话。先让目标会话把当前工作
-        // 压成一份"零上下文也能接手"的交接简报,等它写完并抓取,再 restartFresh 换一个
-        // 全新的进程(同名、同 cwd),把简报作为新会话的首条消息贴进去。拒绝对调用方
-        // 自身操作(会 deadlock,同 /peers/send)。
         /** 交接自己: 简报由调用方给, 排在它这一轮说完之后 (见 handoff.ts)。/handoff 点名点到
          *  自己与老路由 /wizard/handoff-self 共用。 */
         const handoffSelf = (self, brief) => {
-            if (!planContinuationAllowed(self))
-                return { status: 409, body: { ok: false, reason: "workflow continuation withdrawn" } };
+            if (!handoffAllowed(self))
+                return { status: 409, body: { ok: false, reason: "workflow continuation withdrawn or executor reserved" } };
             if (brief.length < 40)
                 return { status: 400, body: { ok: false, reason: "brief 太短 —— 要写到零上下文也能接手: 目标 / 已完成 / 当前状态 / 下一步 / 关键文件与坑" } };
             const info = m.sessionInfo(self);
@@ -3431,7 +3662,7 @@ const main = async () => {
             }
             const name = (b.name ?? "").toString().trim();
             const description = (b.description ?? "").toString().trim() || clipLine(task, 120);
-            // 空 name 交给 bearAs / claimSlot 按职责自动取名避重, 不当作显式点名复用旧记录。
+            // 空 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) {
@@ -3555,7 +3786,7 @@ const main = async () => {
                         return { status: jc.status, body: { ok: false, reason: jc.reason } };
                     }
                 }
-                const planBirthAllowed = (target, name = normalizeTag(b.name ?? b.tag) || (b.detached && b.cwd ? tagFromCwd(b.cwd) : "") || normalizeTag(b.description?.split(/\s+/)[0]) || "clone") => planStore.allowSpawn(self, jobId, planned, name, target) && (!planned || planned.alive());
+                const planBirthAllowed = (target, name = normalizeTag(b.name ?? b.tag)) => planStore.allowSpawn(self, jobId, planned, name, target) && (!planned || planned.alive());
                 if (!planBirthAllowed() || (planned && !!b.task))
                     return { status: 409, body: { ok: false, reason: "dedicated plan job only permits taskless runner spawn" } };
                 // 带 task 派下去 = 派活: 同样过方向闸, 不论带不带 job (新生的目标还不在任何单里, 实际只有 1 / 链深两条会拦)。
@@ -3639,20 +3870,20 @@ const main = async () => {
                         } };
                 }
                 const askedName = String(b.name ?? b.tag ?? "");
-                // 没起名: 独立长住的按目录名 (同 /new 与 new_claude_session), 分身按职责的首词。
-                const fallback = (detached && b.cwd ? tagFromCwd(b.cwd) : "") || normalizeTag(b.description?.split(/\s+/)[0]) || "clone";
-                const slotR = await claimSlot(base, askedName, fallback, [self, source], (target, name) => planBirthAllowed(target, name) && (!target || planBirthAllowed(target, wizards.get(target)?.name ?? name)));
+                const slotR = await claimSlot(base, askedName, [self, source], (target, name) => planBirthAllowed(target, name) && (!target || planBirthAllowed(target, wizards.get(target)?.name ?? name)));
                 if (!slotR.ok) {
                     return { status: slotR.status, body: slotR.body };
                 }
-                const { target, slot: tag } = slotR;
+                const { target, name } = slotR;
+                const releaseBirth = () => releaseSlot(slotR);
                 // claimSlot 会复用同名的冷记录 (detached 正是「叫回一个老名字」的场景): 生不出来时
                 // 只回滚这一次的新记录, 不能把那个老 wizard 的记忆和家谱一起删掉。
-                const existed = !!wizards.get(target);
                 const forkOf = inherit && source !== self ? source : undefined;
                 // 先落身份再 spawn: 宪章是从注册表渲染出来的, 记录不在就渲染出一个无名分身。
-                if (!planBirthAllowed(target, normalizeTag(askedName) || tag) || (jobId && jobs.get(jobId)?.status !== "open"))
+                if (!ownsSlot(slotR) || !planBirthAllowed(target, name) || (jobId && jobs.get(jobId)?.status !== "open")) {
+                    releaseBirth();
                     return { status: 409, body: { ok: false, reason: "plan canceled/job reserved during spawn preparation" } };
+                }
                 wizards.upsert(target, {
                     description: (b.description ?? "").toString().trim(),
                     // 显式写 undefined: upsert 是合并写, 复用的冷记录里旧的 parent 会留下来。
@@ -3669,15 +3900,16 @@ const main = async () => {
                     // 生完才清; 这个进程中途没了, 下次开机由 sweepUnborn 认出并收掉。
                     spawning: BOOT_ID,
                 });
-                const name = wizards.rename(target, normalizeTag(askedName) || tag);
                 const charter = charterFor(target, { ...(detached ? {} : { parent: self }), forkOf, inherited: inherit, cli: pick.cli });
                 const task = (b.task ?? "").toString().trim();
                 // 先盖章再生: 分叉出来的 transcript 里躺着被克隆者的旧回复, 时刻早于这一枚章,
                 // wait_peer 才不会把它们当成分身对这件活的答复。
                 const taskAt = Date.now();
-                const birthGuard = () => (!authority || controlValid(self, authority)) && planBirthAllowed(target, wizards.get(target)?.name ?? name) && (!jobId || jobs.get(jobId)?.status === "open");
-                if (!birthGuard())
+                const birthGuard = () => ownsSlot(slotR) && (!authority || controlValid(self, authority)) && planBirthAllowed(target, wizards.get(target)?.name ?? name) && (!jobId || jobs.get(jobId)?.status === "open");
+                if (!birthGuard()) {
+                    releaseBirth();
                     return { status: 409, body: { ok: false, reason: "executor reservation changed before spawn" } };
+                }
                 const r = await m.cloneSession({
                     guard: birthGuard,
                     parent: source,
@@ -3693,13 +3925,13 @@ const main = async () => {
                 }).catch((e) => ({ ok: false, reason: `spawn threw: ${String(e)}`, inherited: false }));
                 // 生不出来就回滚身份 —— 否则名字被一个永远没有会话的记录占住。
                 if (!r.ok) {
-                    if (existed)
-                        wizards.upsert(target, { spawning: undefined });
-                    else
-                        wizards.drop(target);
+                    releaseBirth();
                     return { status: 500, body: { ok: false, reason: r.reason } };
                 }
-                wizards.upsert(target, { spawning: undefined, clonedFrom: r.inherited ? sourceInfo?.sessionId ?? "" : "", ...(r.inherited ? {} : { forkOf: undefined }) });
+                if (!ownsSlot(slotR))
+                    return { status: 409, body: { ok: false, reason: "birth identity replaced during spawn" } };
+                finishSlot(slotR);
+                wizards.upsert(target, { clonedFrom: r.inherited ? sourceInfo?.sessionId ?? "" : "", ...(r.inherited ? {} : { forkOf: undefined }) });
                 const kid = briefOf(self, target);
                 // 出生不再发群气泡 (人要看的是结论, 不是谁生了谁 —— 过程在 rolepage 里);
                 // 同群的 wizard 仍要知道群里多了一个成员。工单里的临时工连这条也省掉。
@@ -3726,18 +3958,21 @@ const main = async () => {
                         ? 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 eventId = serves ? plan?.ok && plan.op === "transfer" ? `route:${serves}:transfer:${taskAt}:${target}` : `route:${serves}` : `p:${self}:${target}:${taskAt}:1`;
                     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 } : {}), ...(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);
+                    try {
+                        acceptPeerDispatch({ 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 } : {}), ...(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 } : {}),
+                                } } }, !!plan?.ok && plan.op === "transfer");
+                    }
+                    catch (error) {
+                        return { status: 409, body: { ok: false, target, name, dispatched: false, reason: errText(error) } };
+                    }
                 }
                 else if (jobId && birthGuard()) {
                     jobs.attach(jobId, { target, task: "", spawned: true, ...(roleParam(body.role) ? { role: roleParam(body.role) } : {}) });
@@ -3912,6 +4147,10 @@ const main = async () => {
                 json(res, 502, { ok: false, target, reason: done.reason });
                 return;
             }
+            if (wizards.get(target)?.birthToken !== victimRec?.birthToken) {
+                json(res, 409, { ok: false, target, reason: "wizard identity changed during stop; identity cleanup withheld" });
+                return;
+            }
             const detached = end && b.forget ? forgetWizard(target) : [];
             // 打断只是停了它这一轮, 它还在; 只有结束才是名册变了。
             if (end)
@@ -4340,7 +4579,7 @@ const main = async () => {
         ];
         // ── 改配置会不会动到宪章 ─────────────────────────────────────────
         // 宪章是 --append-system-prompt 压进去的, 随进程终身: 改了进宪章的配置, 已在跑的 wizard
-        // 看不见, 要 handoff 重开 (重新渲染宪章) 才换上。不按字段清单判 —— 宪章读哪些配置随代码变,
+        // 看不见, 需要显式 /new 才重新渲染宪章; handoff /clear 保留启动时的系统提示。不按字段清单判 —— 宪章读哪些配置随代码变,
         // 清单迟早漏; 改前改后各渲染一遍有会话的 wizard 的宪章, 变了的就是受影响的。
         const charterSections = (text) => new Map(text.split(/^(?=## )/m).map((sec) => [sec.split("\n", 1)[0].replace(/^## /, ""), sec]));
         // 「出生时同群的 wizard」是出生快照 (宪章自己声明名册随时可查), 且渲染途中的懒定居
@@ -4377,49 +4616,22 @@ const main = async () => {
             }
         };
         const charterImpact = (before, after) => [...before].flatMap(([t, a]) => { const secs = changedSections(a, after.get(t) ?? a); return secs.length ? [{ target: t, sections: secs }] : []; });
-        /** 宪章改动自动交接的时限 (写简报 + 重开), 与 /handoff 路由同档。 */
-        const CHARTER_HANDOFF_MS = 600_000;
-        /** 受影响的 wizard 的处理分两档:
-         *  - hot: 自动交接 —— 守护进程请它写简报、原地重开 (宪章在重开时重渲染)、简报贴回;
-         *    交接不成 (一直忙 / 已在交接中 / 重开失败) 才退回老规矩, 挂一条提醒让它自己 handoff。
-         *  - reload: 此刻重开渲染的还是旧宪章, 自动交接无意义 —— 维持挂提醒, reload 之后它自己交。
-         * 给调用方的那段话照旧回; 调用方自己受影响就直说。人发起的改动多一句「交接之前还是旧规矩」:
-         * 自动交接也要等它这一轮说完才动手, 这句话仍成立。 */
+        /** /clear 不重新渲染进程启动时的宪章; 只通知, 不暗中重启会话。 */
         const announceCharterImpact = (c, hits) => {
             if (!hits.length)
                 return "";
-            const ask = `${c.reload ? "等守护进程 reload 之后再" : ""}调 \`handoff({brief})\` 原地重开 (手上这件告一段落就交; 宪章在 handoff 时重新生成)`;
-            const lag = (t) => !c.byHuman ? "" : tagOfKey(t)
-                ? " —— 这是人发起的改动: 交接之前你仍按旧规矩做事, handoff 之后才按新的"
-                : " —— 这是人发起的改动: 交接之前你仍按旧规矩向人汇报, handoff 之后才会按新规矩汇报; 回人时说一句「交接后生效」";
-            const mine = hits.find((h) => h.target === c.self);
-            // 提醒照旧全机发 (各收各的); 回给调用方的名单与人数只含它看得见的 (sameBot) —— 别的机器人的 wizard
-            // 连名字带个数都不报。没有调用方 (人 /name、自动补名) = 主机器人视角, 单机器人时就是全部。
+            const ask = `${c.reload ? "守护进程 reload 之后, " : ""}需要显式 /new 才能载入新宪章；handoff /clear 保留原进程的系统提示，不会使这次改动生效`;
+            hits.filter((h) => h.target !== c.self).forEach((h) => notices.post([h.target], `${c.what} 改动了你的宪章 (系统提示, 变了的段: ${h.sections.join(" / ")}); ${ask}`));
             const shown = hits.filter((h) => sameBot(c.self ?? "", h.target));
-            const shownOthers = shown.filter((h) => h.target !== c.self);
-            if (!c.reload) {
-                hits.forEach((h) => void handoffs.other(h.target, `${c.what} 改动了你的宪章 (变了的段: ${h.sections.join(" / ")}); 简报里点一句手头活在新规矩下怎么接着干`, CHARTER_HANDOFF_MS).then((r) => {
-                    if (!r.ok)
-                        notices.post([h.target], `${c.what} 改动了你的宪章 (系统提示, 变了的段: ${h.sections.join(" / ")}); 自动交接没做成 (${r.reason}) —— 已在跑的你看不见新规矩, 手上这件告一段落后自己${ask}${lag(h.target)}`);
-                }));
-                return [
-                    "",
-                    `⚠ 这次改动进了宪章 (系统提示): 已在跑的 wizard 看不见, 要 handoff 才换上。受影响 ${shown.length} 个: ${shown.map((h) => displayName(h.target)).join(" ")}`,
-                    ...(shown.length ? ["已自动安排它们交接 (各自写简报 → 原地重开 → 接回简报); 交接不成的会收到提醒, 再自己 handoff"] : []),
-                    ...(mine ? [`**你自己也在其中** (变了的段: ${mine.sections.join(" / ")}): 这一轮说完就会自动交接${lag(mine.target)}`] : []),
-                ].join("\n");
-            }
-            const others = hits.filter((h) => h.target !== c.self);
-            others.forEach((h) => notices.post([h.target], `${c.what} 改动了你的宪章 (系统提示, 变了的段: ${h.sections.join(" / ")}); 已在跑的你看不见新规矩 —— ${ask}${lag(h.target)}`));
+            const mine = hits.find((h) => h.target === c.self);
             return [
                 "",
-                `⚠ 这次改动进了宪章 (系统提示): 已在跑的 wizard 看不见, 要 handoff 才换上。受影响 ${shown.length} 个: ${shown.map((h) => displayName(h.target)).join(" ")}`,
-                ...(shownOthers.length ? [`已给其余 ${shownOthers.length} 个各挂一条提醒 (随它们下一条消息到), 让它们${ask}`] : []),
-                ...(mine ? [`**你自己也在其中** (变了的段: ${mine.sections.join(" / ")}): 这一轮收尾后${ask}${lag(mine.target)}`] : []),
+                `⚠ 这次改动进了宪章 (系统提示)。${ask}。受影响 ${shown.length} 个: ${shown.map((h) => displayName(h.target)).join(" ")}`,
+                ...(mine ? [`**你自己也在其中** (变了的段: ${mine.sections.join(" / ")})`] : []),
             ].join("\n");
         };
         // 所有会动宪章的写入 (config_set、人 `/name`、name_chat、自动补名) 共用这一个守卫: 写前写后各渲染一遍
-        // 挂在 pane 上的 wizard 的宪章, 变了的、pane 还活着的自动交接 (hot) 或挂提醒 (reload, 见 announceCharterImpact)。
+        // 挂在 pane 上的 wizard 的宪章, 变了的、pane 还活着的挂提醒 (见 announceCharterImpact)。
         // 快照到写完之间不能有 await —— 别人的写入插进来, 前后就对不上了。已经写了: 比对失败只少一句提醒, 不能让调用方以为没写而重发。
         guardCharter = (write, change) => {
             const targets = attachedWizards();
@@ -4430,7 +4642,7 @@ const main = async () => {
                 return { r, note: Promise.resolve("") };
             const fail = (e) => {
                 log.warn({ err: errText(e), what: c.what }, "宪章影响比对失败");
-                return `\n(宪章影响没比对出来: ${errText(e)} —— 改的若是进宪章的内容, 受影响的 wizard 要 handoff 才换上)`;
+                return `\n(宪章影响没比对出来: ${errText(e)} —— 改的若是进宪章的内容, 受影响的 wizard 需要显式 /new 才载入；handoff /clear 不刷新系统提示)`;
             };
             try {
                 const hits = charterImpact(before, (c.after ?? charterSnapshot)(targets));
@@ -4738,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);
@@ -4762,15 +4974,20 @@ const main = async () => {
             const rec = tasks.get(taskId);
             const owner = rec ? ownerOf(rec) : target;
             const ownerName = settleName(wizards, chatNameOf(cfg, owner), owner) || "task";
-            const slotR = await claimSlot(base, "", `${ownerName}-task-${taskId.slice(0, 4)}`);
-            if (!guard())
+            const slotR = await claimSlot(base, "", [], undefined, `${ownerName}-task-${taskId.slice(0, 4)}`);
+            if (!guard()) {
+                if (slotR.ok)
+                    releaseSlot(slotR);
                 return { ok: false, reason: "scheduled runner withdrawn during slot selection" };
+            }
             if (!slotR.ok)
                 return { ok: false, reason: "起白板 wizard 失败: 挑不出槽位" };
             const runner = slotR.target;
-            const allowed = () => guard() && planStore.allowExternal(runner, wizards.get(runner)?.name);
-            if (!allowed())
+            const allowed = () => ownsSlot(slotR) && guard() && planStore.allowExternal(runner, wizards.get(runner)?.name);
+            if (!allowed()) {
+                releaseSlot(slotR);
                 return { ok: false, reason: "workflow plan reserves task runner" };
+            }
             const info = m.sessionInfo(target);
             const why = busy ? ` (起因: ${displayName(target)} 当时正忙)` : "";
             wizards.upsert(runner, {
@@ -4779,16 +4996,20 @@ const main = async () => {
                 voiceOf: owner,
                 bornAt: Date.now(),
             });
-            const runnerName = wizards.rename(runner, `${ownerName}-task-${taskId.slice(0, 4)}`);
-            const spawned = await m.newSession(runner, runnerName, info?.cli, { cwd: info?.cwd, model: info?.model, silent: true, guard: allowed });
+            const runnerName = slotR.name;
+            const spawned = await m.newSession(runner, runnerName, info?.cli, { cwd: info?.cwd, model: info?.model, silent: true, guard: allowed })
+                .catch((e) => ({ ok: false, reason: `spawn threw: ${String(e)}` }));
             if (!spawned.ok) {
-                wizards.drop(runner);
+                releaseSlot(slotR);
                 return { ok: false, reason: `起白板 wizard 失败: ${spawned.reason ?? "unknown"}` };
             }
+            if (!ownsSlot(slotR))
+                return { ok: false, reason: "task runner identity replaced during spawn" };
+            finishSlot(slotR);
             if (!allowed()) {
-                if (m.sessionInfo(runner)?.sessionId === spawned.sessionId) {
+                if (ownsSlot(slotR) && m.sessionInfo(runner)?.sessionId === spawned.sessionId) {
                     await m.killPane(runner);
-                    wizards.drop(runner);
+                    releaseSlot(slotR);
                 }
                 return { ok: false, reason: "scheduled runner withdrawn after spawn" };
             }
@@ -4806,7 +5027,7 @@ const main = async () => {
                 ? { guard: allowed, from: { kind: "task", taskId }, channel: "", envelope: renderTaskEnvelope(taskId, { event: turn }) }
                 : { guard: allowed, fromChat: true, from: { kind: "task", taskId }, envelope: renderTaskEnvelope(taskId) });
             if (!inj.ok) {
-                wizards.drop(runner);
+                releaseSlot(slotR);
                 return inj;
             }
             // 没有人会对这个一次性分身喊 stop_wizard, 只能自己等它闲下来再收。30min
@@ -4821,8 +5042,10 @@ const main = async () => {
                     log.warn({ runner, reason: idle.reason }, "task runner: 30min 未闲下来, 放弃自动回收");
                     return;
                 }
+                if (!ownsSlot(slotR) || m.sessionInfo(runner)?.sessionId !== spawned.sessionId)
+                    return;
                 await m.killPane(runner);
-                wizards.drop(runner);
+                releaseSlot(slotR);
             })();
             return inj;
         };
@@ -4894,6 +5117,7 @@ const main = async () => {
         registry: tasks,
         log: log.child({ mod: "tasks" }),
         inject: scheduledTaskInject,
+        ready: bridge.restored,
         // gate 里的 `sh` 默认就在目标 wizard 此刻的工作区跑 —— 任务文件里不必写死绝对路径。
         cwdOf: (t) => { const c = bridge.getCwd(t); return c.runningCwd || c.pendingCwd || c.defaultCwd; },
         // 没写 target 的日程兜底到排班者那个机器人的默认聊天 (副机器人没配就不放枪, 不冒用主机器人)。