wezard 2.4.0 → 2.5.0

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,13 +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";
@@ -53,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";
@@ -100,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 守护进程。
@@ -131,10 +171,13 @@ 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。
-    installInboundRouter(ws.client, cfg, log, { ...bridge, dispatch: async (a) => (await handedOff(a.principal), bridge.dispatch(a)) }, sourcePath);
+    // 宪章守卫 (见「改配置会不会动到宪章」): 要等下面宪章渲染那一块立起来才有; 之前 (启动时那次自动补名) 只写不比对。
+    let guardCharter = (write) => ({ r: write(), note: Promise.resolve("") });
+    installInboundRouter(ws.client, cfg, log, { ...bridge, dispatch: async (a) => (await handedOff(a.principal), bridge.dispatch(a)) }, sourcePath, (w, c) => guardCharter(w, c));
     // approval click → finalize 当前 liveStream, 后续 tool/text 落到 standalone。
     // 规则 2: 用户点击授权那一刻就是"上一段对话"的边界, 截断 stream 让授权后的
     // 工作单独成块, 比让 stream 一直长到下一个 inbound / hardTimer 更清晰。
@@ -187,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> 部分 → 不传
@@ -548,24 +610,31 @@ const main = async () => {
             const raw = (body.name ?? "").toString().trim();
             // "-" is the same erase gesture `/name -` uses in the chat — one verb,
             // one meaning, whether a human or an agent performs it.
+            // 聊天名进宪章: 过宪章守卫, 受影响的 wizard 被提醒 handoff, 调用方自己受影响的那段话放在 `charter`。
+            const byHuman = !!askerOf(self)?.who.startsWith("user:");
+            const charterOf = async (note) => ((t) => (t ? { charter: t } : {}))((await note).trim());
             if (raw === "-") {
-                const gone = clearChatName(cfg, sourcePath, self);
-                json(res, 200, { ok: true, base: baseOfKey(self), name: "", previous: gone });
+                const { r: gone, note } = guardCharter(() => clearChatName(cfg, sourcePath, self), (g) => g ? { what: `\`name_chat\` 取消了聊天名 \`${g}\``, self, byHuman } : undefined);
+                json(res, 200, { ok: true, base: baseOfKey(self), name: "", previous: gone, ...(await charterOf(note)) });
                 return;
             }
             const previous = chatNameOf(cfg, self);
-            const r = setChatName(cfg, sourcePath, self, raw);
+            const home = baseOfKey(self);
+            const { r, note } = guardCharter(() => {
+                const r = setChatName(cfg, sourcePath, self, raw);
+                if (!r.ok)
+                    return r;
+                // 默认 wizard 的名字取自聊天名; 它还叫旧聊天名 (没被单独改过) 就跟着改。
+                const cur = wizards.get(home)?.name ?? "";
+                return { ...r, wizardRenamed: previous && cur.toLowerCase() === previous.toLowerCase() ? wizards.rename(home, r.name) : undefined };
+            }, (r) => r.ok && r.name !== previous ? { what: `\`name_chat\` 把聊天${previous ? ` \`${previous}\`` : ""}改名为 \`${r.name}\``, self, byHuman } : undefined);
             if (!r.ok) {
                 json(res, 409, { ok: false, reason: r.reason });
                 return;
             }
-            // 默认 wizard 的名字取自聊天名; 它还叫旧聊天名 (没被单独改过) 就跟着改。
-            const home = baseOfKey(self);
-            const cur = wizards.get(home)?.name ?? "";
-            const wizardRenamed = previous && cur.toLowerCase() === previous.toLowerCase() ? wizards.rename(home, r.name) : undefined;
-            if (wizardRenamed)
+            if (r.wizardRenamed)
                 void m.retitlePane(home);
