wezard 2.7.2 → 2.7.4

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";
@@ -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,15 +205,19 @@ const main = async () => {
     let peerEvents;
     /** T4: 路由表的投递层 —— 在 mirror 大块里接线 (要用到 jobs / 回执信封 / 事件泵), 这里先留个口。 */
     let deliverFinal;
+    let handoffAllowed = () => false;
+    let handoffFinalSuppressed = (e) => !!e.handoffCut && !e.handoffRestored;
     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)
             peerEvents?.committed(e); },
+        gone: (e) => { if (e.payload.peer)
+            peerEvents?.gone?.(e); },
         canceled: (e) => {
             if (e.payload.peer)
                 peerEvents?.canceled(e);
@@ -228,8 +233,18 @@ const main = async () => {
         // (贴进运行中的一轮记成 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)) {
@@ -273,7 +288,8 @@ const main = async () => {
             }
             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),
@@ -287,7 +303,7 @@ 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 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);
             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" };
@@ -684,24 +700,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
@@ -744,16 +761,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();
@@ -783,12 +791,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,
@@ -975,10 +979,11 @@ 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.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
@@ -1030,29 +1035,90 @@ 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),
             // 交接是生命周期事件, 不进群; 失败只捎给它自己 (它调完 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) {
+                    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;
@@ -1066,7 +1132,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" };
@@ -1074,7 +1142,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 = `${base}:${at}`;
             try {
                 events.accept({
                     id, identity: JSON.stringify([t, event, "resume", at]),
@@ -1089,7 +1157,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) };
@@ -1150,11 +1226,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}` } : {}),
@@ -1164,6 +1237,36 @@ const main = async () => {
                 ...(p.job ? { job: p.job } : {}), ...(p.asker ? { asker: p.asker } : {}), ...(p.after?.length ? { after: p.after } : {}),
             });
         };
+        const ownsReplyEvent = (e) => {
+            const row = e.serves ? router.get(e.serves) : undefined;
+            if (row && row.owner !== e.target)
+                return false;
+            const latest = e.serves ? events.latestTransfer(e.serves) : undefined;
+            return !latest || latest.id === e.id || latest.at < e.at;
+        };
+        // Acceptance projects ownership only after the input is durable. A rejected
+        // acceptance retains the human's route and bubble for the original owner.
+        const acceptPeerDispatch = (input, transfer = false) => {
+            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 = 派活方 = 这一笔的接收方。收给群的根行 (人话 / 定时) 不进账 ——
@@ -1242,12 +1345,22 @@ 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, 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) {
+                // 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);
                 router.commit(ops.hand({ event, inbox: `chat:${receiver.message}:${out.rev}` }));
                 return;
             }
@@ -1266,7 +1379,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({
@@ -1288,9 +1400,37 @@ const main = async () => {
                             ...(retellTo ? { retellTo } : {}),
                             ...(row.late ? { retold: true } : {}) }),
                     } },
-            });
+            }, retire);
             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];
+            // Replaying a torn reroute must target the same durable inbox entry.
+            const inbox = `${e.id}~${finalId(e.id, JSON.stringify(esc?.receiver ?? row.receiver), rev)}`;
+            log.info({ id: e.id, target: e.target, event, to: esc?.receiver ?? row.receiver, inbox }, "receipt reroute: 收方已不在, 改投");
+            postRoute(row, { status: from.status, body: e.payload.text, rev }, esc, inbox, e.id);
+        };
         /** 一条路由 op: 先落盘, 再投该投的 (need / error 带正文入箱; answer 按 receiver 投递)。这里
          *  只管 `re` (`mark open`) 把那一行拉回在飞 —— 账本与工单跟着 deliverRoute 走。 */
         const commitRoute = (op) => {
@@ -1312,16 +1452,25 @@ const main = async () => {
          *  也最多再多打回一次)。**这是「轮终 evidence → onFinal」那条主触发链的落点**: 没有它,
          *  answer 就只能靠 sweeper / 级联取消 / boot 重放合成, 谁答完都不会有回执。 */
         deliverFinal = (e, verdict) => {
+            if (handoffFinalSuppressed(e) || !ownsReplyEvent(e))
+                return;
             // 同一轮的终句会递进来两次: result() 当场递一次, 泵见 complete 未 finalized 再补判一次
             // (message-events)。被打回那一轮的重放不是补交 —— 丢掉; 否则 bounced 已记着这一笔,
             // 第二次就把被打回的原文照收成 done (打回的续问还没注入, 定论先落了)。
             if (e.serves && bounced.get(e.serves) === e.id)
                 return;
             // 自我交接切断的那一轮: 收尾那句不是欠着的那几笔的答案 —— 行留 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: 交接切断的那一轮终句不落定");
                 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;
@@ -1332,6 +1481,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): 失败级联 ─────────────────────────────────────────────
@@ -1503,57 +1657,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 的输入框 (驱动它干活); 这条把话贴进一个聊天
@@ -1883,6 +2078,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"));
             },
@@ -1890,6 +2086,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 ?? ""));
@@ -1922,6 +2127,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) => {
@@ -1939,7 +2153,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,
@@ -1955,8 +2169,11 @@ const main = async () => {
         // 没有行 (老事件 / 不带 serves 的注入) → 照旧放行。
         // 已落定的那一笔只放追述 (§4.3): 判据与 onFinal 的 retellOps 同源 (router.finalReleased)。
         // 调用方可能拿着 result 落定前的快照, 正文按事件库现读。
+        m.setEventOwnerGate(ownsReplyEvent);
         m.setEventFinalGate((e) => {
-            if (e.canceled || e.interjected)
+            if (handoffFinalSuppressed(e))
+                return false;
+            if (e.canceled || e.interjected || !ownsReplyEvent(e))
                 return false;
             return router.finalReleased(e.target, e.serves, (events.get(e.id) ?? e).result?.body ?? "");
         });
@@ -2221,11 +2438,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()))
@@ -2245,7 +2462,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" } };
@@ -2264,7 +2482,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 } : {}),
@@ -2272,9 +2490,10 @@ 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) } };
             }
             // `re` 把那一笔从 need / error 拉回 open (§3.2 的 need→open / error→open): 行状态是「这份中途态
@@ -2428,7 +2647,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 } : {}),
@@ -2466,30 +2685,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);
@@ -3366,12 +3574,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) {
@@ -3495,7 +3699,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 / 链深两条会拦)。
@@ -3579,20 +3783,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 会留下来。
@@ -3609,15 +3813,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,
@@ -3633,13 +3838,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 仍要知道群里多了一个成员。工单里的临时工连这条也省掉。
@@ -3666,16 +3871,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 } : {}),
-                            } } });
+                    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) } : {}) });
@@ -3850,6 +4060,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)
@@ -4278,7 +4492,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」是出生快照 (宪章自己声明名册随时可查), 且渲染途中的懒定居
@@ -4315,49 +4529,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();
@@ -4368,7 +4555,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));
@@ -4700,15 +4887,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, {
@@ -4717,16 +4909,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" };
             }
@@ -4744,7 +4940,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
@@ -4759,8 +4955,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;
         };
@@ -4832,6 +5030,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 的日程兜底到排班者那个机器人的默认聊天 (副机器人没配就不放枪, 不冒用主机器人)。
@@ -4871,9 +5070,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();
@@ -4888,6 +5092,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) => {