wezard 2.4.1 → 2.5.1

package/dist/daemon/index.js

@@ -12,6 +12,11 @@ import { patchJsonc } from "../shared/config-writer.js";
 import { EFFORTS, parseEffort } from "../shared/effort.js";
 import { bindCliBackends, projectDirsFor } from "../shared/cli-backends.js";
 import { startWs } from "./ws.js";
+import { startWeixin } from "./weixin.js";
+import { installWeixinPort } from "./weixin-port.js";
+import { bindWxCommands, makeOnBound, makeWxCommands, routeSendMedia, wecomBindSink, weixinSendMedia, wxAdmins, wxRoutes } from "./weixin-cmd.js";
+import { bindChatReach } from "./reach.js";
+import { aibotSendMedia } from "./aibot-media.js";
 import { startNetWatch } from "./net-watch.js";
 import { startHttp, json, readBody } from "./http.js";
 import { parsePath } from "../shared/config-meta.js";
@@ -36,14 +41,15 @@ import { startScheduler, migrateLegacySchedules, promptWantsFreshWizard, renderT
 import { openTaskRegistry } from "./task-registry.js";
 import { describeTrigger, nextFire, parseTrigger, WHEN_HELP } from "../shared/trigger.js";
 import { isQuiet, slugify, uniqueId } from "../shared/task-file.js";
-import { baseOfKey, bindTagLinker, isInternalKey, keyOf, linkTags, normalizeTag, tagFromCwd, tagHead, tagLink, tagOfKey, uniqueTag, withTagHeader } from "../shared/session-label.js";
+import { baseOfKey, bindTagLinker, headed, ownHead, isInternalKey, keyOf, linkTags, normalizeTag, speakerHead, tagFromCwd, 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 } from "./chat-name.js";
+import { applyChatNames, chatBaseOf, chatNameOf, chatPolicyOf, clearChatName, listChatNames, normChatName, peerAddress, planChatNames, setChatName, stewardTierOf } from "./chat-name.js";
 import { createTopOnlyNudge, gcNudge, policyKeyOf, renderNudge } from "./top-only-nudge.js";
 import { bindWizardStore, loadWizardStore, wizardStore, settleName, settleAll, backfillBorn, sweepUnborn, BOOT_ID, evictStaleName, childrenOf, ancestorsOf, renderCharter, renderLead, renderLeadPlaybook, ROSTER_FRESH_MS, renderRoster, handoffAt, memoryNudgeAt, MEMORY_NUDGE_FLOOR, MEMORY_MAX, NOTE_MAX, } from "./wizard.js";
 import { 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";
 import { loadJobStore, dutyLine, awaitingAccept, stalledRoots, shelvedRoots, nudgeDue, dayClamp, childrenOf as jobChildren, jobEpisode, rejectReason, ACCEPTS, JOB_MEMBER_MAX, JOB_DEPTH_MAX, depthOf, ancestorsOf as jobAncestors, treeOrder, jobStage } from "./jobs.js";
 import { cacheTouchMs, cacheTtlSec, clipMiddle, contextFiles, firstStamp, parseClosing, lastContextTokens, lastExchange, lastModel, openingTurn, replyClosedBefore, talkTurns, renderPeerEnvelope, renderReceiptEnvelope, renderTaskEnvelope } from "./peers.js";
 import { keepalivePingSigs } from "../shared/keepalive.js";
@@ -54,7 +60,7 @@ import { renderInFlight } from "../shared/turn-state.js";
 import { startIdleNudge } from "./idle-nudge.js";
 import { renderReminder } from "../shared/reminder.js";
 import { createHandoffs, handedOff, handingOff } from "./handoff.js";
-import { coldGateOf, decide, rankCandidates, renderCandidates, tierFor, wakeNoteOf } from "./route.js";
+import { coldGateOf, decide, rankCandidates, renderCandidates, tierFor, wakeCostOf, wakeNoteOf } from "./route.js";
 import { parseWhen, renderChatLog, UNKNOWN_HUMAN } from "./chat-log.js";
 import { audienceOf } from "../shared/role-view.js";
 import { startGraph, stopRun, getRun, listRuns, validateSpec, waitForIdle, waitForQuorum, } from "./graph.js";
@@ -101,11 +107,44 @@ const main = async () => {
     // 切网 (换 WiFi / VPN 起停) 后原地重建 WS, 等价于自动做了一次 reload 的
     // 联通性部分 — 但保留全部内存态 (graph 运行、pending 长轮询、镜像绑定),
     // 也不依赖 launchd/systemd 的 respawn 策略 (nohup fallback 没有 supervisor)。
-    const netWatch = startNetWatch(log.child({ mod: "net" }), (from, to) => ws.reconnect(`network changed: ${from || "<offline>"} → ${to}`));
+    const netWatch = startNetWatch(log.child({ mod: "net" }), (from, to) => {
+        ws.reconnect(`network changed: ${from || "<offline>"} → ${to}`);
+        wx.kick(`network changed → ${to}`);
+    });
+    // 微信 ClawBot: 每个扫码绑定的微信用户 = 一个群聊 `chat:wx_…`。分流层装在 tracker 里面 (先装) ——
+    // tracker 的空消息 gate / last-response 记录照样覆盖微信; 其余模块照旧只认 ws.client。
+    // 这里只建状态, 收发要等下面的入站监听全装好 (wx.start)。onBound 用到的 bridge 在下面
+    // 才立起来, 绑定只会在开机很久之后发生, 闭包里取得到。
+    const wxLog = log.child({ mod: "weixin" });
+    // `/wx` 命令与续上的绑定共用的企微出口 (原生 aibot, 不经微信分流)。
+    const wxPush = {
+        log: wxLog,
+        sendWecom: (p, md) => void ws.client
+            .sendMessage(baseOfKey(p).replace(/^(user|chat|group):/, ""), { msgtype: "markdown", markdown: { content: md } })
+            .catch((e) => wxLog.warn({ to: p, err: errText(e) }, "wx cmd push failed")),
+        sendWecomMedia: aibotSendMedia(ws.client, log.child({ mod: "media" })),
+    };
+    const wx = startWeixin({
+        cfg,
+        log: wxLog,
+        sinkFor: (to) => wecomBindSink(wxPush, to),
+        onBound: (acct, name) => makeOnBound({
+            cfg, sourcePath, log: wxLog,
+            hasSession: (t) => bridge.hasMirrorTarget(t),
+            newSession: (t, win) => bridge.newSession(t, win, undefined, { silent: true }),
+        })(acct, name),
+        notifyWecom: (p, md) => void ws.client
+            .sendMessage(baseOfKey(p).replace(/^(user|chat|group):/, ""), { msgtype: "markdown", markdown: { content: md } })
+            .catch((e) => wxLog.warn({ to: p, err: errText(e) }, "weixin → wecom notice failed")),
+    });
+    installWeixinPort(ws.client, wx, wxLog);
+    // 审批 / ask / outbound 的「送得到吗」: 微信 chat 看它自己的号, 不看企微长连接。
+    bindChatReach((c) => (wx.owns(c) ? wx.live(c) : undefined));
     // Wrap replyStream / replyStreamWithCard before any module sends —
     // last-response tracker enables inbound's `quote` dedup of bot self-replies,
     // and its chat-gate drops header-only pushes (empty messages) daemon-wide.
-    installResponseTracker(ws.client, log.child({ mod: "chat-gate" }));
+    // 微信出站不走企微长连接, 不必等它连上。
+    installResponseTracker(ws.client, log.child({ mod: "chat-gate" }), (c) => wx.owns(c));
     const mirrorStore = loadMirrorStore(cfg.wrc.mirror.attachmentsFile);
     // 定时任务表 —— 每条任务是 ~/.wezard/tasks/<id>.task.mjs 一份可注入代码的配置
     // (见 shared/task-file.ts)。目录是热加载的: wizard 改完文件不用 reload 守护进程。
@@ -132,6 +171,7 @@ const main = async () => {
             return t && known(t) ? t : undefined;
         },
         nameOf: (t) => settleName(wizardStore(), chatNameOf(cfg, t), t),
+        voiceOf: (t) => wizardStore()?.get(t)?.voiceOf,
     });
     // 人话也过交接的闸 (见 handoff.ts): 交接期间说的话进新会话, 不被旧会话带走、也不在
     // 重开的空档里 resume 回旧 sid。
@@ -190,7 +230,26 @@ const main = async () => {
     http.register("GET /detail", makeDetailHandler(log.child({ mod: "detail" })));
     for (const [key, handler] of Object.entries(chatHandlers()))
         http.register(key, handler);
+    // 终端 / 持口令的进程发起绑定: 先推确认卡给审批人 (口令每个 wizard 都读得到), 点了才出二维码。
+    const confirmBind = async (name) => {
+        const to = wxAdmins(cfg)[0];
+        if (!to)
+            throw new Error("没有审批人 (approval.approvers / defaultChat / allowFrom 里都没有 user:)");
+        const { decided } = await requestConfirm({
+            client: ws.client, principal: to, who: "本机 `wezard wx bind`",
+            title: "微信绑定待确认",
+            body: `本机有进程 (终端或持 daemon 口令的 wizard) 要绑定一个新微信${name ? ` (群名「${name}」)` : ""}: 同意才会出二维码, 扫码的那个微信将能驱动本机。`,
+            timeoutMs: 180_000,
+        });
+        return decided;
+    };
+    for (const [key, handler] of Object.entries(wxRoutes({ cfg, wx, sourcePath, confirmBind })))
+        http.register(key, guarded(handler));
+    bindWxCommands(makeWxCommands({ cfg, sourcePath, wx, ...wxPush }));
     installAskEventListener(ws.client, log.child({ mod: "ask" }));
+    // 入站监听 (inbound / approval / ask) 都装好了才开收: 首轮 getupdates 会立刻带回 reload 期间
+    // 人发的话 (含回菜单的数字), 游标随即前移 —— 早了就是永久丢。
+    wx.start();
     // 智能机器人 doc / smartsheet / contact MCP 桥接 — 总是注册路由, 失败让
     // 错误透传到上游 (Claude / curl)。requesterUserId 解析顺序:
     // 调用方 body.requesterUserId → defaultChat 里 user:<id> 部分 → 不传
@@ -598,6 +657,10 @@ const main = async () => {
         // 头不走 withTagHeader 的那些 (relay / notify / 工单) 正文里的 tag 在这里挂链;
         // 已挂过的 linkTags 认得出, 不会再套一层。
         const chatIdOf = (t) => baseOfKey(t).replace(/^(user|chat|group):/, "");
+        // 出站媒体只经这一个口子 (通道无关, 见 media.ts); 别的通道接进来时在这里按 principal 分流。
+        // 绑定过的微信群聊走微信 (上限不同, 校验也跟着各通道走 —— planFor)。
+        const media = routeSendMedia(wx, weixinSendMedia(wx), aibotSendMedia(ws.client, log.child({ mod: "media" })));
+        const sendMedia = media.send;
         const notifyChat = (base, markdown) => {
             const chatId = chatIdOf(base);
             void ws.client
@@ -605,18 +668,20 @@ const main = async () => {
                 .catch((e) => log.warn({ chatId, err: errText(e) }, "chat notify failed"));
         };
         // wizard 在群里的称呼, 只用在**正文**里。气泡的头照旧交给 withTagHeader ——
-        // 那一段是路由信息 (`emoji #tag`), parseTagHeader 靠它反解, 群里引用一条气泡
+        // 那一段是路由信息 (`emoji.name:`), parseTagHeader 靠它反解, 群里引用一条气泡
         // 就能直接跟那个 wizard 说话; 把它换成名字会把这条通路弄断。
         const displayName = (t) => {
             const name = settleName(wizards, chatNameOf(cfg, t), t);
             return name ? `.${name}` : "默认 wizard";
         };
         // wizard 之间的往返默认是私聊, 不进群。只有发话方判断「该当着人说」的那一次
-        // (send_peer public:true) 在公开频道里成一条气泡, 头写成 `.a → .b`, 方向一眼可读。
+        // (send_peer public:true) 在公开频道里成一条气泡, 头写成 `.a: .b`, 方向一眼可读。
         const RELAY_MAX = 1200;
-        /** 一个 wizard 在群里的称呼: `emoji .name`, 挂它的 rolepage。名字全局唯一, 不再
+        /** 一个 wizard 在群里的称呼: `.name`, 挂它的 rolepage。名字全局唯一, 不再
          *  因为落在哪个群而换写法 —— 引用这一段就能跟它说话 (parseTagHeader 认得)。 */
-        const relayLabel = (t, _dest) => tagLink(t, tagHead(t));
+        const relayLabel = (t) => ((h) => (h ? tagLink(t, h) : ""))(tagHead(t));
+        /** 以 `self` 的名义往 `dest` 群发一条: 头独占一行; 头怎么写 (群默认 wizard 报不报名) 归 ownHead。 */
+        const postAs = (self, dest, text) => notifyChat(dest, headed(ownHead(self, dest), text, "\n\n"));
         // 没开顶层模式的群里公开气泡多了 → 往那个群的管家 (群默认会话, target 就是 base principal) 信箱挂一行,
         // 让它问人要不要开顶层模式 (见 top-only-nudge.ts)。路径里写聊天名: 管家照抄就能 config_set。
         const topOnlyNudge = createTopOnlyNudge({
@@ -633,7 +698,7 @@ const main = async () => {
             const text = body.trim();
             if (!text || !channel)
                 return;
-            const head = `${relayLabel(from)} → ${relayLabel(to)}`;
+            const head = speakerHead(relayLabel(from), relayLabel(to));
             const clipped = text.length > RELAY_MAX ? `${text.slice(0, RELAY_MAX)}…` : text;
             // 头独占一行, 正文自成一个块 —— 只隔一个换行的话, markdown 会把正文首行
             // 当成头那一段的续行; 表格因此整张塌成一行带竖线的文字 (表格不能打断段落)。
@@ -656,7 +721,7 @@ const main = async () => {
          *  read_chat; 认不出 = ""。 */
         const audienceName = (channel, asker) => {
             const id = audienceOf(channel, asker);
-            return id === "human:" ? "" : id.slice("human:".length);
+            return id.startsWith("human:") ? id.slice("human:".length) : "";
         };
         // 挂起事项表 (见 pending-items.ts): 派活时记一行, 回执落定时由下面的 onOutcome 记账。
         const ledger = createLedger(loadJsonMap(cfg.wrc.mirror.pendingFile, pendingGc));
@@ -677,6 +742,12 @@ const main = async () => {
             nameOf: displayName,
             log,
             store: loadJsonMap(cfg.wrc.mirror.receiptsFile),
+            holdStore: loadJsonMap(cfg.wrc.mirror.holdsFile),
+            // 放行停放着的 after 件: 走 tell_peer 同一条注入路径, 沿用停放时的件号 / 频道 / 父 k。
+            release: async (h, seen) => {
+                const r = await tellPeerAs(h.from, h.body, afterNote(h.after, seen), { turn: h.turn, channel: h.channel, ...(h.k ? { k: h.k } : {}), ...(h.asker ? { asker: h.asker } : {}) });
+                return r.status === 200 ? { ok: true } : { ok: false, reason: String(r.body.reason ?? `HTTP ${r.status}`) };
+            },
             handingOff,
             handedOff,
             replyFor: (to, fromName, since, turn) => m.replyToPeer(to, fromName, since, turn),
@@ -896,6 +967,17 @@ const main = async () => {
         // 给**人**看。收件人就是地址 —— 聊天名或裸 principal, 没有「先订阅才收得到」
         // 这一步。头沿用 relay 那一套: 本群退化成寻常的 `emoji #tag`, 外群写成带聊天
         // 名的全称, 于是那边的人一眼看得出是谁、从哪个群说过来的。
+        // 顶层模式: 只有顶层 wizard 对人说话。拦的是「这一轮在为同伴干活」的: 同伴私聊派来的活, 或
+        // 回执轮但那件活是为上游同伴派的 (k 是 peer)。人说的、定时任务放的、旁支 (chain:false, 无 k)
+        // 的回执轮都不拦; 管家只在自己的群里豁免。notify 与 send_file 共用这一道闸。
+        const topOnlyMuted = (self, dests) => {
+            const env = openingOfSelf(self)?.env;
+            const belowTop = env?.kind === "peer" && (env.receipt ? kOfAttr(env.k ?? "")?.kind === "peer" : env.private);
+            const muted = dests.filter((d) => chatPolicyOf(cfg, d).topOnly && !(!tagOfKey(self) && baseOfKey(self) === d));
+            return muted.length && belowTop
+                ? { ok: false, topOnly: true, reason: `${muted.map((d) => chatNameOf(cfg, d) || d).join(", ")} 开着顶层模式: 你这一轮是同伴派来的活, 不对人说话 —— 要说的写进终句 (\`RESULT:\` / \`NEED:\`), 由派你的那个代你向人交代` }
+                : undefined;
+        };
         http.register("POST /notify", async (req, res) => {
             const { self, body } = await readPeerBody(req);
             if (!self) {
@@ -920,22 +1002,69 @@ const main = async () => {
                 return;
             }
             const dests = [...new Set(refs.length ? refs.map((r) => chatBaseOf(cfg, r)) : [channelOf(self)])];
-            // 顶层模式: 只有顶层 wizard 对人说话。拦的是「这一轮在为同伴干活」的: 同伴私聊派来的活, 或
-            // 回执轮但那件活是为上游同伴派的 (k 是 peer)。人说的、定时任务放的、旁支 (chain:false, 无 k)
-            // 的回执轮都不拦; 管家只在自己的群里豁免。
-            const env = openingOfSelf(self)?.env;
-            const belowTop = env?.kind === "peer" && (env.receipt ? kOfAttr(env.k ?? "")?.kind === "peer" : env.private);
-            const muted = dests.filter((d) => chatPolicyOf(cfg, d).topOnly && !(!tagOfKey(self) && baseOfKey(self) === d));
-            if (muted.length && belowTop) {
-                json(res, 409, { ok: false, topOnly: true, reason: `${muted.map((d) => chatNameOf(cfg, d) || d).join(", ")} 开着顶层模式: 你这一轮是同伴派来的活, 不对人说话 —— 要说的写进终句 (\`RESULT:\` / \`NEED:\`), 由派你的那个代你向人交代` });
+            const muted = topOnlyMuted(self, dests);
+            if (muted) {
+                json(res, 409, muted);
                 return;
             }
             const asker = askerOf(self);
             for (const dest of dests) {
-                notifyChat(dest, `${relayLabel(self)}\n\n${content}`);
+                postAs(self, dest, content);
                 recordPost({ target: self, channel: dest, body: content, ...(asker ? { asker } : {}) });
             }
-            json(res, 200, { ok: true, sent: dests.map((d) => chatNameOf(cfg, d) || d) });
+            // 微信群聊: 人超过 ctxTtlSec 没说话时微信会静默丢弃, 消息只能压着等他下次开口 —— 如实告诉调用方, 别回「已发送」。
+            const wxId = (d) => baseOfKey(d).replace(/^chat:/, "");
+            const held = dests.filter((d) => wx.owns(wxId(d)) && !wx.fresh(wxId(d)));
+            const name = (d) => chatNameOf(cfg, d) || d;
+            json(res, 200, {
+                ok: true,
+                sent: dests.filter((d) => !held.includes(d)).map(name),
+                ...(held.length ? { held: held.map(name), note: `微信群聊 ${held.map(name).join("、")} 那头超过 ${cfg.weixin.ctxTtlSec}s 没说话: 微信会静默丢弃主动推送, 这条已压着, 对方下次在微信里开口时送达 (定时提醒做不到准点)` } : {}),
+            });
+        });
+        // ── 给人看的文件 / 图片 ────────────────────────────────────────────
+        // notify 的媒体版: 去向、认名字、顶层模式闸都与它同一套; 投递交给 sendMedia (通道无关,
+        // 按 principal 分到 aibot / 微信)。caption 先成一条带头的气泡, 让群里知道是谁发的。
+        http.register("POST /send_file", async (req, res) => {
+            const { self, body } = await readPeerBody(req);
+            if (!self) {
+                json(res, 400, { ok: false, reason: "cannot resolve caller session" });
+                return;
+            }
+            const b = body;
+            const path = expandHome((b.path ?? "").trim());
+            if (!path) {
+                json(res, 400, { ok: false, reason: "path required" });
+                return;
+            }
+            ensureChatNames(self);
+            const ref = (b.to ?? "").trim();
+            const dest = ref ? chatBaseOf(cfg, ref) : channelOf(self);
+            if (!dest) {
+                json(res, 400, { ok: false, reason: `认不出聊天: ${ref} (wizard_roster 每行有 home 聊天名, 人侧 /chats; 没起名的聊天寻址不到)` });
+                return;
+            }
+            const muted = topOnlyMuted(self, [dest]);
+            if (muted) {
+                json(res, 409, muted);
+                return;
+            }
+            const plan = media.plan(dest, { path, ...(b.kind ? { kind: b.kind } : {}) });
+            if (!plan.ok) {
+                json(res, 400, plan);
+                return;
+            }
+            const caption = (b.caption ?? "").trim();
+            if (caption)
+                postAs(self, dest, caption);
+            const r = await sendMedia(dest, { path, kind: plan.kind, ...(b.title ? { title: b.title } : {}), ...(b.description ? { description: b.description } : {}) });
+            if (!r.ok) {
+                json(res, 502, r);
+                return;
+            }
+            const asker = askerOf(self);
+            recordPost({ target: self, channel: dest, body: [caption, `📎 ${r.name} (${r.kind}) · ${path}`].filter(Boolean).join("\n\n"), ...(asker ? { asker } : {}) });
+            json(res, 200, { ok: true, sent: chatNameOf(cfg, dest) || dest, kind: r.kind, name: r.name, bytes: r.bytes });
         });
         http.register("POST /peers/peek", async (req, res) => {
             const { self, body } = await readPeerBody(req);
@@ -1066,9 +1195,29 @@ const main = async () => {
         const ttlOf = (p) => (cacheTtlSec(p) || cfg.wrc.mirror.keepalive.ttlSec) * 1000;
         // 被冷门控退回过的 `self\0target` → 到期时刻: 老 MCP 进程原样重发即视为 force。
         const coldRefused = new Map();
+        /** 入参 `after` → 件号数组 (去反引号 / 空白 / 重复)。 */
+        const afterTurnsOf = (body) => {
+            const raw = body.after;
+            return [...new Set((Array.isArray(raw) ? raw : []).map((x) => String(x).replace(/[`\s]/g, "")).filter(Boolean))];
+        };
+        /** 放行时挂在信封后面的前置结论: 谁交的、件号、RESULT 与 ARTIFACT 原样 (只进对方输入框)。 */
+        const afterNote = (turns, seen) => renderReminder({ wezard: "after" }, [
+            "这件活排在下面这些前置之后, 它们都已落定; 结论原样附上 (谁交的 · 件号):",
+            ...turns.flatMap((t) => {
+                const x = seen[t];
+                if (!x)
+                    return [];
+                const c = parseClosing(x.body, 1500);
+                const clean = (v) => v.replace(/<\/?system-reminder[^>]*>/g, "");
+                return [
+                    `- ${displayName(x.to)} · ${t} · ${x.status}: ${c.kind === "result" ? `RESULT: ${clean(c.text)}` : clipLine(clean(x.body), 600) || "(没有正文)"}`,
+                    ...c.artifacts.map((a) => `  ARTIFACT: ${a.path}${a.note ? ` — ${a.note}` : ""}`),
+                ];
+            }),
+        ]);
         /** tell_peer 的本体: 以 `self` 的名义说一句 —— HTTP 路由与 dispatch 共用。`extra` = 挂在信封后面的
          *  一段 (只进对方输入框, 不进 `text`: 公开时 text 会成群气泡)。 */
-        const tellPeerAs = async (self, body, extra = "") => {
+        const tellPeerAs = async (self, body, extra = "", held) => {
             const text = (body.text ?? "").toString();
             if (!text.trim()) {
                 return { status: 400, body: { ok: false, reason: "text required" } };
@@ -1084,7 +1233,8 @@ const main = async () => {
             const { target, foreign } = r;
             // 件号先于一切: `re` 续问沿用那件活的件号、工单与频道 (见 receipts.prepare)。
             const re = (body.re ?? "").toString().trim();
-            const turn = receipts.prepare(self, target, re || undefined);
+            // 放行一件停放着的 (after): 件号 / 频道 / 父 k / 链头都沿用停放那一刻定的 —— 依赖边不改 k。
+            const turn = held ? { turn: held.turn, legs: 1, channel: held.channel } : receipts.prepare(self, target, re || undefined);
             // 续问只在那个工单还开着时沿用它: 收了工的工单不再收成员, 续问照样能发。
             // 没带工单的一句顶掉一份还没落定的工单活, 也算在那张工单上 (receipts.register 同理
             // 继承): 不然换个不带 job 的 tell_peer 就绕开了预算。
@@ -1098,11 +1248,40 @@ const main = async () => {
             const leadJob = jobs.all().find((j) => j.kind === "req" && j.status === "open" && j.owner === self && j.members.some((x) => x.target === target && x.role === "lead"))?.id ?? "";
             const jobId = kind === "fyi" ? "" : askedJob || isOpen(turn.job) || (open?.deferred ? "" : isOpen(open?.job)) || (re && turn.reUnknown ? leadJob : "");
             if (jobId) {
-                const jc = checkJob(jobId, target, !!open?.need && open.turn === turn.turn);
+                const jc = checkJob(jobId, target, (!!open?.need && open.turn === turn.turn) || !!held);
                 if (!jc.ok) {
                     return { status: jc.status, body: { ok: false, reason: jc.reason } };
                 }
             }
+            // 派活方向闸 (见 direction.ts): 只拒不改投递路径, 不动回执 k。
+            const dr = held ? undefined : checkDirection({ self, target, kind, re: turn.legs > 1, jobId, jobs: jobs.all(), chain: receipts.ancestorsOf(self, parentKOf(self)), nameOf: displayName });
+            if (dr) {
+                return { status: 409, body: { ok: false, gated: "direction", reason: dr } };
+            }
+            // 依赖 (after): 前置必须是自己派出去的件。查不到 → 400; 有失败的 → 409; 都 done → 照常投并附结论; 还有没落定的 → 停放 (见下)。
+            const afters = held ? [] : afterTurnsOf(body);
+            const prereqs = afters.length ? receipts.prereqs(self, afters) : [];
+            if (afters.length) {
+                if (kind !== "task" || re) {
+                    return { status: 400, body: { ok: false, reason: "`after` 只用于派新活 (kind:\"task\"、不带 re)" } };
+                }
+                const gone = afters.filter((_, i) => prereqs[i].state === "unknown");
+                if (gone.length) {
+                    return { status: 400, body: { ok: false, reason: `after 里的 ${gone.join(" ")} 在你的回执登记里查不到 —— 只能依赖你自己派出去的件号 (过期 / 被同一对的新一句顶掉的也查不到)` } };
+                }
+                const failed = afters.flatMap((t, i) => { const p = prereqs[i]; return p.state === "failed" ? [`${t} (${displayName(p.seen.to)}) 以 ${p.seen.status} 收场`] : []; });
+                if (failed.length) {
+                    return { status: 409, body: { ok: false, reason: `前置 ${failed.join("; ")} —— 这件不投; 前置失败了就先处理它, 再重发` } };
+                }
+                const cur = receipts.pending(self, target);
+                if (cur && !afters.includes(cur.turn)) {
+                    return { status: 409, body: { ok: false, reason: `你已有一件活 (${cur.turn}) 在 ${displayName(target)} 手上没落定, 同一对只有一个回执槽 —— 等它交差, 或把它也列进 after` } };
+                }
+            }
+            const parkIt = prereqs.some((p) => p.state === "pending");
+            // 前置都已落定: 不停放, 结论附在信封后面照常投。
+            if (afters.length && !parkIt)
+                extra += afterNote(afters, Object.fromEntries(afters.map((t, i) => [t, prereqs[i].seen])));
             // 公开与否由发话方 (LLM) 判断: 公开 = 在它这一轮的公开频道里说, 气泡进群、对方
             // 那一轮的回复也发进这个群; 私聊 (默认) = 只落双方的 rolepage, 回复靠 wait_peer 取。
             // 只有两端都是登记在册的 wizard 才能当着人说: 裸 target 冒充的发话方、forget
@@ -1154,6 +1333,25 @@ const main = async () => {
                     return { status: 409, body: { ok: false, gated: "cold", reason: gate + (force === undefined ? " (你的 MCP 是旧版、没有 force 参数: 10 分钟内原样再发一次即视为 force)" : "") } };
                 }
             }
+            // 前置还没落定: 不注入, 登记一份停放 (见 receipts.Hold) —— 件号、频道、父 k、链头定在这一刻,
+            // 放行时原样沿用; 工单成员与预算也现在就记, 「齐了吗」照常数。
+            if (parkIt) {
+                const bp = body;
+                const pk = bp.chain === false ? undefined : parentKOf(self);
+                const pasker = askerOf(self);
+                receipts.hold({
+                    from: self, to: target, turn: turn.turn, at: Date.now(), after: afters, channel, job: jobId,
+                    ...(pk ? { k: pk } : {}), ...(pasker ? { asker: pasker } : {}),
+                    // force: 冷门控上面已过一遍, 放行时缓存又凉了也不再退回。
+                    body: { name: peerAddress(cfg, self, target), text, kind, force: true, ...(jobId ? { job: jobId } : {}), ...(bp.role ? { role: bp.role } : {}), ...(bp.priority ? { priority: bp.priority } : {}), ...(bp.waitSec ? { waitSec: bp.waitSec } : {}), ...(bp.deadline !== undefined ? { deadline: bp.deadline } : {}), ...(bp.receipt === false ? { receipt: false } : {}) },
+                });
+                if (jobId) {
+                    const role = roleParam(bp.role);
+                    jobs.attach(jobId, { target, task: text, spawned: false, ...(role ? { role } : {}) }, kind === "ask" ? "ask" : "task");
+                    jobs.spend(jobId);
+                }
+                return { status: 200, body: { ok: true, parked: true, after: afters, turn: turn.turn, name: peerAddress(cfg, self, target), ...(jobId ? { job: jobId } : {}), receipt: `排在 ${afters.join(" ")} 之后: 前置都 done 才投 (带上它们的结论), 任一失败这件不投、按 canceled 回给你; 不要挂在 wait_peer 上等, 接着干你自己的事` } };
+            }
             // 「忙」= 这一轮还没结束, 或停在审批上等人 —— 都不是能接新活的时候。
             const wasBusy = !(await m.idleNow(target));
             // urgent 只打断你自己派的那一轮 (或它自己的回执轮): 手上若是别的 wizard / 人 / 定时任务的活,
@@ -1192,7 +1390,7 @@ const main = async () => {
             // 是"放出去就不管了"的那种派活; fyi 一定不要。对方的信封据此改口, 不再让它收口。
             const wantReceipt = kind !== "fyi" && body.receipt !== false;
             const deadlineAt = deadlineOf(at, deadlineSec === undefined ? undefined : Number(deadlineSec));
-            const asker = askerOf(self);
+            const asker = held ? held.asker : askerOf(self);
             const inj = await m.injectText(target, text, undefined, {
                 from: { kind: "peer", from: self, turn: turn.turn, ...(jobId ? { job: jobId } : {}), ...(isPublic ? { public: true } : {}), ...(asker ? { asker } : {}) },
                 channel,
@@ -1210,7 +1408,7 @@ const main = async () => {
             // 一份不守的槽会以同一对的 key 顶掉发话方还在等它答的那件活, 那件的回执就再也来不了。
             // 父 k: 默认这件活算发话方此刻在答的那件的子活 (链式续回); `chain:false` = 旁支,
             // 回执照常回来, 但不挂住它给上游的交代 —— 只有发话方知道这件活是不是为上游派的。
-            const k = body.chain === false ? undefined : parentKOf(self);
+            const k = held ? held.k : body.chain === false ? undefined : parentKOf(self);
             if (inj.ok && wantReceipt)
                 receipts.register({ from: self, to: target, channel, job: jobId, at, turn: turn.turn, legs: turn.legs, deadlineAt, ...(k ? { k } : {}), ...(asker ? { asker } : {}) });
             if (inj.ok && wantReceipt) {
@@ -1229,7 +1427,8 @@ const main = async () => {
                     jobs.mark(jobId, { gate: { g2: Date.now() } });
                 jobs.attach(jobId, { target, task: turn.legs > 1 ? "" : text, spawned: false, ...(role ? { role } : {}) }, kind === "ask" ? "ask" : "task");
             }
-            const spent = inj.ok && jobId ? jobs.spend(jobId) : undefined;
+            // 停放时已记过预算, 放行不再算一次。
+            const spent = inj.ok && jobId && !held ? jobs.spend(jobId) : undefined;
             if (inj.ok && isPublic)
                 relayPeer(self, target, text, channel);
             // `wasBusy` 是给调用方的判断依据: 立刻投给一个正在生成的会话, 这句话会排在
@@ -1344,10 +1543,12 @@ const main = async () => {
         });
         // 交接的「重开」一步: 走 /new (杀旧 pane、起新进程) 而不是往原 pane 注入 /clear。
         // /clear 只换会话不换进程 —— MCP 子进程、charter 都还是旧的, 新工具拿不到; 镜像
-        // 还得靠 sid 轮换探测才跟得上。模型 / CLI / cwd / keepalive 照旧沿用。
+        // 还得靠 sid 轮换探测才跟得上。CLI / cwd / keepalive 照旧沿用; 模型也沿用, 管家除外 ——
+        // 它换上此刻的管家档 (newSession 里定), 改了 models.steward 后交接一次就是让它生效的那一下。
         const restartFresh = (target) => {
             const info = m.sessionInfo(target);
-            return m.newSession(target, displayName(target) || tagOfKey(target) || target, info?.cli, { model: info?.model || undefined, silent: true, warm: true });
+            const model = stewardTierOf(cfg, target) ? undefined : info?.model || undefined;
+            return m.newSession(target, displayName(target) || tagOfKey(target) || target, info?.cli, { model, silent: true, warm: true });
         };
         // POST /handoff — 交接一个 pane 的会话给一个全新会话。先让目标会话把当前工作
         // 压成一份"零上下文也能接手"的交接简报,等它写完并抓取,再 restartFresh 换一个
@@ -1503,7 +1704,13 @@ const main = async () => {
             snapshot: (t) => (wizards.get(t)?.parent ? undefined : () => m.chatTargets(t)
                 .filter((x) => x !== t && wizards.get(x)?.name)
                 .filter((x) => ((p) => !tagOfKey(x) || (!p ? !!wizards.get(x)?.description : p === t || p === baseOfKey(t)))(wizards.get(x)?.parent))
-                .map((x) => ({ name: displayName(x), state: ((v) => (v === undefined ? "-" : v ? "idle" : "busy"))(m.idleVerdict(x)), job: wizards.get(x)?.description || (tagOfKey(x) ? "" : "steward") }))),
+                .map((x) => {
+                const i = m.sessionInfo(x);
+                const state = ((v) => (v === undefined ? "-" : v ? "idle" : m.parkedNow(x) ? "parked" : "busy"))(m.idleVerdict(x));
+                // 冷热与 route_candidates / tell_peer 冷门控同一口径 (touchOf / ttlOf)。
+                const warmth = i?.jsonlPath ? { ctx: i.contextTokens, cold: wakeCostOf(i.contextTokens, touchOf(i.jsonlPath), Date.now(), ttlOf(i.jsonlPath)).cold } : {};
+                return { name: displayName(x), state, ...warmth, job: wizards.get(x)?.description || (tagOfKey(x) ? "" : "steward") };
+            })),
             seen: createSeenRing(loadJsonMap(cfg.wrc.mirror.noticeSeenFile, gcSeen), (t) => m.sessionInfo(t)?.sessionId ?? ""),
             cwdOf: (t) => ((c) => c.runningCwd || c.defaultCwd)(m.getCwd(t)),
         }));
@@ -1531,7 +1738,7 @@ const main = async () => {
                 const one = xs.length === 1;
                 const mark = (i) => (one ? "" : "①②③④⑤⑥⑦⑧⑨⑩"[i] ?? `${i + 1}.`);
                 const text = `有 ${xs.length} 件做完了等你看: ${xs.map(({ job, at }, i) => `${mark(i)}「${job.title}」(${agoZh(now - at)}交付)`).join(" ")} —— 回一句「好」就收, 或者说哪里不对。`;
-                notifyChat(chat, `${relayLabel(owner)}\n\n${text}`);
+                postAs(owner, chat, text);
                 recordPost({ target: owner, channel: chat, body: text });
                 xs.forEach(({ job }) => jobs.mark(job.id, { nudge: { n: (job.nudge?.n ?? 0) + 1, lastAt: now } }));
                 notices.post([owner], `nudged the human (daemon, in your name) about finished requests; their next line may be the verdict on one: ${xs.map(({ job }) => `${job.id} "${job.title}"`).join(" · ")}`);
@@ -1734,6 +1941,12 @@ const main = async () => {
                     };
                 }),
                 chatNames: Object.fromEntries(listChatNames(cfg).map((c) => [c.base, c.name])),
+                // 微信用户的发话人 id 就是它那个群的 chatId: 名字跟着群名走。
+                humanNames: Object.fromEntries(wx.list().map((a) => [`human:${a.chatId}`, chatNameOf(cfg, `chat:${a.chatId}`)]).filter(([, n]) => n)),
+                weixin: wx.list().map((a) => ({
+                    base: `chat:${a.chatId}`, state: a.state, lastInAt: a.lastInAt ?? 0, held: a.outbox.length,
+                    budget: a.ctx ? Math.max(0, cfg.weixin.sendCap - a.ctx.used) : 0, pausedUntil: a.pausedUntil ?? 0,
+                })),
             };
         };
         // 一次采集失败 (某个 pane 的 tmux 抖了一下) 不等于注册表没了: 退回上一份好的,
@@ -1753,6 +1966,7 @@ const main = async () => {
             name: settleName(wizards, chatNameOf(cfg, target), target),
             address: peerAddress(cfg, self, target),
             description: wizards.get(target)?.description ?? "",
+            ...(wizards.get(target)?.expertise ? { expertise: wizards.get(target).expertise } : {}),
             cwd: m.getCwd(target).runningCwd,
         });
         /** 自己的地址 = 全局名字, 与住在哪个群无关。 */
@@ -1971,6 +2185,7 @@ const main = async () => {
             const b = body;
             const asked = normalizeTag((b.name ?? "").toString());
             const description = (b.description ?? "").toString().trim();
+            const expertise = (b.expertise ?? "").toString().trim();
             if ((b.name ?? "").toString().trim() && !asked) {
                 json(res, 400, { ok: false, reason: "名字只能是 1-32 位字母/数字/`_`/`-`" });
                 return;
@@ -1979,6 +2194,9 @@ const main = async () => {
             const name = asked ? wizards.rename(self, asked) : before;
             if (description)
                 wizards.upsert(self, { description });
+            // 专长: 传 "-" 清掉; 它不进名册变动通知 (只在名册 / 候选行里读)。
+            if (expertise)
+                wizards.upsert(self, { expertise: expertise === "-" ? undefined : expertise });
             const me = identityOf(self, self);
             // 职责是别人决定"该不该找你"的依据, 改了就得让同群的知道 —— 否则他们照着
             // 出生快照里那句旧的 (或者空的) 职责派活。
@@ -2000,7 +2218,7 @@ const main = async () => {
             const q = (b.query ?? "").trim().toLowerCase();
             const chat = (b.chat ?? "").trim().toLowerCase();
             const cwd = (b.cwd ?? "").trim().toLowerCase();
-            return (w) => (!q || [w.name, w.address, w.description, w.target].some((f) => (f ?? "").toLowerCase().includes(q))) &&
+            return (w) => (!q || [w.name, w.address, w.description, w.expertise, w.target].some((f) => (f ?? "").toLowerCase().includes(q))) &&
                 (!chat || (w.chat ?? "").toLowerCase() === chat || (w.target ?? "").toLowerCase().includes(chat)) &&
                 (!cwd || (w.cwd ?? "").toLowerCase().includes(cwd)) &&
                 (b.alive !== true || w.alive);
@@ -2026,7 +2244,7 @@ const main = async () => {
             const shown = ranked.slice(0, limit).map((r) => ({
                 ...r,
                 turns: turnsLine(inflight, r.target),
-                duty: dutyLine(jobs.all(), r.target),
+                duty: dutyLine(jobs.all(), r.target, (t) => `.${displayName(t)}`),
                 model: r.model || (r.jsonlPath ? lastModel(r.jsonlPath) : ""),
                 summary: r.jsonlPath ? lastExchange(r.jsonlPath, 80, warm) : "",
                 contextTokens: r.jsonlPath ? lastContextTokens(r.jsonlPath) : 0,
@@ -2080,7 +2298,7 @@ const main = async () => {
                 return;
             }
             const limit = Math.min(Math.max(Number(b.limit ?? 5) || 5, 1), 20);
-            const cands = rankCandidates(task, (b.cwd ?? "").trim() || m.getCwd(self).runningCwd, await routeRowsOf(self)).slice(0, limit);
+            const cands = rankCandidates(task, (b.cwd ?? "").trim() || m.getCwd(self).runningCwd, await routeRowsOf(self), { now: Date.now(), ttlMs: cfg.wrc.mirror.keepalive.ttlSec * 1000 }).slice(0, limit);
             json(res, 200, { ok: true, text: renderCandidates(task, cands, Date.now(), cfg.wrc.mirror.keepalive.ttlSec * 1000, homedir()) });
         });
         // 派活收成一步 (见 route.decide): 查候选 → 过成本门控 → 转给已有的或按档白板 spawn →
@@ -2107,7 +2325,7 @@ const main = async () => {
             // 不是别人开着的工单里的队员 —— 点名 (`to`) 不受此限。
             const inOthersJob = (t) => jobs.openOf(baseOfKey(t)).some((j) => j.owner !== self && j.members.some((mm) => mm.target === t));
             const pool = to || b.spawn || lead ? [] : (await routeRowsOf(self)).filter((r) => r.alive && !!tagOfKey(r.target) && !inOthersJob(r.target));
-            const cands = rankCandidates(task, m.getCwd(self).runningCwd, pool).slice(0, 5);
+            const cands = rankCandidates(task, m.getCwd(self).runningCwd, pool, { now, ttlMs }).slice(0, 5);
             let d = to ? { kind: "existing", why: `你点名了 ${to}` }
                 : b.spawn ? { kind: "spawn", why: "你要了新的" }
                     : lead ? { kind: "spawn", why: "复杂活: 白板起一个 hard 档的 lead, 由它组队" }
@@ -2138,7 +2356,7 @@ const main = async () => {
             const settleRoot = (ok) => { if (rootId && !ok)
                 jobs.close(rootId, "派活没投成"); };
             const withRoot = (body) => rootId
-                ? { ...body, job: rootId, hint: "需求根单已开, 对人**别提单号**。lead 交付后根单仍开着, 等人验收: 人认可 → close_job(job) 归档并回收 lead; 人说不对 → tell_peer({name, re, job}) 给 lead 返工 (同一张单, 不开新单); 人说不要了 → close_job({job, as:\"cancel\"}); 先放着 → close_job({job, as:\"shelve\"}) (停提醒, 不关单)。" }
+                ? { ...body, job: rootId, hint: "需求根单已开, 对人**别提单号**。lead 交付后根单仍开着, 等人验收: 人认可 → close_job(job) 归档; 人说不对 → tell_peer({name, re, job}) 给 lead 返工 (同一张单, 不开新单); 人说不要了 → close_job({job, as:\"cancel\"}); 先放着 → close_job({job, as:\"shelve\"}) (停提醒, 不关单)。" }
                 : body;
             if (d.kind === "existing") {
                 const name = to || (d.kind === "existing" && d.row ? d.row.address || d.row.name : "");
@@ -2155,13 +2373,13 @@ const main = async () => {
                     wizards.upsert(r.target, { lead: true });
                 if (rootId && t.status === 200)
                     jobs.attach(rootId, { target: r.target, task: "", spawned: false, role: "lead" });
-                // 自动选中的被冷门控退回 (decide 用名册的活动时刻, 门控用 transcript 的, 口径差一点): 改走 spawn。
-                if (!(t.body.gated === "cold" && !to)) {
+                // 自动选中的被冷门控 (decide 用名册的活动时刻, 门控用 transcript 的, 口径差一点) 或方向闸 (它归别人管 / 是借来的专家) 退回: 改走 spawn; 点名的不改。
+                if (!(!to && (t.body.gated === "cold" || t.body.gated === "direction"))) {
                     settleRoot(t.status === 200);
                     json(res, t.status, withRoot({ ...t.body, decision: "existing", reason: d.why, ...(shown.length ? { candidates: shown } : {}) }));
                     return;
                 }
-                d = { kind: "spawn", why: `${d.why}; 但它被冷门控退回 (${String(t.body.reason)}) —— 改为白板 spawn` };
+                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();
@@ -2180,7 +2398,7 @@ const main = async () => {
             // 宪章里只有层级规矩, 打法随信封带 (宪章每轮都在上下文里, 打法只这一件活用得上)。
             const t = await tell(String(born.body.name), task, lead ? renderReminder({ wezard: "lead" }, renderLeadPlaybook()) : "");
             settleRoot(t.status === 200);
-            // 为这张根单生出来的: 归档 close_job 时要回收它 (tell 记的是 spawned:false, 再 attach 一次补上; lead 角色也在这里记)。
+            // 为这张根单生出来的 (tell 记的是 spawned:false, 再 attach 一次补上; lead 角色也在这里记)。
             if (rootId && t.status === 200)
                 jobs.attach(rootId, { target: String(born.body.target), task: "", spawned: true, role: "lead" });
             json(res, t.status, withRoot({
@@ -2275,6 +2493,11 @@ const main = async () => {
                     return { status: jc.status, body: { ok: false, reason: jc.reason } };
                 }
             }
+            // 带 task 派下去 = 派活: 同样过方向闸, 不论带不带 job (新生的目标还不在任何单里, 实际只有 1 / 链深两条会拦)。
+            const dr = (b.task ?? "").toString().trim() ? checkDirection({ self, target: "", kind: "task", re: false, jobId, jobs: jobs.all(), chain: receipts.ancestorsOf(self, parentKOf(self)), nameOf: displayName }) : undefined;
+            if (dr) {
+                return { status: 409, body: { ok: false, gated: "direction", reason: dr } };
+            }
             // `inherit` 没有默认值 —— 继承与否是两种完全不同的分身 (一种开局就带着你
             // 读过的一切, 另一种白纸一张), 猜错了要么白烧一份上下文, 要么让它从零重读。
             // 逼调用方每次自己说。
@@ -2307,16 +2530,28 @@ const main = async () => {
                 return { status: 409, body: { ok: false, reason: `${displayName(source)} 没有可 fork 的会话 (还没说过话, 或绑定已失效)` } };
             }
             const alivePeers = detached ? [] : await m.peers(self);
-            // 预算。撞到上限不是"不许再分", 是"先把干完活的收掉": stop_wizard 收单个,
-            // close_job 整批回收一个工单的临时分身。只数**本聊天里**活着的 ——
+            // 预算。撞到上限由守护进程腾位, 不叫调用方去收: 最久没动的闲分身只关 pane、绑定留着
+            // (同 maxPanes 的 reap), 再找它 `--resume` 带全上下文复活。忙的、停在审批上的、手上
+            // 还有没落定的活的不动; 全都动不了才拒。只数**本聊天里**活着的 ——
             // 生到别的聊天去的归那边管, 为了数它们再探一遍 tmux 不值当。
-            const aliveKids = childrenOf(wizards.all(), self).filter((k) => alivePeers.some((pp) => pp.target === k.target && pp.paneAlive));
-            if (!detached && aliveKids.length >= cfg.wrc.mirror.cloneMax) {
-                return { status: 429, body: {
-                        ok: false,
-                        reason: `你名下已经有 ${aliveKids.length} 个活着的分身 (上限 ${cfg.wrc.mirror.cloneMax}) —— 先 stop_wizard 收掉干完活的那些, 或者 close_job 整批回收一个工单`,
-                        clones: aliveKids.map((k) => peerAddress(cfg, self, k.target)),
-                    } };
+            const aliveKids = alivePeers.filter((pp) => pp.paneAlive && childrenOf(wizards.all(), self).some((k) => k.target === pp.target));
+            const over = detached ? 0 : aliveKids.length - cfg.wrc.mirror.cloneMax + 1;
+            if (over > 0) {
+                const parked = new Set(listPending().map((p) => p.meta.sessionId).filter(Boolean));
+                const owing = new Set(receipts.states().map((x) => x.to));
+                const idle = aliveKids
+                    .filter((pp) => !pp.busy && !owing.has(pp.target) && !parked.has(m.sessionInfo(pp.target)?.sessionId ?? ""))
+                    .sort((x, y) => x.lastActivity - y.lastActivity)
+                    .slice(0, over);
+                const slept = (await Promise.all(idle.map((pp) => m.sleepPane(pp.target)))).filter((r) => r.ok).length;
+                if (slept < over) {
+                    return { status: 429, body: {
+                            ok: false,
+                            reason: `你名下 ${aliveKids.length} 个活着的分身 (上限 ${cfg.wrc.mirror.cloneMax}) 都在干活, 腾不出位置 —— 等其中一个交回结论再分`,
+                            clones: aliveKids.map((k) => peerAddress(cfg, self, k.target)),
+                        } };
+                }
+                log.info({ self, slept: idle.map((pp) => pp.target) }, "clone cap: idle clones put to sleep");
             }
             const wantChat = (b.chat ?? "").toString().trim();
             const base = wantChat ? chatBaseOf(cfg, wantChat) : baseOfKey(self);
@@ -2630,7 +2865,7 @@ const main = async () => {
                 title,
                 ...(parentJob ? { parent: parentJob.id } : {}),
                 memberMax: JOB_MEMBER_MAX,
-                hint: "把这个 id 传给 spawn_wizard / clone_wizard / tell_peer 的 `job` 参数, 它们就归到这个工单名下 (一律私聊, 不进群); 活干完调 close_job 留档并回收临时分身, 给人的结论写在你自己这一轮的最终回复里。",
+                hint: "把这个 id 传给 spawn_wizard / clone_wizard / tell_peer 的 `job` 参数, 它们就归到这个工单名下 (一律私聊, 不进群); 活干完调 close_job 留档, 给人的结论写在你自己这一轮的最终回复里。",
             });
         });
         http.register("POST /jobs/close", async (req, res) => {
@@ -2671,22 +2906,18 @@ const main = async () => {
                 json(res, 200, { ok: true, job: id, [how === "shelve" ? "shelved" : "resumed"]: true });
                 return;
             }
-            // 关一张单连它还开着的后代单一起关 (深的先关): 否则子 lead 的分身留在原地、账本上挂着没人收的单。
-            // 回收只针对**为这个工单生出来的**分身: 被拉来帮忙的长期 wizard 不该因为一次活结束就被杀掉。
-            // 调用方自己也不收 —— 那会在这次工具调用里把自己干掉。
-            const recycle = b.stop !== false;
+            // 关一张单连它还开着的后代单一起关 (深的先关): 否则账本上挂着没人收的子单。
+            // 收工只结账、留档, 不碰成员的 pane: 分身的去留与工单无关, pane 多了由 maxPanes / cloneMax 自己收
+            // (只关 pane、绑定留着)。老 MCP 进程还会带 `stop`, 收下不用。
             const openKids = (j) => jobChildren(jobs.all(), j.id).filter((c) => c.status === "open").flatMap((c) => [...openKids(c), c]);
             const cascade = openKids(job);
             const closeOne = async (j, summary, mark) => {
-                const victims = recycle ? j.members.filter((mm) => mm.spawned && mm.target !== self) : [];
-                // 收掉之前把它们手上没落定的活记成 canceled: 不然发起者收工之后还会收到一串 dead 回执。
-                victims.forEach((mm) => receipts.cancel(mm.target, j.owner));
-                // 留档要的 sessionId 得在回收之前取: killPane 连绑定一起删。
                 const sids = new Map([j.owner, ...j.members.map((mm) => mm.target)].map((t) => [t, m.sessionInfo(t)?.sessionId ?? ""]));
-                const killed = await victims.reduce(async (acc, mm) => (await acc) + ((await m.killPane(mm.target)).ok ? 1 : 0), Promise.resolve(0));
-                // 取消: 还没落定、又不是为这张单生的成员 (长住 wizard) 不杀, 但它们名下这张单派的活记成 canceled, 发起者不会再收到一串回执。
+                // 取消: 还没落定的成员手上这张单派的活记成 canceled, 发起者不会再收到一串回执。
                 if (how === "cancel")
-                    j.members.filter((mm) => !mm.outcome && !victims.includes(mm)).forEach((mm) => receipts.cancel(mm.target, j.owner, (x) => x.from === j.owner));
+                    j.members.filter((mm) => !mm.outcome).forEach((mm) => receipts.cancel(mm.target, j.owner, (x) => x.from === j.owner));
+                // 这张单名下还排着没投的 (after 停放) 也不投了。
+                receipts.cancelHeld(j.id, j.owner);
                 const closed = jobs.close(j.id, summary, mark);
                 ledger.closeJob(j.id);
                 // 收工结论留档到开单者名下 (与交接简报同一份 jsonl); 空工单 (没人、没结论) 不记。
@@ -2695,13 +2926,12 @@ const main = async () => {
                     if (!appendEpisode(episodePath(cfg.daemon.stateDir, ep.name), ep))
                         log.warn({ job: j.id, name: ep.name }, "job episode not archived");
                 }
-                return { members: closed.members.length, killed, kept: victims.length - killed };
+                return { members: closed.members.length };
             };
             const rs = await [...cascade.map((c) => [c, `随上级单 ${id} 收工`]), [job, how === "cancel" ? `取消: ${(b.summary ?? "").toString()}` : (b.summary ?? "").toString()]]
                 // 根单收工: accept = G3 验收过闸 (人认可), cancel = 取消; 非根单没有闸。
                 .reduce(async (acc, [j, sum]) => [...(await acc), await closeOne(j, sum, j !== job ? undefined : how === "cancel" ? { end: "cancel" } : job.kind === "req" ? { gate: { g3: Date.now() }, end: "accept" } : undefined)], Promise.resolve([]));
-            const sum = (f) => rs.reduce((n, r) => n + f(r), 0);
-            json(res, 200, { ok: true, job: id, members: rs[rs.length - 1].members, recycled: sum((r) => r.killed), kept: sum((r) => r.kept), ...(cascade.length ? { cascaded: cascade.map((c) => c.id) } : {}) });
+            json(res, 200, { ok: true, job: id, members: rs[rs.length - 1].members, ...(cascade.length ? { cascaded: cascade.map((c) => c.id) } : {}) });
         });
         // 挂起事项全表 (见 pending-items.ts): 你派出去、还没了结的事。`drop` 显式消项;
         // `name` 看别人的 (只读)。读过全表就算刚给过一次: 自动的全表提醒从此刻重新计。
@@ -3268,7 +3498,7 @@ const main = async () => {
                 const reply = (m.replyToPeer(t, "", at, turn)?.text ?? "").trim();
                 if (reply && (await m.idleNow(t))) {
                     if (!isQuiet(reply))
-                        notifyChat(base, withTagHeader(t, reply));
+                        notifyChat(base, withTagHeader(t, reply, undefined, base));
                     log.info({ target: t, quiet: isQuiet(reply), len: reply.length }, "quiet task: 一轮结束");
                     quietRelays.drop(turn);
                     return;
@@ -3298,6 +3528,7 @@ const main = async () => {
             wizards.upsert(runner, {
                 description: `定时任务 ${taskId} 的一次性执行体${why}`,
                 parent: owner,
+                voiceOf: owner,
                 bornAt: Date.now(),
             });
             const runnerName = wizards.rename(runner, `${ownerName}-task-${taskId.slice(0, 4)}`);
@@ -3440,6 +3671,7 @@ const main = async () => {
         steward?.stop();
         tasks.stop();
         netWatch.stop();
+        await wx.stop().catch(() => undefined);
         // 同 POST /shutdown: 先把挂着的审批长轮询了结成「稍后续接」, 再关连接。
         log.info(drainForReload(), "pending drained for reload");
         // Hard-exit watchdog: http.close() blocks until every in-flight connection