-            json(res, 200, { ok: true, base: r.base, name: r.name, previous, ...(wizardRenamed ? { wizardRenamed } : {}) });
+            json(res, 200, { ok: true, base: r.base, name: r.name, previous, ...(r.wizardRenamed ? { wizardRenamed: r.wizardRenamed } : {}), ...(await charterOf(note)) });
         });
         const readPeerBody = async (req) => {
             const body = (await readBody(req));
@@ -588,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
@@ -595,28 +668,43 @@ 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({
+            store: loadJsonMap("~/.wezard/top-only-nudge.json", gcNudge),
+            policy: () => ((p) => ({ windowMs: p.windowMin * 60_000, threshold: p.threshold, cooldownMs: p.cooldownH * 3_600_000 }))(cfg.wrc.mirror.topOnlyNudge),
+            nudge: (chat, n) => {
+                const p = cfg.wrc.mirror.topOnlyNudge;
+                notices.post([chat], renderNudge(policyKeyOf(chatNameOf(cfg, chat), chat), n, p.windowMin, p.cooldownH));
+                log.info({ chat, n }, "top-only nudge: 已提醒管家问人要不要开顶层模式");
+            },
+        });
         /** 公开的 wizard 间对话: 落在 `channel` 这个群。 */
         const relayPeer = (from, to, body, channel) => {
             const text = body.trim();
             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 会把正文首行
             // 当成头那一段的续行; 表格因此整张塌成一行带竖线的文字 (表格不能打断段落)。
             notifyChat(channel, `${head}\n\n${clipped}`);
+            if (!chatPolicyOf(cfg, channel).topOnly)
+                topOnlyNudge.count(baseOfKey(channel));
         };
         /** 调用方这一轮所在的公开频道: 人从哪个群叫的它 / 公开 peer 轮的那个群;
          *  私聊轮或无记录 → 它的 home 群。notify 与 public send_peer 默认发到这里。 */
@@ -633,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));
@@ -654,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),
@@ -873,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) {
@@ -897,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);
@@ -1043,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" } };
@@ -1061,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 就绕开了预算。
@@ -1075,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
@@ -1131,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 / 人 / 定时任务的活,
@@ -1169,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,
@@ -1187,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) {
@@ -1206,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` 是给调用方的判断依据: 立刻投给一个正在生成的会话, 这句话会排在
@@ -1321,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 换一个
@@ -1474,6 +1698,19 @@ const main = async () => {
         const notices = bindNoticeBox(createNoticeBox({
             probe: (t) => [...handoffNudge(t), ...memoryNudge(t)],
             digest: pendingDigest,
+            // 群况快照只给长住的 (没有 parent): 分身的协调人是生它的那位, 宪章里的出生快照够用。
+            // 表里是这个群的常驻面: 管家、长住有职责的、管家生的 (群里的执行者)、收件人自己生的;
+            // 再往下一层的 (分身的分身, 回归测试那批 rr-*) 不进表 —— 同名册变动 hears 的取舍。
+            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) => {
+                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)),
         }));
@@ -1501,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(" · ")}`);
@@ -1548,7 +1785,9 @@ const main = async () => {
                 .slice()
                 .sort((x, y) => y.targets.length - x.targets.length)
                 .map((c) => ({ base: c.base, cwd: chatCwd(c.targets) })));
-            const named = applyChatNames(cfg, sourcePath, plan);
+            if (!Object.keys(plan).length)
+                return {};
+            const { r: named } = guardCharter(() => applyChatNames(cfg, sourcePath, plan), (n) => Object.keys(n).length ? { what: `自动补的聊天名 (${Object.values(n).map((x) => `\`${x}\``).join(" ")})` } : undefined);
             for (const [base, name] of Object.entries(named)) {
                 log.info({ base, name }, "chat: auto-named from workspace");
                 // 群里不发气泡 (一次补名会命中十几个群, 那是刷屏), 但住在里面的 wizard
@@ -1702,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 抖了一下) 不等于注册表没了: 退回上一份好的,
@@ -1721,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,
         });
         /** 自己的地址 = 全局名字, 与住在哪个群无关。 */
@@ -1939,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;
@@ -1947,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);
             // 职责是别人决定"该不该找你"的依据, 改了就得让同群的知道 —— 否则他们照着
             // 出生快照里那句旧的 (或者空的) 职责派活。
@@ -1968,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);
@@ -1994,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,
@@ -2048,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 →
@@ -2075,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, 由它组队" }
@@ -2106,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 : "");
@@ -2123,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();
@@ -2148,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({
@@ -2243,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` 没有默认值 —— 继承与否是两种完全不同的分身 (一种开局就带着你
             // 读过的一切, 另一种白纸一张), 猜错了要么白烧一份上下文, 要么让它从零重读。
             // 逼调用方每次自己说。
@@ -2275,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);
@@ -2598,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) => {
@@ -2639,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); 空工单 (没人、没结论) 不记。
@@ -2663,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` 看别人的 (只读)。读过全表就算刚给过一次: 自动的全表提醒从此刻重新计。
@@ -2861,7 +3123,27 @@ const main = async () => {
             usageMemo = { at: Date.now(), u: { today: fold(r.today), week: fold(r.week) } };
             return usageMemo.u;
         };
-        const configEvidence = (p) => tierEvidence(cfg.models, p, tierUsage, (tier) => wizards.all().filter((w) => w.tier === tier).length, { tokens: fmtTokens, cost: fmtCost });
+        /** chatPolicy 的依据: 各聊天名 ↔ principal 与它此刻的顶层模式 —— 键落盘是 principal, 人和模型认的是名字。 */
+        const chatPolicyEvidence = (p) => {
+            if (p[0] !== "chatPolicy")
+                return [];
+            const named = listChatNames(cfg);
+            const line = (b) => `${named.filter((c) => c.base === b).map((c) => c.name).join(" / ") || "(未命名)"} = ${b} · 顶层模式 ${chatPolicyOf(cfg, b).topOnly ? "开" : "关"}`;
+            // 查某一个聊天: 只报它; 查整张表: 报写过策略的, 其余命名聊天只报个数。
+            if (p[1])
+                return [line(p[1])];
+            const set = Object.keys(cfg.chatPolicy);
+            const rest = named.filter((c) => !set.includes(c.base)).length;
+            return [
+                "键写聊天名或 principal 都行, 落盘换成 principal:",
+                ...set.map(line),
+                ...(rest ? [`其余 ${rest} 个已命名聊天没写, 按默认 (顶层模式关) —— 查某个: config_get({path:"chatPolicy.<聊天名>"})`] : []),
+            ];
+        };
+        const configEvidence = (p) => [
+            ...tierEvidence(cfg.models, p, tierUsage, (tier) => wizards.all().filter((w) => w.tier === tier).length, { tokens: fmtTokens, cost: fmtCost }),
+            ...chatPolicyEvidence(p),
+        ];
         // ── 改配置会不会动到宪章 ─────────────────────────────────────────
         // 宪章是 --append-system-prompt 压进去的, 随进程终身: 改了进宪章的配置, 已在跑的 wizard
         // 看不见, 要 handoff 重开 (重新渲染宪章) 才换上。不按字段清单判 —— 宪章读哪些配置随代码变,
@@ -2871,17 +3153,19 @@ const main = async () => {
             const x = charterSections(a), y = charterSections(b);
             return [...new Set([...x.keys(), ...y.keys()])].filter((k) => x.get(k) !== y.get(k));
         };
-        /** pane 活着的 wizard —— 宪章在效的只有它们; 冷的醒来时宪章重渲染, 自然是新的。一次 list-panes 答完。 */
-        const liveWizards = async () => {
+        /** 宪章挂在 pane 上的 wizard —— 候选。同步取: 守卫要在写之前拍快照, 中间不能 await。 */
+        const attachedWizards = () => wizards.all().map((w) => w.target).filter((t) => !!m.sessionInfo(t)?.tmuxPane);
+        /** 其中 pane 活着的 —— 宪章在效的只有它们; 冷的醒来时宪章重渲染, 自然是新的。一次 list-panes 答完。 */
+        const liveOf = async (targets) => {
             const snap = await runTmux(["list-panes", "-a", "-F", "#{pane_id}"]);
             const live = new Set(snap.ok ? snap.stdout.split("\n").map((l) => l.trim()).filter(Boolean) : []);
-            return wizards.all().map((w) => w.target).filter((t) => live.has(m.sessionInfo(t)?.tmuxPane ?? ""));
+            return targets.filter((t) => live.has(m.sessionInfo(t)?.tmuxPane ?? ""));
         };
         /** 这些 wizard 此刻的宪章正文。 */
         const charterSnapshot = (targets) => new Map(targets.map((t) => [t, charterText(t, charterOptsOf(t, m.getCwd(t).runningCwd || undefined), true)]));
         /** 把 `next` 那一节换进活的 cfg 渲染一遍再换回 —— 同步完成, 中间没有 await, 别的模块看不见这一瞬。
          *  reload 项落盘后活值不变, 只有这样才算得出它 reload 之后的宪章。 */
-        const charterUnder = (pl, targets) => {
+        const charterUnder = (pl) => (targets) => {
             const live = cfg;
             const key = pl.path[0];
             const saved = live[key];
@@ -2893,26 +3177,48 @@ const main = async () => {
                 live[key] = saved;
             }
         };
-        const charterImpact = (before, pl) => {
-            const after = charterUnder(pl, [...before.keys()]);
-            return [...before].flatMap(([t, a]) => { const secs = changedSections(a, after.get(t) ?? a); return secs.length ? [{ target: t, sections: secs }] : []; });
-        };
-        /** 受影响的 wizard 各挂一条提醒 (随它下一条消息到); 给调用方的那段话。调用方自己受影响就直说要它 handoff。 */
-        const announceCharterImpact = (pl, hits, self) => {
+        const charterImpact = (before, after) => [...before].flatMap(([t, a]) => { const secs = changedSections(a, after.get(t) ?? a); return secs.length ? [{ target: t, sections: secs }] : []; });
+        /** 受影响的 wizard 各挂一条提醒 (随它下一条消息到); 给调用方的那段话。调用方自己受影响就直说要它 handoff。
+         *  人发起的改动多一句「交接之前还是旧规矩」: 管家要知道它此刻向人汇报的方式还没变, 别让人以为已经生效。 */
+        const announceCharterImpact = (c, hits) => {
             if (!hits.length)
                 return "";
-            const when = pl.apply === "reload" ? "等守护进程 reload 之后再" : "";
-            const ask = `${when}调 \`handoff({brief})\` 原地重开 (手上这件告一段落就交; 宪章在 handoff 时重新生成)`;
-            const others = hits.filter((h) => h.target !== self);
-            others.forEach((h) => notices.post([h.target], `\`config_set ${pl.path.join(".")}\` 改动了你的宪章 (系统提示, 变了的段: ${h.sections.join(" / ")}); 已在跑的你看不见新规矩 —— ${ask}`));
-            const mine = hits.find((h) => h.target === self);
+            const ask = `${c.reload ? "等守护进程 reload 之后再" : ""}调 \`handoff({brief})\` 原地重开 (手上这件告一段落就交; 宪章在 handoff 时重新生成)`;
+            const lag = (t) => !c.byHuman ? "" : tagOfKey(t)
+                ? " —— 这是人发起的改动: 交接之前你仍按旧规矩做事, handoff 之后才按新的"
+                : " —— 这是人发起的改动: 交接之前你仍按旧规矩向人汇报, handoff 之后才会按新规矩汇报; 回人时说一句「交接后生效」";
+            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 才换上。受影响 ${hits.length} 个: ${hits.map((h) => displayName(h.target)).join(" ")}`,
                 ...(others.length ? [`已给其余 ${others.length} 个各挂一条提醒 (随它们下一条消息到), 让它们${ask}`] : []),
-                ...(mine ? [`**你自己也在其中** (变了的段: ${mine.sections.join(" / ")}): 这一轮收尾后${ask}`] : []),
+                ...(mine ? [`**你自己也在其中** (变了的段: ${mine.sections.join(" / ")}): 这一轮收尾后${ask}${lag(mine.target)}`] : []),
             ].join("\n");
         };
+        // 所有会动宪章的写入 (config_set、人 `/name`、name_chat、自动补名) 共用这一个守卫: 写前写后各渲染一遍
+        // 挂在 pane 上的 wizard 的宪章, 变了的、pane 还活着的挂提醒。快照到写完之间不能有 await —— 别人的写入
+        // 插进来, 前后就对不上了。已经写了: 比对失败只少一句提醒, 不能让调用方以为没写而重发。
+        guardCharter = (write, change) => {
+            const targets = attachedWizards();
+            const before = charterSnapshot(targets);
+            const r = write();
+            const c = change(r);
+            if (!c)
+                return { r, note: Promise.resolve("") };
+            const fail = (e) => {
+                log.warn({ err: errText(e), what: c.what }, "宪章影响比对失败");
+                return `\n(宪章影响没比对出来: ${errText(e)} —— 改的若是进宪章的内容, 受影响的 wizard 要 handoff 才换上)`;
+            };
+            try {
+                const hits = charterImpact(before, (c.after ?? charterSnapshot)(targets));
+                return { r, note: liveOf(hits.map((h) => h.target)).then((live) => announceCharterImpact(c, hits.filter((h) => live.includes(h.target)))).catch(fail) };
+            }
+            catch (e) {
+                return { r, note: Promise.resolve(fail(e)) };
+            }
+        };
         // POST /config/get —— 新 MCP 带 `path` (可空) 拿渲染好的文本; 老 MCP 带 `key` 拿 {key, value}。
         http.register("POST /config/get", async (req, res) => {
             const body = (await readBody(req));
@@ -2921,7 +3227,10 @@ const main = async () => {
                 json(res, r.ok ? 200 : 400, r);
                 return;
             }
-            const r = configGet(cfg, sourcePath, body.path, configEvidence);
+            // chatPolicy.<聊天名>… 换成它指向的 principal 再查 (同 config_set 的 pinChatKeys); 认不出的原样查。
+            const p = parsePath(body.path);
+            const base = p[0] === "chatPolicy" && p[1] ? chatBaseOf(cfg, p[1]) : "";
+            const r = configGet(cfg, sourcePath, base ? ["chatPolicy", base, ...p.slice(2)].join(".") : body.path, configEvidence);
             json(res, r.ok ? 200 : 400, r);
         });
         // chatPolicy 的键一律落成 base principal: 聊天名会改, 拿它当键一改名策略就悄悄失效。写名字照收,
@@ -2974,26 +3283,21 @@ const main = async () => {
                 return;
             }
             // 落盘时重算一遍: 等卡期间文件可能被别人改过, 按那一刻的文件打补丁、再校验。
-            // 宪章快照取在落盘之前: hot 项一 applyHot, 活的 cfg 就已经是新的了。
+            // 宪章快照取在落盘之前 (守卫里): hot 项一 applyHot, 活的 cfg 就已经是新的了。
             // 不用 resolveSelf: 它最后回落到 defaultChat, 会把认不出的调用方当成那个群的管家。
             const caller = (body.sessionId?.trim() && m.targetForSession(body.sessionId.trim())) || (body.tmuxPane?.trim() && m.targetForPane(body.tmuxPane.trim())) || undefined;
+            // 人发起 = 调用方这一轮的链头是人 (人在群里 / 单聊里叫它改的)。
+            const byHuman = !!caller && !!askerOf(caller)?.who.startsWith("user:");
             const commit = async () => {
-                const targets = await liveWizards();
-                // 从这里到 applyHot 之间不能有 await: 快照与落盘之间别人的 config_set 插进来, 前后就对不上了。
-                const now = planSet(cfg, sourcePath, ask);
-                if (!now.ok)
+                const { r: now, note } = guardCharter(() => {
+                    const now = planSet(cfg, sourcePath, ask);
+                    if (!now.ok)
+                        return now;
+                    patchJsonc(sourcePath, [{ path: now.jsonPath, value: now.value }]);
+                    applyHot(cfg, now);
                     return now;
-                const before = charterSnapshot(targets);
-                patchJsonc(sourcePath, [{ path: now.jsonPath, value: now.value }]);
-                applyHot(cfg, now);
-                // 已经落盘了: 比对失败只少一句提醒, 不能让调用方以为没写而重发。
-                try {
-                    return { ...now, charter: announceCharterImpact(now, charterImpact(before, now), caller) };
-                }
-                catch (e) {
-                    log.warn({ err: errText(e), path: now.path.join(".") }, "config_set: 宪章影响比对失败");
-                    return { ...now, charter: `\n(宪章影响没比对出来: ${errText(e)} —— 改的若是进宪章的配置, 受影响的 wizard 要 handoff 才换上)` };
-                }
+                }, (now) => now.ok ? { what: `\`config_set ${now.path.join(".")}\``, self: caller, byHuman, reload: now.apply === "reload", after: charterUnder(now) } : undefined);
+                return now.ok ? { ...now, charter: await note } : now;
             };
             const done = (now) => `已写入${now.apply === "hot" ? ", 已生效" : "; 需 reload (`./cli/wezard.sh reload`) 才生效"}:\n${renderPlan(now)}${now.charter}`;
             if (pl.gate !== "card") {
@@ -3194,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;
@@ -3224,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)}`);
@@ -3366,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