wezard 2.2.1 → 2.3.0

package/dist/daemon/index.js

@@ -1,8 +1,15 @@
 // Daemon entry. Resident process — exits only on signal or fatal WS auth failure.
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { timingSafeEqual } from "node:crypto";
+import { loadOrCreateSvrToken } from "../shared/svr-token.js";
+import { DAEMON_TOKEN_FILE, DAEMON_TOKEN_HEADER } from "../shared/daemon-token.js";
 import { homedir } from "node:os";
 import { loadConfig } from "../shared/config.js";
 import { makeLogger } from "../shared/log.js";
-import { bindCliBackends } from "../shared/cli-backends.js";
+import { clipLine, sleep } from "../shared/std.js";
+import { EFFORTS, parseEffort } from "../shared/effort.js";
+import { bindCliBackends, projectDirsFor } from "../shared/cli-backends.js";
 import { startWs } from "./ws.js";
 import { startNetWatch } from "./net-watch.js";
 import { startHttp, json, readBody } from "./http.js";
@@ -10,37 +17,39 @@ import { configGet, configSet } from "./config-api.js";
 import { installInboundRouter } from "./inbound.js";
 import { loadMirrorStore } from "./mirror-store.js";
 import { startMirror, installMirrorEventListener } from "./mirror-bridge.js";
-import { setTmuxTimeoutReporter, spawnTmuxClaude } from "./spawn-tmux.js";
+import { runTmux, setTmuxTimeoutReporter, spawnTmuxClaude } from "./spawn-tmux.js";
 import { installApprovalEventListener, makeApproveHandler } from "./approval.js";
-import { initDetailPersistence, makeDetailHandler, chatHandlers, configureRemoteForward, chatUrlFor, setWorldFactsProvider, recordPost } from "./detail.js";
+import { initDetailPersistence, makeDetailHandler, chatHandlers, configureRemoteForward, chatUrlFor, setWorldFactsProvider, recordPost, recordCharter, backfillCharter } from "./detail.js";
 import { EMPTY_FACTS } from "../shared/world.js";
-import { initAutoWindowPersistence } from "./session-cache.js";
+import { clearAutoWindow, initAutoWindowPersistence, setAutoWindow } from "./session-cache.js";
 import { makeMessageHandler } from "./outbound.js";
 import { makeCardHandler, makeAskHandler, installAskEventListener } from "./ask.js";
 import { drainForReload, listPending } from "./pending.js";
 import { makeClaimStartHandler, makeClaimStatusHandler, makeClaimResetHandler, } from "./claim.js";
 import { makeWedocBridge } from "./wedoc.js";
-import { installResponseTracker } from "./last-response.js";
+import { errText, installResponseTracker } from "./last-response.js";
 import { scanClaudeSessions } from "./session-scan.js";
-import { startScheduler, migrateLegacySchedules, promptWantsFreshWizard, renderTask, sinceOf, } from "./tasks.js";
+import { startScheduler, migrateLegacySchedules, promptWantsFreshWizard, renderTask, sinceOf, TASK_POSTPONE_MS, TASK_QUIET_WAIT_MS, } from "./tasks.js";
 import { openTaskRegistry } from "./task-registry.js";
 import { describeTrigger, nextFire, parseTrigger, WHEN_HELP } from "../shared/trigger.js";
-import { slugify, uniqueId } from "../shared/task-file.js";
-import { baseOfKey, bindTagLinker, keyOf, linkTags, normalizeTag, tagFromCwd, tagHead, tagLink, tagOfKey, uniqueTag, withTagHeader } from "../shared/session-label.js";
-import { clipForCharter, inboxPath, memoryPath, memoryRoot, proposeMemory, readMemory } from "./wizard-memory.js";
-import { ensureStewardTask } from "./memory-steward.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 { 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, clearChatName, listChatNames, normChatName, peerAddress, planChatNames, setChatName } from "./chat-name.js";
-import { bindWizardStore, loadWizardStore, wizardStore, settleName, settleAll, evictStaleName, childrenOf, ancestorsOf, renderCharter, renderRoster, CONTEXT_FULL_TOKENS, } from "./wizard.js";
+import { bindWizardStore, loadWizardStore, wizardStore, settleName, settleAll, backfillBorn, sweepUnborn, BOOT_ID, evictStaleName, childrenOf, ancestorsOf, renderCharter, ROSTER_FRESH_MS, renderRoster, handoffAt, memoryNudgeAt, MEMORY_NUDGE_FLOOR, MEMORY_MAX, NOTE_MAX, } from "./wizard.js";
 import { bindNoticeBox, createNoticeBox, chatAudience } from "./notices.js";
-import { loadJobStore, renderJobOpen, renderJobClose, JOB_MEMBER_MAX } from "./jobs.js";
-import { clipMiddle, contextFiles, extractResult, lastContextTokens, lastExchange, lastModel, replyClosedBefore, talkTurns, renderPeerEnvelope, renderReceiptEnvelope, renderTaskEnvelope } from "./peers.js";
+import { loadJobStore, jobEpisode, rejectReason, ACCEPTS, JOB_MEMBER_MAX } from "./jobs.js";
+import { cacheTtlSec, clipMiddle, contextFiles, firstStamp, parseClosing, lastContextTokens, lastExchange, lastModel, openingOf, replyClosedBefore, talkTurns, renderPeerEnvelope, renderReceiptEnvelope, renderTaskEnvelope } from "./peers.js";
 import { keepalivePingSigs } from "../shared/keepalive.js";
 import { expandHome } from "../shared/paths.js";
 import { loadJsonMap } from "../shared/json-map-store.js";
-import { createReceipts } from "./receipts.js";
+import { createReceipts, deadlineOf, kAttr, newTurn } from "./receipts.js";
+import { renderInFlight } from "../shared/turn-state.js";
 import { createHandoffs, handedOff, handingOff } from "./handoff.js";
-import { rankCandidates, renderCandidates } from "./route.js";
-import { parseWhen, renderChatLog } from "./chat-log.js";
+import { rankCandidates, renderCandidates, 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";
 // pino's file transport is async; without flush, log.fatal before process.exit
 // vanishes. Mirror anything fatal to stderr too so launchd's stderr.log captures it.
@@ -59,6 +68,9 @@ const main = async () => {
     log.info({ sourcePath, pid: process.pid }, "daemon start");
     // 定时调度器的 `inject` 真正实现, 赋值在 mirror-mode 的大块里 (要用到那里面的
     // wizards / m / notifyChat), 但 startScheduler 在那块外面接线 —— 见文件尾。
+    // 记忆整理者的执行体, 同样只有 mirror 模式给得出 —— 赋值见 scheduledTaskInject 旁边。
+    let stewardRun;
+    let stewardWiring = {};
     let scheduledTaskInject;
     // Bind the CLI backend registry. `primary` (= defaultCli) drives new-session
     // spawns; `backends` is every installed CLI whose transcript root exists, so
@@ -90,12 +102,15 @@ const main = async () => {
     const mirrorStore = loadMirrorStore(cfg.wrc.mirror.attachmentsFile);
     // 定时任务表 —— 每条任务是 ~/.wezard/tasks/<id>.task.mjs 一份可注入代码的配置
     // (见 shared/task-file.ts)。目录是热加载的: wizard 改完文件不用 reload 守护进程。
-    // 共享记忆的整理者是一条定时任务 (memory-steward.ts), 缺了就补一份默认的。
+    // 共享记忆的整理者改成了 daemon 内建定时器 (memory-steward.ts); 老版本写下的那条
+    // 定时任务要在任务表加载前停用, 否则两路并跑。
     try {
-        ensureStewardTask(memoryRoot(cfg.daemon.stateDir));
+        const retired = retireStewardTask();
+        if (retired)
+            log.info({ retired }, "memory steward task file retired");
     }
     catch (e) {
-        log.warn({ err: e.message }, "memory steward task not written");
+        log.warn({ err: e.message }, "memory steward task not retired");
     }
     const tasks = await openTaskRegistry(log.child({ mod: "tasks" }), (added, removed) => log.info({ added, removed }, "task files changed"));
     const bridge = startMirror({ cfg, log: log.child({ mod: "mirror" }), client: ws.client, store: mirrorStore });
@@ -145,9 +160,23 @@ const main = async () => {
     http.register("POST /message", makeMessageHandler(ws.client, log.child({ mod: "outbound" })));
     http.register("POST /card", makeCardHandler(ws.client, log.child({ mod: "outbound" })));
     http.register("POST /ask", makeAskHandler(ws.client, log.child({ mod: "ask" })));
-    http.register("POST /claim/start", makeClaimStartHandler({ log: log.child({ mod: "claim" }) }));
+    // 写敏感状态的路由只认出示口令的 —— wezard 的 MCP server 与 CLI 读得到 0600 的口令文件
+    // (见 shared/daemon-token.ts), 本机别的进程 curl 不进来: 写配置、改 allowFrom 的认领
+    // 口令、落一份 daemon 会执行其 gate 的任务文件, 都不该是谁连上 127.0.0.1 就能做的。
+    const daemonToken = loadOrCreateSvrToken(DAEMON_TOKEN_FILE);
+    const tokenOk = (req) => {
+        const got = Buffer.from(String(req.headers[DAEMON_TOKEN_HEADER] ?? ""));
+        const want = Buffer.from(daemonToken);
+        return got.length === want.length && timingSafeEqual(got, want);
+    };
+    const guarded = (h) => async (req, res, url, ctx) => {
+        if (tokenOk(req))
+            return h(req, res, url, ctx);
+        json(res, 403, { ok: false, reason: `这条路由要出示 ${DAEMON_TOKEN_FILE} 里的口令 (header ${DAEMON_TOKEN_HEADER}); 正在跑的 wizard 若是旧版 MCP 进程, 重开会话即可` });
+    };
+    http.register("POST /claim/start", guarded(makeClaimStartHandler({ log: log.child({ mod: "claim" }) })));
     http.register("GET /claim/status", makeClaimStatusHandler());
-    http.register("POST /claim/reset", makeClaimResetHandler());
+    http.register("POST /claim/reset", guarded(makeClaimResetHandler()));
     http.register("GET /detail", makeDetailHandler(log.child({ mod: "detail" })));
     for (const [key, handler] of Object.entries(chatHandlers()))
         http.register(key, handler);
@@ -532,6 +561,8 @@ const main = async () => {
             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)
+                void m.retitlePane(home);
             json(res, 200, { ok: true, base: r.base, name: r.name, previous, ...(wizardRenamed ? { wizardRenamed } : {}) });
         });
         const readPeerBody = async (req) => {
@@ -559,7 +590,7 @@ const main = async () => {
             const chatId = chatIdOf(base);
             void ws.client
                 .sendMessage(chatId, { msgtype: "markdown", markdown: { content: linkTags(base, markdown) } })
-                .catch((e) => log.warn({ err: e.message }, "chat notify failed"));
+                .catch((e) => log.warn({ chatId, err: errText(e) }, "chat notify failed"));
         };
         // wizard 在群里的称呼, 只用在**正文**里。气泡的头照旧交给 withTagHeader ——
         // 那一段是路由信息 (`emoji #tag`), parseTagHeader 靠它反解, 群里引用一条气泡
@@ -589,13 +620,30 @@ const main = async () => {
          *  私聊轮或无记录 → 它的 home 群。notify 与 public send_peer 默认发到这里。 */
         const channelOf = (self) => m.currentChannel(self) || baseOfKey(self);
         /** 同伴注入的信封: 公开轮写上那个群的名字, 私聊不写 (见 peers.renderPeerEnvelope)。 */
-        const envelopeFor = (from, channel) => renderPeerEnvelope(displayName(from), channel ? chatNameOf(cfg, channel) : undefined);
+        const envelopeFor = (from, channel, t) => renderPeerEnvelope(displayName(from), channel ? chatNameOf(cfg, channel) : undefined, t);
         // 回执 (见 receipts.ts): 一次 tell_peer 之后对方干完那一轮, 它的结论自动 paste
         // 回发话方的输入框, 发话方全程不阻塞。这里只提供四样能力给那个模块 —— 忙闲、
         // 死活、「它答我那一句的是哪段话」、以及怎么把一段话送进去 —— 投递逻辑在那边。
+        // 工单账本 (见 jobs.ts)。只在**显式传了 `job`** 时起作用 —— 不用工单的调用方
+        // 行为与从前一模一样。回执要数它的成员, 所以先于回执载入。
+        const jobs = loadJobStore(cfg.wrc.mirror.jobsFile);
+        /** 回执那一轮在群里的终句答给谁 (userid) —— 与 rolepage 同一个判定, 写进信封给模型与
+         *  read_chat; 认不出 = ""。 */
+        const audienceName = (channel, asker) => {
+            const id = audienceOf(channel, asker);
+            return id === "human:" ? "" : id.slice("human:".length);
+        };
         const receipts = createReceipts({
-            isBusy: m.isBusy,
             idleNow: m.idleNow,
+            jobTally: (id) => jobs.tally(id),
+            parkedNow: m.parkedNow,
+            settleJob: (id, target, outcome, artifacts) => { jobs.settle(id, target, outcome, artifacts); },
+            accept: (id, body) => { const j = jobs.get(id); return j?.status === "open" ? rejectReason(j.accept ?? "result", parseClosing(body)) : undefined; },
+            rebound: async (x, why) => (await m.injectText(x.to, `（守护进程代 ${displayName(x.from)} 打回一次: 这件活是工单里的一份, 你的回复${why}。请按约定收口 —— 末尾一行 \`RESULT: <结论>\`, 交付了文件每个加一行 \`ARTIFACT: <路径> — 一句话\`; 真缺信息就 \`NEED: <问题>\`。）`, undefined, {
+                from: { kind: "peer", from: x.from, turn: x.turn, ...(x.asker ? { asker: x.asker } : {}) },
+                channel: x.channel,
+                envelope: envelopeFor(x.from, x.channel, { turn: x.turn, legs: x.legs, re: true }),
+            })).ok,
             untilIdle: m.untilIdle,
             paneLive: m.paneLive,
             nameOf: displayName,
@@ -603,22 +651,29 @@ const main = async () => {
             store: loadJsonMap(cfg.wrc.mirror.receiptsFile),
             handingOff,
             handedOff,
-            // 信封锚取不到 (对方是个还不挂信封的老 wizard) 时退回按时刻取, 由 receipts
-            // 区分这两种"没有"。
-            replyFor: (to, fromName, since) => m.replyToPeer(to, fromName, since),
+            replyFor: (to, fromName, since, turn) => m.replyToPeer(to, fromName, since, turn),
+            lastWords: m.lastReply,
             deliver: (to, bodyText, meta) => m.injectText(to, clipMiddle(bodyText), undefined, {
                 // receipt:true 是「这一轮不该再生回执」的记录 —— 回环在结构上就不成立:
                 // 只有 tell_peer 那条路登记 watcher, 这里是直接注入。
-                from: { kind: "peer", from: meta.from, receipt: true, ...(meta.job ? { job: meta.job } : {}) },
+                from: { kind: "peer", from: meta.from, receipt: true, status: meta.status, ...(meta.turn ? { turn: meta.turn } : {}), ...(meta.job ? { job: meta.job, done: meta.done, total: meta.total } : {}), ...(meta.asker ? { asker: meta.asker } : {}) },
                 channel: meta.channel,
-                envelope: renderReceiptEnvelope(displayName(meta.from), meta.channel ? chatNameOf(cfg, meta.channel) : undefined, meta.job ? { job: meta.job, done: meta.done, total: meta.total } : undefined),
+                envelope: renderReceiptEnvelope(displayName(meta.from), meta.channel ? chatNameOf(cfg, meta.channel) : undefined, meta.job ? { job: meta.job, done: meta.done, total: meta.total, closed: jobs.get(meta.job)?.status !== "open" } : undefined, meta.status, meta.turn || undefined, {
+                    ...(meta.replyTo ? { replyTo: meta.replyTo.kind === "chat" ? chatNameOf(cfg, meta.replyTo.channel) : displayName(meta.replyTo.from) } : {}),
+                    ...(meta.k ? { k: kAttr(meta.k) } : {}),
+                    ...(meta.pending ? { pending: meta.pending } : {}),
+                    ...(audienceName(meta.channel, meta.asker) ? { audience: audienceName(meta.channel, meta.asker) } : {}),
+                }),
             }),
         });
+        const turnsLine = (xs, target) => renderInFlight(xs, target, displayName);
         // reload 前在飞的回执: 等 mirror 把绑定都恢复了再续守 —— 早一步读 target 会拿不到
         // transcript, 退回按时刻取就可能把上一件事的结论当回执。
         // 交接 (见 handoff.ts): 换会话不换身份。这里给它重开、贴话、读旧 transcript 的能力,
         // 闸、回执清点与断点续做在那边。
         const pingSigs = keepalivePingSigs(cfg.wrc.mirror.keepalive.ping);
+        /** 情景记忆 (memory/episodes/<name>.jsonl) 按名字归档; 默认会话没名字时退回 slot / "default"。 */
+        const episodeName = (t) => wizards.get(t)?.name || tagOfKey(t) || "default";
         const handoffs = createHandoffs({
             isBusy: m.isBusy,
             sessionId: (t) => m.sessionInfo(t)?.sessionId ?? "",
@@ -627,15 +682,15 @@ const main = async () => {
             // 频道也接回原来那一句所在的地方 (私聊不进群)。
             inject: (t, text, owe) => owe.length
                 ? m.injectText(t, text, undefined, {
-                    from: { kind: "peer", from: owe[0].from },
+                    from: { kind: "peer", from: owe[0].from, ...(owe[0].turn ? { turn: owe[0].turn } : {}), ...(owe[0].asker ? { asker: owe[0].asker } : {}) },
                     channel: owe[0].channel,
-                    envelope: owe.map((o) => envelopeFor(o.from, o.channel)).join(""),
+                    envelope: owe.map((o) => envelopeFor(o.from, o.channel, o.turn ? { turn: o.turn } : undefined)).join(""),
                 })
                 : m.injectText(t, text),
             lastText: m.lastText,
-            answeredBefore: (to, from, since, until) => {
+            answeredBefore: (to, from, since, until, turn) => {
                 const p = m.sessionInfo(to)?.jsonlPath;
-                return p ? replyClosedBefore(expandHome(p), displayName(from), since, until, pingSigs) : undefined;
+                return p ? replyClosedBefore(expandHome(p), displayName(from), since, until, pingSigs, turn) : undefined;
             },
             receipts,
             // 交接是生命周期事件, 不进群; 失败只捎给它自己 (它调完 handoff_self 拿到的是
@@ -643,7 +698,66 @@ const main = async () => {
             notify: (t, text) => notices.post([t], text),
             log,
             store: loadJsonMap(cfg.wrc.mirror.handoffsFile),
+            archive: (e) => {
+                if (!e.brief.trim())
+                    return;
+                const name = episodeName(e.target);
+                const ok = appendEpisode(episodePath(cfg.daemon.stateDir, name), { at: e.at, kind: "handoff", name, sid: e.sid, nextSid: e.nextSid, text: e.brief });
+                if (!ok)
+                    log.warn({ target: e.target, name }, "handoff episode not archived");
+            },
         });
+        /** `self` 此刻这一轮派出去的活, 结论该交给谁 (见 receipts.parentOf)。只读它自己
+         *  transcript 里开这一轮的那句 user 行的信封: attachment 上的 channel 在注入时就被
+         *  排队的下一句改写了, transcript 才记着「这一轮是谁发起的」, reload 后也读得到。 */
+        /** `target` 手上这一轮是哪件 peer 活 —— 认开头那句的信封: 有件号按件号, 老信封按发话方。 */
+        /** `target` 手上这一轮若是某个 wizard 派来的活: 发话方的称呼 (`.x`) 与件号。人 / 定时 / 回执轮 = undefined。 */
+        const openingAsk = (target) => {
+            const p = m.sessionInfo(target)?.jsonlPath;
+            const env = p ? openingOf(talkTurns(expandHome(p), 80, pingSigs, false, true))?.env : undefined;
+            return env?.kind === "peer" && !env.receipt ? { from: env.from, ...(env.turn ? { turn: env.turn } : {}) } : undefined;
+        };
+        const currentAsk = (target) => {
+            const env = openingAsk(target);
+            if (!env)
+                return () => false;
+            return (x) => (env.turn ? x.turn === env.turn : displayName(x.from) === env.from);
+        };
+        /** 打断 `target` 会不会误伤别人的活: 它正忙, 且这一轮不是调用方派的 —— 别的 wizard 派的、
+         *  人说的、定时任务放的 → 那一方的称呼。回执轮是它自己那件活的延续, 不算别人的。 */
+        const othersTurn = async (target, self) => {
+            if (await m.idleNow(target))
+                return undefined;
+            const p = m.sessionInfo(target)?.jsonlPath;
+            const env = p ? openingOf(talkTurns(expandHome(p), 80, pingSigs, false, true))?.env : undefined;
+            if (env?.receipt)
+                return undefined;
+            if (env?.kind === "peer")
+                return env.from === displayName(self) ? undefined : { from: env.from, ...(env.turn ? { turn: env.turn } : {}) };
+            return { from: env?.kind === "task" ? env.from : env?.from ? `人 (${env.from})` : "人" };
+        };
+        const openingOfSelf = (self) => {
+            const p = m.sessionInfo(self)?.jsonlPath;
+            return p ? openingOf(talkTurns(expandHome(p), 80, pingSigs, false, true)) : undefined;
+        };
+        const parentKOf = (self) => {
+            const opening = openingOfSelf(self);
+            return receipts.parentOf(self, opening?.env, channelOf(self), String(opening?.ms ?? 0));
+        };
+        /** `self` 此刻这一轮的链头 (见 Asker), 同样认开头那句的信封: 人在群里说的 → 信封上的
+         *  userid 与群; 与人的单聊里没挂信封 → 那个人; 同伴派的活 / 回执 → 登记那件活时记下的;
+         *  定时任务、CLI 敲字、认不出 → undefined (如实不知道, 不猜)。 */
+        const askerOf = (self) => {
+            const env = openingOfSelf(self)?.env;
+            const home = baseOfKey(self);
+            if (!env)
+                return home.startsWith("user:") ? { who: home, chat: home } : undefined;
+            if (env.kind === "human") {
+                const chat = env.chat ? chatBaseOf(cfg, env.chat) : home;
+                return chat ? { who: `user:${env.from}`, chat } : undefined;
+            }
+            return env.kind === "peer" ? receipts.askerOf(self, env) : undefined;
+        };
         // 交接先续做: 它的闸要在回执续守之前立起来, 否则续守的 watcher 会读到换了一半的会话。
         void m.restored.then(() => { handoffs.resume(); receipts.resume(); });
         /** 入参里的地址: 新字段 `name`, 老 MCP 进程 (正在跑的 wizard) 仍在传 `tag`。 */
@@ -728,13 +842,14 @@ const main = async () => {
             const refs = (b.to ?? []).map((r) => (r ?? "").trim()).filter(Boolean);
             const bad = refs.filter((r) => !chatBaseOf(cfg, r));
             if (bad.length) {
-                json(res, 400, { ok: false, reason: `认不出这些聊天: ${bad.join(", ")} (list_chats 看有哪些; 没起名的聊天寻址不到)` });
+                json(res, 400, { ok: false, reason: `认不出这些聊天: ${bad.join(", ")} (wizard_roster 每行有 home 聊天名, 人侧 /chats; 没起名的聊天寻址不到)` });
                 return;
             }
             const dests = [...new Set(refs.length ? refs.map((r) => chatBaseOf(cfg, r)) : [channelOf(self)])];
+            const asker = askerOf(self);
             for (const dest of dests) {
                 notifyChat(dest, `${relayLabel(self)}\n\n${content}`);
-                recordPost({ target: self, channel: dest, body: content });
+                recordPost({ target: self, channel: dest, body: content, ...(asker ? { asker } : {}) });
             }
             json(res, 200, { ok: true, sent: dests.map((d) => chatNameOf(cfg, d) || d) });
         });
@@ -755,6 +870,7 @@ const main = async () => {
             // 截断的视口加一层 TUI 装饰, 而「它卡在哪」transcript 答得更准 —— 不在转圈
             // 却悬着工具调用, 就是停在审批卡 / 本地弹窗上等人点。
             const peek = await m.peekTurns(target, turns);
+            const inflight = turnsLine(receipts.states(), target);
             const waiting = peek.waiting ?? [];
             const state = peek.busy
                 ? "正在生成"
@@ -766,7 +882,7 @@ const main = async () => {
                 name: peerAddress(cfg, self, target),
                 busy: peek.busy ?? false,
                 ...(waiting.length ? { waiting } : {}),
-                text: [`${displayName(target)} · ${state}${foreign ? ` · 住在群 ${chatNameOf(cfg, target) || "(未命名)"}` : ""}`, peek.dialog ?? `(${peek.reason})`].join("\n"),
+                text: [`${displayName(target)} · ${state}${foreign ? ` · 住在群 ${chatNameOf(cfg, target) || "(未命名)"}` : ""}`, ...(inflight ? [inflight] : []), peek.dialog ?? `(${peek.reason})`].join("\n"),
             });
         });
         // ── 聊天记录 ────────────────────────────────────────────────────────
@@ -785,7 +901,7 @@ const main = async () => {
                 name: displayName(t.target),
                 jsonlPath: t.jsonlPath,
                 homeChat: chatNameOf(cfg, home),
-                homeHuman: home.startsWith("user:") ? home.slice(5) : "人",
+                homeHuman: home.startsWith("user:") ? home.slice(5) : UNKNOWN_HUMAN,
                 since: rec?.clonedFrom ? rec.bornAt : 0,
             };
         };
@@ -809,7 +925,7 @@ const main = async () => {
             // 什么都没给 = 调用方这一轮所在的群; 只给 target = 调用方与它的往来。
             const base = chatRef ? chatBaseOf(cfg, chatRef) : roleRef || targetRef ? "" : channelOf(self);
             if (chatRef && !base) {
-                json(res, 404, { ok: false, reason: `认不出聊天 '${chatRef}' (list_chats 看有哪些)` });
+                json(res, 404, { ok: false, reason: `认不出聊天 '${chatRef}' (wizard_roster 每行有 home 聊天名, 人侧 /chats)` });
                 return;
             }
             const role = roleRef ? logRole(self, roleRef) : targetRef ? { name: displayName(self), target: self } : undefined;
@@ -866,26 +982,41 @@ const main = async () => {
                 json(res, 400, { ok: false, reason: "text required" });
                 return;
             }
-            const jobId = (body.job ?? "").trim();
-            if (jobId) {
-                const jc = checkJob(jobId);
-                if (!jc.ok) {
-                    json(res, jc.status, { ok: false, reason: jc.reason });
-                    return;
-                }
-            }
+            // 这句话要对方怎么接 (priority 管何时投, receipt 管要不要回执, 这个管它怎么接):
+            // task 一件活 (默认) / ask 只答一问 / fyi 知会 —— fyi 不要回执、不进工单、不进群。
+            const rawKind = body.kind;
+            const kind = rawKind === "ask" || rawKind === "fyi" ? rawKind : "task";
             const r = resolvePeer(self, addrOf(body));
             if (!r.ok) {
                 json(res, r.status, { ok: false, reason: r.reason, candidates: r.candidates });
                 return;
             }
             const { target, foreign } = r;
+            // 件号先于一切: `re` 续问沿用那件活的件号、工单与频道 (见 receipts.prepare)。
+            const re = (body.re ?? "").toString().trim();
+            const turn = receipts.prepare(self, target, re || undefined);
+            // 续问只在那个工单还开着时沿用它: 收了工的工单不再收成员, 续问照样能发。
+            // 没带工单的一句顶掉一份还没落定的工单活, 也算在那张工单上 (receipts.register 同理
+            // 继承): 不然换个不带 job 的 tell_peer 就绕开了预算。
+            const open = receipts.pending(self, target);
+            const isOpen = (id) => (id && jobs.get(id)?.status === "open" ? id : "");
+            const askedJob = (body.job ?? "").trim();
+            const jobId = kind === "fyi" ? "" : askedJob || isOpen(turn.job) || isOpen(open?.job);
+            if (jobId) {
+                const jc = checkJob(jobId, target, !!open?.need && open.turn === turn.turn);
+                if (!jc.ok) {
+                    json(res, jc.status, { ok: false, reason: jc.reason });
+                    return;
+                }
+            }
             // 公开与否由发话方 (LLM) 判断: 公开 = 在它这一轮的公开频道里说, 气泡进群、对方
             // 那一轮的回复也发进这个群; 私聊 (默认) = 只落双方的 rolepage, 回复靠 wait_peer 取。
             // 只有两端都是登记在册的 wizard 才能当着人说: 裸 target 冒充的发话方、forget
             // 掉的分身不是谁, 它们的往来进群只会留下一段人找不到主的对话 —— 降为私聊。
-            const isPublic = body.public === true && !!wizards.get(self) && !!wizards.get(target);
-            const channel = isPublic ? channelOf(self) : "";
+            // 工单里的派活一律私聊: 人看不懂 fan-out 的过程, 群里只留发起者自己的收口。
+            // 知会不进群: 公开信封要对方「照对人说话的方式答」, 一句「收到」会被发给一群人。
+            const isPublic = !jobId && kind !== "fyi" && (turn.channel !== undefined ? !!turn.channel : body.public === true) && !!wizards.get(self) && !!wizards.get(target);
+            const channel = isPublic ? turn.channel || channelOf(self) : "";
             // Injecting into your own pane would type into the box you're generating
             // from — Claude Code queues it and the caller deadlocks waiting for itself.
             if (target === self) {
@@ -895,40 +1026,90 @@ const main = async () => {
             // 它正在交接: 这句话等它换完会话再进 —— 投进旧会话会被交接一并带走, 投进重开中的
             // 空 pane 会 resume 回旧 sid (见 handoff.ts)。发话时刻取在这之后。
             await handedOff(target);
-            // 投递时机。默认照旧立刻投 —— 「回答它的提问」「打断它」本来就是冲着一个
-            // 正在忙的会话去的。`when:"idle"` 是**派新活**该用的那一种: 两个 wizard 同时
-            // 找第三个时, 两段文本会挤进同一个输入框、被当成一轮读掉, 这在协同网络里
-            // 不是边角情况而是常态。等它闲下来再投, 一句话就是一轮。
-            const when = (body.when ?? "now") === "idle" ? "idle" : "now";
+            // 投递策略。对方闲着三者一样 —— 立刻投; 只在它正忙时分岔:
+            //   normal (默认) 等它这一轮结束再投 —— 派新活的常态: 两个 wizard 同时找第三个时,
+            //     两段文本会挤进同一个输入框、被当成一轮读掉, 这在协同网络里不是边角情况而是常态;
+            //   urgent 先打断它这一轮 (与 stop_wizard 的 interrupt 同一下 Esc) 再投 —— 紧急改道;
+            //   now   不等不打断, 落进输入框由 CLI 并进它这一轮 —— 插话、补一句、答它的问。
+            // 老 MCP 进程只认 `when` (默认 now): idle ≡ normal, now ≡ now。都没给时, `re` 续问默认 now ——
+            // 续问是同一场来回里的应答, 对方可能正挂在 wait_peer 上等你, 等它闲下来就互相干等到超时。
+            const bp = body;
+            const asked = bp.priority === "urgent" ? "urgent"
+                : bp.priority === "normal" ? "normal"
+                    : bp.priority === "now" || bp.when === "now" ? "now"
+                        : bp.when === "idle" ? "normal"
+                            : re ? "now" : "normal";
             const waitSec = Math.min(Math.max(Number(body.waitSec ?? 600) || 600, 10), 3600);
             // 「忙」= 这一轮还没结束, 或停在审批上等人 —— 都不是能接新活的时候。
             const wasBusy = !(await m.idleNow(target));
+            // urgent 只打断你自己派的那一轮 (或它自己的回执轮): 手上若是别的 wizard / 人 / 定时任务的活,
+            // 打断就误伤了那件 —— 降成 normal, 等它这一轮做完再投。
+            const others = asked === "urgent" && wasBusy ? await othersTurn(target, self) : undefined;
+            const policy = others ? "normal" : asked;
             let waitedMs = 0;
-            if (when === "idle" && wasBusy) {
+            let interrupted;
+            if (policy === "normal" && wasBusy) {
                 const t0 = Date.now();
                 // 它那一轮一结束就投: 注册表 status 翻 idle 是事件, 不抽样也不等稳定期。
                 const wr = await m.untilIdle(target, waitSec * 1000);
                 waitedMs = Date.now() - t0;
                 if (!wr.idle) {
-                    json(res, 409, { ok: false, target, foreign, wasBusy, waitedMs, reason: `它一直在忙, ${waitSec}s 内没闲下来 —— peek_peer 看看它卡在哪, 或者用 when:"now" 插队` });
+                    json(res, 409, { ok: false, target, foreign, wasBusy, waitedMs, reason: `它一直在忙, ${waitSec}s 内没闲下来 —— peek_peer 看看它卡在哪; 真急就 priority:"urgent" 打断它` });
                     return;
                 }
             }
+            if (policy === "urgent" && wasBusy) {
+                // 只按 Esc, 不走 /stop 的 teardown: 那会清掉它的注入队列 (别人排着的话一起丢)
+                // 并暂停 keepalive —— 这里打断它是为了马上接着干, 不是让它安静。
+                const t0 = Date.now();
+                const esc = await m.interruptPane(target);
+                // 等 Esc 生效、这一轮真收住再投; 收不住也照投 —— 落进输入框排在后面, 退化成 now。
+                interrupted = esc.ok && (await m.untilIdle(target, 15_000)).idle;
+                waitedMs = Date.now() - t0;
+            }
             // 时刻取在注入**之前**: 晚于那一句落盘的话, 回执定位的下界就偏了。
             const at = Date.now();
+            // 唤醒代价同样要在注入之前量: 投进去 transcript 一动, 就看不出它冷了多久。
+            const info = m.sessionInfo(target);
+            const wake = info?.jsonlPath
+                ? wakeNoteOf(info.contextTokens, (() => { try {
+                    return statSync(info.jsonlPath).mtimeMs;
+                }
+                catch {
+                    return 0;
+                } })(), at, (cacheTtlSec(info.jsonlPath) || cfg.wrc.mirror.keepalive.ttlSec) * 1000)
+                : "";
+            const deadlineSec = body.deadline;
+            // 回执: 对方干完那一轮, 守护进程把它的结论自动送回来 (默认开)。`receipt:false`
+            // 是"放出去就不管了"的那种派活; fyi 一定不要。对方的信封据此改口, 不再让它收口。
+            const wantReceipt = kind !== "fyi" && body.receipt !== false;
+            const deadlineAt = deadlineOf(at, deadlineSec === undefined ? undefined : Number(deadlineSec));
+            const asker = askerOf(self);
             const inj = await m.injectText(target, text, undefined, {
-                from: { kind: "peer", from: self, ...(jobId ? { job: jobId } : {}), ...(isPublic ? { public: true } : {}) },
+                from: { kind: "peer", from: self, turn: turn.turn, ...(jobId ? { job: jobId } : {}), ...(isPublic ? { public: true } : {}), ...(asker ? { asker } : {}) },
                 channel,
-                envelope: envelopeFor(self, channel),
+                envelope: envelopeFor(self, channel, {
+                    turn: turn.turn,
+                    legs: turn.legs,
+                    ...(turn.legs > 1 ? { re: true } : {}),
+                    // 期限只在发话方明说时写给对方看: 默认的一小时不值得每轮多一句。
+                    ...(deadlineSec !== undefined ? { deadline: deadlineAt } : {}),
+                    ...(kind !== "task" ? { act: kind } : {}),
+                    ...(wantReceipt ? {} : { quiet: true }),
+                }),
             });
-            // 回执: 对方干完那一轮, 守护进程把它的结论自动送回来 (默认开)。`receipt:false`
-            // 是"放出去就不管了"的那种派活。注入失败就不守 —— 没有问话, 也不会有回答。
-            const wantReceipt = body.receipt !== false;
-            if (inj.ok)
-                receipts.register({ from: self, to: target, channel, job: jobId, at }, wantReceipt);
+            // 注入失败就不守 —— 没有问话, 也不会有回答。不要回执 (receipt:false / fyi) 就不登记:
+            // 一份不守的槽会以同一对的 key 顶掉发话方还在等它答的那件活, 那件的回执就再也来不了。
+            // 父 k: 默认这件活算发话方此刻在答的那件的子活 (链式续回); `chain:false` = 旁支,
+            // 回执照常回来, 但不挂住它给上游的交代 —— 只有发话方知道这件活是不是为上游派的。
+            const 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 } : {}) });
             // 工单成员照旧记账 (收工那一条会列出各自那段活); 公开的那一句在群里成气泡。
+            // 续问 (re) 不是一段新活: 工单页与留档里该列的仍是当初派的那段。
             if (inj.ok && jobId)
-                jobs.attach(jobId, { target, task: text, spawned: false });
+                jobs.attach(jobId, { target, task: turn.legs > 1 ? "" : text, spawned: false });
+            const spent = inj.ok && jobId ? jobs.spend(jobId) : undefined;
             if (inj.ok && isPublic)
                 relayPeer(self, target, text, channel);
             // `wasBusy` 是给调用方的判断依据: 立刻投给一个正在生成的会话, 这句话会排在
@@ -937,13 +1118,25 @@ const main = async () => {
                 ...inj,
                 name: peerAddress(cfg, self, target),
                 public: isPublic,
+                priority: policy,
+                ...(kind !== "task" ? { kind } : {}),
+                ...(kind === "fyi" && askedJob ? { jobIgnored: true } : {}),
+                ...(others ? { urgentDowngraded: `它此刻在做 ${others.from} 派的活, 没打断它 —— 按 normal 等它这一轮做完再投` } : {}),
                 wasBusy,
+                ...(interrupted !== undefined ? { interrupted } : {}),
                 ...(waitedMs ? { waitedMs } : {}),
                 ...(jobId ? { job: jobId } : {}),
+                ...(inj.ok ? { turn: turn.turn } : {}),
+                ...(spent?.maxTurns ? { budget: `${spent.turns}/${spent.maxTurns}${spent.turns >= spent.maxTurns ? " —— 用完了, 这是最后一次派活, 下一步收口" : ""}` } : {}),
+                ...(inj.ok && wake ? { wakeCost: wake } : {}),
+                ...(turn.reUnknown ? { reUnknown: true, reNote: `re "${re}" 不是你正在等 ${displayName(target)} 答的那件, 按新活发出` } : {}),
                 // 回执怎么回来 —— 写在回包里, 调用方 (模型) 不必从工具描述里回忆。
                 ...(inj.ok && wantReceipt
                     ? { receipt: "它干完那一轮, 结论会作为新的一轮自动进到你这里 —— 不要挂在 wait_peer 上等, 接着干你自己的事" }
                     : {}),
+                ...(inj.ok && wantReceipt && k?.kind === "peer"
+                    ? { chained: `这件活算在你答 ${displayName(k.from)} 的那件 (${k.turn}) 名下: 它回来之前, 你这一轮的终句不会先交给 ${displayName(k.from)}; 与那件活无关就带 chain:false 发` }
+                    : {}),
             });
         };
         http.register("POST /peers/tell", tellPeer);
@@ -994,13 +1187,16 @@ const main = async () => {
                 // 取走就占位: 同一段话不会再作为回执 paste 进来一遍 (见 receipts.claim)。
                 const full = wr.idle ? m.lastReply(h.target, receipts.sentAt(self, h.target)) : "";
                 const already = full ? receipts.claim(self, h.target) : false;
-                const result = extractResult(full);
+                const closing = parseClosing(full);
+                const result = closing.kind === "result" ? closing.text : "";
                 return {
                     name: h.address,
                     idle: wr.idle,
                     // 回执早一步到了: 这段话已经作为新的一轮进过你的会话, 别再处理第二遍。
                     ...(already ? { delivered: true } : {}),
                     ...(wr.reason ? { reason: wr.reason } : {}),
+                    ...(closing.kind === "need" ? { need: closing.text } : {}),
+                    ...(closing.artifacts.length ? { artifacts: closing.artifacts } : {}),
                     ...(result
                         ? { result, ...(full.length > result.length + 200 ? { omitted: full.length - result.length } : {}) }
                         : full
@@ -1027,6 +1223,17 @@ const main = async () => {
         // 压成一份"零上下文也能接手"的交接简报,等它写完并抓取,再 restartFresh 换一个
         // 全新的进程(同名、同 cwd),把简报作为新会话的首条消息贴进去。拒绝对调用方
         // 自身操作(会 deadlock,同 /peers/send)。
+        /** 交接自己: 简报由调用方给, 排在它这一轮说完之后 (见 handoff.ts)。/handoff 点名点到
+         *  自己与老路由 /wizard/handoff-self 共用。 */
+        const handoffSelf = (self, brief) => {
+            if (brief.length < 40)
+                return { status: 400, body: { ok: false, reason: "brief 太短 —— 要写到零上下文也能接手: 目标 / 已完成 / 当前状态 / 下一步 / 关键文件与坑" } };
+            const info = m.sessionInfo(self);
+            const r = handoffs.self(self, brief);
+            return r.ok
+                ? { status: 200, body: { ok: true, target: self, contextTokens: info?.contextTokens ?? 0, scheduled: true } }
+                : { status: 409, body: { ok: false, reason: r.reason } };
+        };
         http.register("POST /handoff", async (req, res) => {
             const { self, body } = await readPeerBody(req);
             if (!self) {
@@ -1043,6 +1250,12 @@ const main = async () => {
                 }
             }
             else {
+                // 不点名不能落成「本聊天的默认 wizard」(resolvePeer 对 "" 的语义): 交接是把人家的
+                // 上下文清掉重开, 一个漏传的参数不该把群管家交接掉。不点名的交接只能是交接自己。
+                if (!addrOf(body).trim()) {
+                    json(res, 400, { ok: false, reason: "要点名 (name) —— 交接你自己走 /wizard/handoff-self (MCP: handoff 不传 name, 带 brief)" });
+                    return;
+                }
                 const r = resolvePeer(self, addrOf(body));
                 if (!r.ok) {
                     json(res, r.status, { ok: false, reason: r.reason, candidates: r.candidates });
@@ -1050,10 +1263,16 @@ const main = async () => {
                 }
                 target = r.target;
             }
-            // 注入到自己的 pane = 往正在生成的输入框里打字,Claude Code 会把它排队,
-            // 调用方等自己等成死锁(同 /peers/send)。
+            // 点名点到自己: 不能走「让它写简报」那条 (往正在生成的输入框里打字, 等自己等成
+            // 死锁), 改走交接自己 —— 简报得由调用方自己给。
             if (target === self) {
-                json(res, 400, { ok: false, reason: "refusing to hand off the calling session itself (would deadlock)" });
+                const brief = (body.brief ?? "").toString().trim();
+                if (!brief) {
+                    json(res, 400, { ok: false, reason: "这是交接你自己: 把简报写在 brief 里 (不传 name 即可; 旧会话的 handoff 没有 brief 参数, 用 wizard_handoff_self)" });
+                    return;
+                }
+                const r = handoffSelf(self, brief);
+                json(res, r.status, r.body);
                 return;
             }
             const focus = (body.focus ?? "").toString().trim();
@@ -1068,12 +1287,26 @@ const main = async () => {
         // 上下文窗口也挤不掉。
         // 这里只做三件事: 读身份、改身份、按身份生/收分身。tmux 一概不碰, 动作全在
         // mirror-bridge。
-        const wizards = bindWizardStore(loadWizardStore(cfg.wrc.mirror.wizardsFile));
+        const bornOf = (t) => firstStamp(m.sessionInfo(t)?.jsonlPath ?? "");
+        const wizards = bindWizardStore(loadWizardStore(cfg.wrc.mirror.wizardsFile, bornOf));
         // 名册增量的投递面 (见 notices.ts)。charter 只是出生那一刻的快照; 此后的成员
         // 变动从这里搭下一次注入的车进到每个在场 wizard 的上下文里, 不占一轮。
         // 一条变动只投给**同一个聊天**里在场的其他 wizard: 群成员变动是那个群的事,
         // 当事人自己做的自己知道, 所以排除在外。
-        const notices = bindNoticeBox(createNoticeBox());
+        // 上下文逼近自动压缩时提醒一句「先记」: 压缩 / 交接都会丢细节。每段会话 (sid) 只提一次。
+        const nudged = new Set();
+        // 线按模型的窗口算 (memoryNudgeAt); 模型取 transcript 里实际跑的那个 id, pane 记的常是空串或 `opus` 这种别名。
+        const memoryNudge = (t) => {
+            const i = m.sessionInfo(t);
+            // 最低的那条线先挡: 不到它就不必再读一次 transcript 取模型。
+            if (!i?.sessionId || nudged.has(i.sessionId) || i.contextTokens < MEMORY_NUDGE_FLOOR)
+                return [];
+            if (i.contextTokens < memoryNudgeAt(lastModel(i.jsonlPath) || i.model))
+                return [];
+            nudged.add(i.sessionId);
+            return [`你的上下文已到 ${Math.round(i.contextTokens / 1000)}k, 快到自动压缩了: 这段里学到的、值得跨会话活下来的东西, 先 \`wizard_remember\` 记下 (自己的选 self, 属于群 / 仓库的选 chat / workspace), 再考虑 \`handoff\``];
+        };
+        const notices = bindNoticeBox(createNoticeBox(12, memoryNudge));
         const postRoster = (base, except, line) => notices.post(chatAudience(m.chatTargets(base), base, except), line);
         /** 一个聊天的工作区: 它名下各会话跑在哪个目录, 取最多的那个。聊天与工作区是
          *  一对多, 但绝大多数聊天只围着一个项目转。 */
@@ -1108,26 +1341,43 @@ const main = async () => {
                 log.info({ base, name }, "chat: auto-named from workspace");
                 // 群里不发气泡 (一次补名会命中十几个群, 那是刷屏), 但住在里面的 wizard
                 // 得知道自己的地址变了 —— 它的 charter 里写的还是「(未命名)」。
-                postRoster(base, [], `这个聊天现在叫 **${name}** (按工作区自动起的) —— notify / new_claude_session 可以用这个名字指到这里。`);
+                postRoster(base, [], `这个聊天现在叫 **${name}** (按工作区自动起的) —— notify / spawn_wizard 的 \`chat\` 可以用这个名字指到这里。`);
             }
             return named;
         };
         // 名字全局唯一 (见 wizard.ts): 先给没名字的聊天补名, 再按「默认会话先挑」把
         // 每个已知 wizard 的名字落定 —— 老记录 (名字还跟着聊天走的那一代) 在这里一次迁完。
         ensureChatNames(cfg.defaultChat || "");
+        const reborn = backfillBorn(wizards, bornOf);
+        if (reborn.length)
+            log.child({ mod: "wizard" }).info({ n: reborn.length }, "bornAt backfilled from transcript heads");
         settleAll(wizards, [...m.chatRoster("").flatMap((c) => c.targets), ...wizards.all().map((w) => w.target)], (t) => chatNameOf(cfg, t));
-        // 工单账本 (见 jobs.ts)。只在**显式传了 `job`** 时起作用 —— 不用工单的调用方
-        // 行为与从前一模一样。
-        const jobs = loadJobStore(cfg.wrc.mirror.jobsFile);
+        // 上一个进程生到一半就没了的身份 (spawn 途中 reload): 没会话的删掉, 腾出名字。
+        // 它们的 tmux window 也一并收掉 (没人叫得到它, 只会占着 pane): 等绑定恢复完再看,
+        // 免得把还没恢复的活 pane 当成没绑定; 期间名字已被新 spawn 认领的不碰。
+        const unborn = sweepUnborn(wizards, (t) => m.chatTargets(baseOfKey(t)).includes(t));
+        unborn.forEach((w) => log.child({ mod: "wizard" }).warn({ target: w.target, name: w.name }, "unborn identity swept"));
+        if (unborn.length) {
+            void m.restored
+                .then(() => m.reapUnborn(unborn.map((w) => w.name).filter((n) => n && !wizards.byName(n))))
+                .then((killed) => { if (killed.length)
+                log.child({ mod: "wizard" }).info({ killed }, "unborn windows killed"); })
+                .catch((e) => log.warn({ err: e.message }, "unborn window reap failed"));
+        }
         /** 派活前先验工单: 生完分身才发现工单号打错了, 那个分身就成了没人认领的孤儿。 */
-        const checkJob = (id) => {
+        /** `free` = 这次不花预算 (不带 task 的 spawn; 答一份停在 NEED 上的反问 —— 拒了它就只能干等到超时)。 */
+        const checkJob = (id, target, free = false) => {
             const j = jobs.get(id);
             if (!j)
                 return { ok: false, status: 404, reason: `没有工单 '${id}' —— open_job 先开一个, 或者 list_jobs 看还开着哪些` };
             if (j.status !== "open")
                 return { ok: false, status: 409, reason: `工单 '${id}' 已经收工了` };
-            if (j.members.length >= JOB_MEMBER_MAX)
+            // 已在册的成员 (续问 / 再派一句) 不占新名额。
+            if (j.members.length >= JOB_MEMBER_MAX && !j.members.some((x) => x.target === target))
                 return { ok: false, status: 409, reason: `工单 '${id}' 的成员已经满了 (${JOB_MEMBER_MAX} 个) —— 分身是有成本的, 拆成两个工单, 或者先收工回收掉一批` };
+            // 预算是硬的: 与单件活的 legs 不同, 这里拒了也无路可绕 —— 换个人派照样记在这张工单上。
+            if (!free && j.maxTurns && (j.turns ?? 0) >= j.maxTurns)
+                return { ok: false, status: 409, reason: `工单 '${id}' 的派活预算用完了 (${j.turns}/${j.maxTurns} 次) —— 拿手上已有的结论 close_job 收口, 缺的如实写; 真要接着干就 open_job 开一张新的` };
             return { ok: true };
         };
         // ── 关系视图的数据面 ──────────────────────────────────────────────
@@ -1148,8 +1398,18 @@ const main = async () => {
             const known = wizards.all();
             const byTarget = new Map(known.map((w) => [w.target, w]));
             const seen = new Set(peers.map((p) => p.target));
+            // 「卡在审批」以 daemon 手里的 pending 为准 —— 审批长轮询期间 pane 照样在转圈,
+            // 拿 busy 去推会把它当成「执行中」。归属走 approval 认卡的同一口径 (getMirrorTarget):
+            // hook 的 sid 在 /clear 之后先变, 镜像绑定的 sid 要等新 jsonl 出现才跟上。
+            // ask_user 的 pending 不带 sessionId —— 它是 MCP 工具在等, 不归哪张卡, 不亮。
+            const waitingOf = listPending().reduce((m, { meta }) => {
+                const t = meta.sessionId ? getMirrorTarget(meta.sessionId) : undefined;
+                const tool = meta.toolName || meta.kind;
+                return t ? m.set(t, [...new Set([...(m.get(t) ?? []), tool])]) : m;
+            }, new Map());
             const live = peers.map((p) => {
                 const w = byTarget.get(p.target);
+                const waiting = waitingOf.get(p.target);
                 return {
                     target: p.target,
                     name: settleName(wizards, chatNameOf(cfg, p.target), p.target),
@@ -1157,9 +1417,11 @@ const main = async () => {
                     chat: chatNameOf(cfg, p.target) || p.chat,
                     cwd: p.cwd,
                     model: p.model,
+                    ...((e) => (e ? { effort: e } : {}))(mirrorStore.get(p.target)?.effort),
                     cli: p.cli,
                     busy: p.busy,
                     alive: p.paneAlive,
+                    ...(waiting ? { waiting } : {}),
                     parent: w?.parent,
                     clonedFrom: w?.clonedFrom,
                     forkOf: w?.forkOf,
@@ -1191,9 +1453,11 @@ const main = async () => {
                 wizards: [...live, ...cold],
                 jobs: jobs.all().map((j) => ({
                     id: j.id, base: j.base, owner: j.owner, title: j.title, status: j.status,
-                    openedAt: j.openedAt, closedAt: j.closedAt, summary: j.summary,
-                    members: j.members.map((mm) => ({ target: mm.target, task: mm.task, spawned: mm.spawned })),
+                    openedAt: j.openedAt, closedAt: j.closedAt, summary: j.summary, ...(j.expect ? { expect: j.expect } : {}), ...(j.plan ? { plan: j.plan } : {}),
+                    members: j.members.map((mm) => ({ target: mm.target, task: mm.task, spawned: mm.spawned, ...(mm.outcome ? { outcome: mm.outcome } : {}), ...(mm.artifacts?.length ? { artifacts: mm.artifacts } : {}) })),
                 })),
+                // rolepage 的待办托盘: 与名册 / peek 的「在等 / 欠着」同一份 (receipts.states)。
+                inflight: receipts.states().map(({ ageMs, ...x }) => ({ ...x, at: Date.now() - ageMs })),
                 schedules: tasks.list().filter((x) => x.enabled).map((x) => {
                     const st = tasks.stateOf(x.id);
                     const loadError = tasks.errors()[x.id];
@@ -1244,25 +1508,68 @@ const main = async () => {
             const path = memoryPath(cfg.daemon.stateDir, scope, key);
             return clipForCharter(readMemory(path), path);
         };
+        /** transcript 最后写入的时刻; 没有会话 / 读不到 = 0。 */
+        const lastTouched = (t) => {
+            const p = m.sessionInfo(t)?.jsonlPath;
+            try {
+                return p ? statSync(p).mtimeMs : 0;
+            }
+            catch {
+                return 0;
+            }
+        };
+        // 每个会话的宪章里写进了哪些 self 记忆。`/clear` 抹掉对话却不重写系统提示, 此后
+        // 新记的那些就只活在被抹掉的对话里 —— onContextCut 据这份快照补发差集。纯内存: reload
+        // 之后没有快照, 只指路不补发。
+        const chartered = new Map();
         /** 开局宪章。出生时的兄弟只是快照 —— 名册随时可查, 写进系统提示的那份只为了
          *  让它一睁眼就知道自己不是一个人在跑。 */
-        const charterFor = (target, o) => renderCharter({
-            // o.cwd = 正在启动的那个 pane 的目录; 没给才退回"现在记着的那个"。
-            self: { ...briefOf(target, target), address: selfAddress(target), ...(o.cwd ? { cwd: o.cwd } : {}) },
-            chat: chatNameOf(cfg, target),
-            principal: baseOfKey(target),
-            parent: o.parent ? briefOf(target, o.parent) : undefined,
-            inherited: !!o.inherited,
-            forkOf: o.forkOf ? briefOf(target, o.forkOf) : undefined,
-            cwdUnconfirmed: m.cwdUnconfirmed(target, o.cwd),
-            siblings: m.chatTargets(baseOfKey(target)).filter((t) => t !== target).map((t) => briefOf(target, t)),
-            memory: wizards.get(target)?.memory ?? [],
-            chatMemory: sharedMemory("chat", baseOfKey(target)),
-            workspaceMemory: (() => {
-                const cwd = o.cwd || m.getCwd(target).runningCwd || m.getCwd(target).defaultCwd;
-                return cwd ? sharedMemory("workspace", cwd) : "";
-            })(),
-            steward: !tagOfKey(target),
+        const charterFor = (target, o) => {
+            chartered.set(target, wizards.get(target)?.memory ?? []);
+            const text = renderCharter({
+                // o.cwd = 正在启动的那个 pane 的目录; 没给才退回"现在记着的那个"。
+                self: { ...briefOf(target, target), address: selfAddress(target), ...(o.cwd ? { cwd: o.cwd } : {}) },
+                chat: chatNameOf(cfg, target),
+                principal: baseOfKey(target),
+                parent: o.parent ? briefOf(target, o.parent) : undefined,
+                inherited: !!o.inherited,
+                forkOf: o.forkOf ? briefOf(target, o.forkOf) : undefined,
+                cwdUnconfirmed: m.cwdUnconfirmed(target, o.cwd),
+                // 最近动过的排前面: 名册只点名前几个, 截掉的该是早就停了的那些。
+                // 没有 transcript 的冷记录按 bornAt 算, 刚生下还没开口的照样在。
+                siblings: m.chatTargets(baseOfKey(target))
+                    .filter((t) => t !== target)
+                    .map((t) => [t, Math.max(lastTouched(t), wizards.get(t)?.bornAt ?? 0)])
+                    .filter(([, at]) => Date.now() - at <= ROSTER_FRESH_MS)
+                    .sort((x, y) => y[1] - x[1])
+                    .map(([t]) => briefOf(target, t)),
+                memory: wizards.get(target)?.memory ?? [],
+                chatMemory: sharedMemory("chat", baseOfKey(target)),
+                workspaceMemory: (() => {
+                    const cwd = o.cwd || m.getCwd(target).runningCwd || m.getCwd(target).defaultCwd;
+                    return cwd ? sharedMemory("workspace", cwd) : "";
+                })(),
+                steward: !tagOfKey(target),
+            });
+            recordCharter(target, text);
+            return text;
+        };
+        m.onContextCut((t, cut) => {
+            const now = wizards.get(t)?.memory ?? [];
+            const seen = chartered.get(t);
+            // 没有快照 (reload 之后) 就不猜差集, 只指路 —— 整份塞进一行能有几万字。
+            if (!seen) {
+                if (now.length)
+                    notices.post([t], `你有 ${now.length} 条 self 记忆, 宪章里那份可能是旧的: \`wizard_whoami\` 看全的`);
+                return;
+            }
+            const fresh = now.filter((x) => !seen.includes(x));
+            const gone = seen.filter((x) => !now.includes(x)).length;
+            const shown = fresh.slice(-10).map((x) => `「${clipLine(x, 200)}」`).join(" ");
+            if (fresh.length)
+                notices.post([t], `你出生之后记下的 self 记忆 (${cut === "clear" ? "/clear 抹掉了对话" : "上下文压缩把对话换成了摘要"}, 宪章里没有它们)${fresh.length > 10 ? `, 最新 10 条` : ""}: ${shown}`);
+            if (gone)
+                notices.post([t], `宪章「我的记忆」里有 ${gone} 条已被你 forget, 别再照它们办`);
         });
         // 所有 spawn 路径 (群里手打 /new、pane 自愈重生、编排出来的分身) 都从这里
         // 取身份, 于是「是谁」不再取决于是哪段代码把它生出来的。
@@ -1271,9 +1578,25 @@ const main = async () => {
             // 终身的 —— 一个在聊天还没名字时出生的 wizard, 会一辈子以为自己住在一个
             // 「(未命名)」的地方。所以补名要发生在渲染之前, 不能等它以后自己去查。
             ensureChatNames(target);
+            // 信箱里装的是相对上一份宪章的变化; 新宪章一渲染就都过期了 (名册、记忆都已在里面)。
+            notices.drain(target);
             const rec = wizards.get(target);
             return charterFor(target, { parent: rec?.parent, forkOf: rec?.forkOf, inherited: !!rec?.clonedFrom, cwd: ctx?.cwd });
         });
+        // 宪章记录是后来才有的: 已经在跑的 wizard 拿 spawn 落盘的那份 (state/charters/<sid>.md) 补上,
+        // 否则要等它下次重生, rolepage 的「宪章」入口才出现。与自动命名同一个延迟: 等附着表恢复完。
+        setTimeout(() => {
+            const dir = join(expandHome(cfg.daemon.stateDir), "charters");
+            wizards.all().forEach((w) => {
+                const sid = m.sessionInfo(w.target)?.sessionId;
+                const file = sid ? join(dir, `${sid}.md`) : "";
+                try {
+                    if (file && existsSync(file))
+                        backfillCharter(w.target, readFileSync(file, "utf8"), statSync(file).mtimeMs);
+                }
+                catch { /* 补不上就等它重生 */ }
+            });
+        }, 15_000).unref();
         // 开机也补一次: IM 侧的 `/peers`、`/help` 直接读名字, 不经过任何 MCP 路由。
         // 延后是因为附着表要先从盘上恢复完, 否则这一刻还看不见那些聊天; 补不全也无妨,
         // 上面每一道拦截都会再补。
@@ -1310,8 +1633,9 @@ const main = async () => {
                 sessionId: info?.sessionId ?? "",
                 cli: info?.cli,
                 model: info?.model ?? "",
+                ...(info?.effort ? { effort: info.effort } : {}),
                 contextTokens: info?.contextTokens ?? 0,
-                handoffSuggested: (info?.contextTokens ?? 0) > CONTEXT_FULL_TOKENS,
+                handoffSuggested: !!info && info.contextTokens > handoffAt(lastModel(info.jsonlPath) || info.model),
             };
         };
         /** 全体名册: 活着的 (peers + 跨聊天可寻址的) 在前, 注册表里有记录但此刻不在
@@ -1429,8 +1753,10 @@ const main = async () => {
             // 的箭头 (读名册的是另一个 wizard), 模型取它真正跑的那个 —— 绑定里的 model 只在
             // 有人显式选过时才有。
             const warm = keepalivePingSigs(cfg.wrc.mirror.keepalive.ping);
+            const inflight = receipts.states();
             const shown = ranked.slice(0, limit).map((r) => ({
                 ...r,
+                turns: turnsLine(inflight, r.target),
                 model: r.model || (r.jsonlPath ? lastModel(r.jsonlPath) : ""),
                 summary: r.jsonlPath ? lastExchange(r.jsonlPath, 80, warm) : "",
                 contextTokens: r.jsonlPath ? lastContextTokens(r.jsonlPath) : 0,
@@ -1469,9 +1795,11 @@ const main = async () => {
                 .filter((r) => !r.self)
                 .map((r) => {
                 const live = r.jsonlPath ? r.jsonlPath : "";
+                const ttl = live ? cacheTtlSec(live) : 0;
                 return {
                     ...r,
                     contextTokens: live ? lastContextTokens(live) : 0,
+                    ...(ttl ? { cacheTtlMs: ttl * 1000 } : {}),
                     files: live ? contextFiles(live) : [],
                     asks: live ? talkTurns(live, 12, warm).filter((t) => t.role === "user").map((t) => t.text) : [],
                     summary: live ? lastExchange(live, 80, warm) : "",
@@ -1479,7 +1807,7 @@ const main = async () => {
             });
             const limit = Math.min(Math.max(Number(b.limit ?? 5) || 5, 1), 20);
             const cands = rankCandidates(task, (b.cwd ?? "").trim() || m.getCwd(self).runningCwd, rows).slice(0, limit);
-            json(res, 200, { ok: true, text: renderCandidates(cands, Date.now(), homedir()) });
+            json(res, 200, { ok: true, text: renderCandidates(task, cands, Date.now(), cfg.wrc.mirror.keepalive.ttlSec * 1000, homedir()) });
         });
         // 记忆三种作用域: self 跟着自己 (wizards.json), 直写; chat / workspace 是共享的 md,
         // 每个在那个群 / 那个目录出生的 wizard 都会读到 —— 它们只收提议, 由整理者合并
@@ -1508,6 +1836,7 @@ const main = async () => {
                 const queued = proposeMemory(inboxPath(cfg.daemon.stateDir, scope, key), {
                     at: Date.now(),
                     by: selfAddress(self),
+                    ...(scope === "workspace" ? { cwd: key } : {}),
                     ...(note ? { note } : {}),
                     ...(forget ? { forget } : {}),
                 });
@@ -1515,18 +1844,30 @@ const main = async () => {
                     json(res, 500, { ok: false, reason: "提议没写进收件箱" });
                     return;
                 }
+                // 不回全文: 每提一条就把整份 md 吐回上下文, 连交几条就是几倍的 token。
+                // forget 是子串, 回它此刻命中几行 —— 0 行就是写错了, 当场能改。
+                const lines = readMemory(path).split("\n").filter((l) => l.trim());
                 json(res, 200, {
-                    ok: true, scope, queued, file: path, memory: readMemory(path),
-                    hint: "已提交给记忆整理者, 下一轮整理 (半小时内) 合并进上面这份记忆; 此后出生的 wizard 才读得到",
+                    ok: true, scope, queued, file: path, lines: lines.length,
+                    ...(forget ? { forgetHits: lines.filter((l) => l.includes(forget)).length } : {}),
+                    hint: "已提交给记忆整理者, 下一轮整理 (半小时内) 合并进 file; 此后出生的 wizard 才读得到",
                 });
                 return;
             }
             const cur = wizards.get(self)?.memory ?? [];
             // 忘记按子串匹配: 模型记不住自己当初一字不差写了什么, 但记得大意。
             const next = forget ? cur.filter((x) => !x.includes(forget)) : cur;
-            const memory = note ? [...next.filter((x) => x !== note), note] : next;
-            wizards.upsert(self, { memory });
-            json(res, 200, { ok: true, scope: "self", memory, added: !!note, forgotten: cur.length - next.length });
+            // 先截再比: 注册表存的是截到 NOTE_MAX 的那版, 拿原文比就永远去不了重。
+            const n = note.slice(0, NOTE_MAX);
+            const want = n ? [...next.filter((x) => x !== n), n] : next;
+            // 满额时注册表从最旧的挤掉 —— 挤掉的、截短的都要明说, 不让它以为全记住了。
+            const dropped = want.slice(0, Math.max(0, want.length - MEMORY_MAX));
+            const { memory } = wizards.upsert(self, { memory: want });
+            json(res, 200, {
+                ok: true, scope: "self", count: memory.length, added: !!note, forgotten: cur.length - next.length,
+                ...(dropped.length ? { dropped, hint: `self 记忆满 ${MEMORY_MAX} 条, 最旧的 ${dropped.length} 条被挤掉了 (见 dropped); 还要的话 forget 掉不重要的再记回来, 或合并成一条` } : {}),
+                ...(note.length > NOTE_MAX ? { truncated: `这条超过 ${NOTE_MAX} 字, 只记下了前 ${NOTE_MAX} 字` } : {}),
+            });
         });
         // 生分身。默认 fork 调用方此刻的上下文 —— 这是"先把公共材料读进来, 再分出 N
         // 个干活的"之所以省事的原因: 材料只读一遍, 却进了 N 份上下文。
@@ -1537,10 +1878,15 @@ const main = async () => {
                 return;
             }
             const b = body;
+            const effort = parseEffort(b.effort);
+            if (b.effort !== undefined && !effort) {
+                json(res, 400, { ok: false, reason: `effort 只有这几档: ${EFFORTS.join(" / ")}` });
+                return;
+            }
             // 工单先验: 生完分身才发现工单号打错了, 那个分身就成了没人认领的孤儿。
             const jobId = (b.job ?? "").trim();
             if (jobId) {
-                const jc = checkJob(jobId);
+                const jc = checkJob(jobId, undefined, !(b.task ?? "").toString().trim());
                 if (!jc.ok) {
                     json(res, jc.status, { ok: false, reason: jc.reason });
                     return;
@@ -1554,6 +1900,13 @@ const main = async () => {
                 return;
             }
             const inherit = b.inherit;
+            // detached = 独立长住 (原 new_claude_session / 人在群里 `/new .x`): 不挂家谱、不占
+            // 调用方的分身名额、不随工单回收。它和「fork 我的上下文」「归某张工单」都互斥。
+            const detached = b.detached === true;
+            if (detached && (inherit || (b.job ?? "").trim())) {
+                json(res, 400, { ok: false, reason: "detached 只用于白板 (inherit:false) 且不带 job —— 独立长住的 wizard 不归你管, 也不随工单回收" });
+                return;
+            }
             // 克隆的源头: 默认是调用方自己; `from` 点名就 fork 那个 wizard 此刻的上下文。
             // 分身仍归调用方管 (parent = self: 占它的预算、随它的工单回收), 只有上下文来自别处。
             // 空串不能交给 resolvePeer —— 那是「本聊天的默认 wizard」, 不是「我自己」。
@@ -1575,12 +1928,12 @@ const main = async () => {
                 json(res, 409, { ok: false, reason: `${displayName(source)} 没有可 fork 的会话 (还没说过话, 或绑定已失效)` });
                 return;
             }
-            const alivePeers = await m.peers(self);
+            const alivePeers = detached ? [] : await m.peers(self);
             // 预算。撞到上限不是"不许再分", 是"先把干完活的收掉": stop_wizard 收单个,
             // close_job 整批回收一个工单的临时分身。只数**本聊天里**活着的 ——
             // 生到别的聊天去的归那边管, 为了数它们再探一遍 tmux 不值当。
             const aliveKids = childrenOf(wizards.all(), self).filter((k) => alivePeers.some((pp) => pp.target === k.target && pp.paneAlive));
-            if (aliveKids.length >= cfg.wrc.mirror.cloneMax) {
+            if (!detached && aliveKids.length >= cfg.wrc.mirror.cloneMax) {
                 json(res, 429, {
                     ok: false,
                     reason: `你名下已经有 ${aliveKids.length} 个活着的分身 (上限 ${cfg.wrc.mirror.cloneMax}) —— 先 stop_wizard 收掉干完活的那些, 或者 close_job 整批回收一个工单`,
@@ -1599,77 +1952,104 @@ const main = async () => {
                 return;
             }
             const askedName = String(b.name ?? b.tag ?? "");
-            const slotR = await claimSlot(base, askedName, normalizeTag(b.description?.split(/\s+/)[0]) || "clone", [self, source]);
+            // 没起名: 独立长住的按目录名 (同 /new 与 new_claude_session), 分身按职责的首词。
+            const fallback = (detached && b.cwd ? tagFromCwd(b.cwd) : "") || normalizeTag(b.description?.split(/\s+/)[0]) || "clone";
+            const slotR = await claimSlot(base, askedName, fallback, [self, source]);
             if (!slotR.ok) {
                 json(res, slotR.status, slotR.body);
                 return;
             }
             const { target, slot: tag } = slotR;
+            // claimSlot 会复用同名的冷记录 (detached 正是「叫回一个老名字」的场景): 生不出来时
+            // 只回滚这一次的新记录, 不能把那个老 wizard 的记忆和家谱一起删掉。
+            const existed = !!wizards.get(target);
             const forkOf = inherit && source !== self ? source : undefined;
             // 先落身份再 spawn: 宪章是从注册表渲染出来的, 记录不在就渲染出一个无名分身。
             wizards.upsert(target, {
                 description: (b.description ?? "").toString().trim(),
-                parent: self,
+                // 显式写 undefined: upsert 是合并写, 复用的冷记录里旧的 parent 会留下来。
+                parent: detached ? undefined : self,
                 bornAt: Date.now(),
                 clonedFrom: inherit ? sourceInfo?.sessionId ?? "" : "",
                 ...(forkOf ? { forkOf } : {}),
+                // fork 了上下文就一并继承 self 记忆: 系统提示不随 fork 走 (分身拿的是自己的宪章),
+                // 不拷的话它开局就没有, /clear 或交接重开后更是彻底没了。标上来源; 已经是继承来的不再套一层。
+                ...(inherit ? { memory: (wizards.get(source)?.memory ?? []).map((x) => x.startsWith("(继承自 ") ? x : `(继承自 ${displayName(source)}) ${x}`) } : {}),
+                // 生完才清; 这个进程中途没了, 下次开机由 sweepUnborn 认出并收掉。
+                spawning: BOOT_ID,
             });
             const name = wizards.rename(target, normalizeTag(askedName) || tag);
-            const charter = charterFor(target, { parent: self, forkOf, inherited: inherit });
+            const charter = charterFor(target, { ...(detached ? {} : { parent: self }), forkOf, inherited: inherit });
             const task = (b.task ?? "").toString().trim();
             // 没点名就按配置的 keepalive.spawnDefault 来 —— 调用方明说的永远优先。
             const keepalive = typeof b.keepalive === "boolean" ? b.keepalive : cfg.wrc.mirror.keepalive.spawnDefault;
             // 先盖章再生: 分叉出来的 transcript 里躺着被克隆者的旧回复, 时刻早于这一枚章,
             // wait_peer 才不会把它们当成分身对这件活的答复。
             const taskAt = Date.now();
+            const taskTurn = newTurn();
+            const asker = task ? askerOf(self) : undefined;
             const r = await m.cloneSession({
                 parent: source,
                 target,
                 windowName: name,
                 cli: b.cli,
                 model: b.model,
+                effort,
                 cwd: b.cwd,
                 systemPrompt: charter,
                 inherit,
                 // 继承路径上第一句话是分叉的触发器, 所以直接把活当开场白 —— 少一次往返,
                 // 也少一次"就位了但没事干"的空转。
-                bootstrap: task ? task + envelopeFor(self, "") : undefined,
+                bootstrap: task ? task + envelopeFor(self, "", { turn: taskTurn }) : undefined,
+                ...(task ? { bootstrapFrom: { from: { kind: "peer", from: self, turn: taskTurn, ...(jobId ? { job: jobId } : {}), ...(asker ? { asker } : {}) }, query: task } } : {}),
                 keepalive,
-            });
+            }).catch((e) => ({ ok: false, reason: `spawn threw: ${String(e)}`, inherited: false }));
+            // 生不出来就回滚身份 —— 否则名字被一个永远没有会话的记录占住。
             if (!r.ok) {
-                wizards.drop(target);
+                if (existed)
+                    wizards.upsert(target, { spawning: undefined });
+                else
+                    wizards.drop(target);
                 json(res, 500, { ok: false, reason: r.reason });
                 return;
             }
-            wizards.upsert(target, { clonedFrom: r.inherited ? sourceInfo?.sessionId ?? "" : "", ...(r.inherited ? {} : { forkOf: undefined }) });
+            wizards.upsert(target, { spawning: undefined, clonedFrom: r.inherited ? sourceInfo?.sessionId ?? "" : "", ...(r.inherited ? {} : { forkOf: undefined }) });
             const kid = briefOf(self, target);
             // r.model 是 spawnTmuxClaude 通过 /model 实测确认落地的那个 —— 可能跟调用方
             // 传的原始字符串不一样 (口语化 → 目录里匹配到的关键词), 播报要报实情。
-            const modelNote = r.model
+            const modelNote = (r.model
                 ? (r.modelWarning ? ` · 模型 ${r.model} (⚠️ ${r.modelWarning})` : ` · 模型 ${r.model}`)
-                : "";
+                : "") + (r.effort ? ` · effort ${r.effort}` : "");
             // 出生不再发群气泡 (人要看的是结论, 不是谁生了谁 —— 过程在 rolepage 里);
             // 同群的 wizard 仍要知道群里多了一个成员。工单里的临时工连这条也省掉。
             if (!jobId) {
-                postRoster(base, [target, self], `新 wizard **.${name}** 就位${kid.description ? ` · ${kid.description}` : ""}${r.cwd ? ` · 工作区 ${r.cwd}` : ""}${modelNote}${keepalive ? "" : " · 已关闭 keepalive"} —— ${displayName(self)} 的分身${r.inherited ? ` (继承了${forkOf ? ` ${displayName(forkOf)} ` : "它"}的上下文)` : ""}`);
+                postRoster(base, [target, self], `新 wizard **.${name}** 就位${kid.description ? ` · ${kid.description}` : ""}${r.cwd ? ` · 工作区 ${r.cwd}` : ""}${modelNote}${keepalive ? "" : " · 已关闭 keepalive"} —— ${detached ? `空白起步, 由 ${displayName(self)} 造的` : `${displayName(self)} 的分身`}${r.inherited ? ` (继承了${forkOf ? ` ${displayName(forkOf)} ` : "它"}的上下文)` : ""}`);
             }
             // 继承路径上活已经随开场白进去了, 空白分身才需要在这里补一次注入 (私聊)。
             let dispatched = r.inherited && !!task;
             if (task && !r.inherited) {
-                const inj = await m.injectText(target, task, undefined, { from: { kind: "peer", from: self, ...(jobId ? { job: jobId } : {}) }, channel: "", envelope: envelopeFor(self, "") });
+                const inj = await m.injectText(target, task, undefined, { from: { kind: "peer", from: self, turn: taskTurn, ...(jobId ? { job: jobId } : {}), ...(asker ? { asker } : {}) }, channel: "", envelope: envelopeFor(self, "", { turn: taskTurn }) });
                 dispatched = inj.ok;
             }
             if (jobId)
                 jobs.attach(jobId, { target, task, spawned: true });
+            if (jobId && dispatched)
+                jobs.spend(jobId);
             // 分身的第一件活也守回执: fan-out 最常见的形状就是 clone_wizard({task}) × N,
             // 让它们干完自己把结论送回来, 发起方不必挂在 wait_peer 上。
+            const k = body.chain === false ? undefined : parentKOf(self);
             if (dispatched)
-                receipts.register({ from: self, to: target, channel: "", job: jobId, at: taskAt });
-            json(res, 200, { ok: true, target, name, address: name, inherited: r.inherited, sessionId: r.sessionId, cwd: r.cwd, dispatched, keepalive, ...(r.model ? { model: r.model } : {}), ...(r.modelWarning ? { modelWarning: r.modelWarning } : {}), ...(jobId ? { job: jobId } : {}) });
+                receipts.register({ from: self, to: target, channel: "", job: jobId, at: taskAt, turn: taskTurn, ...(k ? { k } : {}), ...(asker ? { asker } : {}) });
+            json(res, 200, { ok: true, target, name, address: name, inherited: r.inherited, sessionId: r.sessionId, cwd: r.cwd, dispatched, keepalive, ...(r.model ? { model: r.model } : {}), ...(r.modelWarning ? { modelWarning: r.modelWarning } : {}), ...(r.effort ? { effort: r.effort } : {}), ...(jobId ? { job: jobId } : {}), ...(detached ? { detached: true } : {}) });
         });
         // 收掉一个 wizard。interrupt = 打断它这一轮 (Esc); end = 结束它并回收 pane。
         // 自己终结自己是合法的 (分身干完活自我了结), 代价是这次工具调用不会返回 ——
         // 回执只在 rolepage (生命周期事件不进群); 同群的 wizard 从名册增量里得知。
+        /** 抹掉一个 wizard 的身份; 它在开着的工单里没落定的那一份记成 canceled —— 名字都没了, 不会再落定。 */
+        const forgetWizard = (target) => {
+            wizards.drop(target);
+            return jobs.detach(target);
+        };
         http.register("POST /wizard/stop", async (req, res) => {
             const { self, body } = await readPeerBody(req);
             if (!self) {
@@ -1678,6 +2058,15 @@ const main = async () => {
             }
             const b = body;
             const r = resolvePeer(self, addrOf(b));
+            // 有身份没会话 (冷记录 / 生到一半的僵尸): resolvePeer 够不着它, 但收它不需要
+            // 会话 —— end 视为早已结束, forget 删掉记录、腾出名字。interrupt 无从谈起。
+            const found = r.ok || r.candidates?.length ? undefined : wizards.byName(addrOf(b));
+            const cold = found && !m.chatTargets(baseOfKey(found.target)).includes(found.target) ? found : undefined;
+            if (cold && (b.mode ?? "end") === "end") {
+                const detached = b.forget ? forgetWizard(cold.target) : [];
+                json(res, 200, { ok: true, target: cold.target, name: cold.name, mode: "end", forgotten: !!b.forget, note: "它本来就没有会话在跑", ...(detached.length ? { canceledIn: detached } : {}) });
+                return;
+            }
             if (!r.ok) {
                 json(res, r.status, { ok: false, reason: r.reason, candidates: r.candidates });
                 return;
@@ -1689,20 +2078,56 @@ const main = async () => {
                 json(res, 400, { ok: false, reason: "打断自己没有意义 —— 你就是正在生成的那一个" });
                 return;
             }
+            // 按件号撤回自己派的那一件: 它此刻正在做的就是这件才按 Esc; 否则 (排着 / 在做别人的)
+            // 只把这件记成 canceled —— 它之后答出来也不再回执, 手上别人的那一轮不受影响。
+            const turn = (b.turn ?? "").replace(/[`\s]/g, "");
+            if (!end && turn) {
+                const mine = receipts.pending(self, target);
+                if (mine?.turn !== turn) {
+                    json(res, 404, { ok: false, reason: `你没有在等 ${victim.name ? `.${victim.name}` : target} 答 '${turn}' 这件 (已落定、件号写错, 或不是你派的)` });
+                    return;
+                }
+                // 先落 canceled 再按 Esc: 被打断那一轮的半截话不该被 watcher 当成答案投回来。
+                const busy = !(await m.idleNow(target));
+                const canceled = receipts.cancel(target, self, (x) => x.from === self && x.turn === turn);
+                // 按 Esc 之前再认一次手上这一轮: 上面那次 await 期间它可能已经做完这件、接了别人的下一件。
+                const current = busy && openingAsk(target)?.turn === turn;
+                // 还没轮到 / 排在后面: 捎一句给它, 轮到那句话时别再做了 (notices 挂在下一条注入的尾巴上)。
+                if (!current)
+                    notices.post([target], `${displayName(self)} 撤回了它派给你的 ${turn} —— 那件活不用做了; 读到它时直接略过, 不必回复。`);
+                // 只按 Esc, 不 teardown: teardown 会清掉它的注入队列, 别人排着的话一起丢。
+                const esc = current ? await m.interruptPane(target) : undefined;
+                // Esc 没按成也不回滚撤回: 这件已经不等了, 只是它手上那一轮还在跑 —— 如实说。
+                json(res, 200, {
+                    ok: true, target, name: victim.name, mode: "interrupt", turn, canceled, interrupted: !!esc?.ok,
+                    ...(esc && !esc.ok ? { note: `这件已撤回 (不会再回执给你), 但 Esc 没按成 (${esc.reason ?? "unknown"}), 它这一轮可能还在跑` } : {}),
+                    ...(current ? {} : { note: "它此刻没在做这件 (还排着, 或在做别人的活), 没按 Esc —— 这件已撤回, 它之后答出来也不会再回执给你" }),
+                });
+                return;
+            }
+            // 不带件号的打断会停掉它手上整轮: 那一轮若是别的 wizard 派的, 先拒 —— 误伤的是别人的活。
+            const others = !end && !b.force ? await othersTurn(target, self) : undefined;
+            if (others) {
+                json(res, 409, { ok: false, target, reason: `它此刻在做 ${others.from} 派的活${others.turn ? ` (${others.turn})` : ""}, 打断会连那件一起停掉 —— 只想撤回你自己派的那件, 传 turn (件号); 确要打断它这一轮, 加 force:true` });
+                return;
+            }
+            // 先落 canceled 再动 pane: pane 一死, 守着的 watcher 会把同一份报成 dead。
+            // 打断只停它手上这一轮: 只掐这一轮开头那句派来的活 (人 / 定时 / 回执轮不掐任何一份)。
+            const canceled = receipts.cancel(target, self, end ? undefined : currentAsk(target));
             const done = end ? await m.killPane(target) : await m.interruptPane(target, { teardown: true });
             if (!done.ok) {
                 json(res, 502, { ok: false, target, reason: done.reason });
                 return;
             }
-            if (end && b.forget)
-                wizards.drop(target);
+            const detached = end && b.forget ? forgetWizard(target) : [];
             // 打断只是停了它这一轮, 它还在; 只有结束才是名册变了。
             if (end)
                 postRoster(baseOfKey(target), [target, self], `**${victim.name || target}** 已收工 · 由 ${displayName(self)} 结束${b.forget ? " (记录一并抹掉)" : ""}`);
-            json(res, 200, { ok: true, target, name: victim.name, mode: end ? "end" : "interrupt", forgotten: !!(end && b.forget) });
+            json(res, 200, { ok: true, target, name: victim.name, mode: end ? "end" : "interrupt", forgotten: !!(end && b.forget), ...(canceled ? { canceled } : {}), ...(detached.length ? { canceledIn: detached } : {}) });
         });
-        // 换模型: 省略名字 = 换自己 (选择器盖在正在跑的这一轮上面照样能开), 点名 = 换
-        // 那个 wizard。与 spawn 时的 `model` 是同一条路 (model-select.ts)。
+        // 换模型 / effort: 省略名字 = 换自己 (选择器盖在正在跑的这一轮上面照样能开), 点名 =
+        // 换那个 wizard。与 spawn 时的 `model` 是同一条路 (model-select.ts); effort 走
+        // `/effort` 档位条的「只本会话」键, 不碰全机默认。两样都给就先模型后档位。
         http.register("POST /wizard/model", async (req, res) => {
             const { self, body } = await readPeerBody(req);
             if (!self) {
@@ -1711,8 +2136,13 @@ const main = async () => {
             }
             const b = body;
             const model = (b.model ?? "").toString().trim();
-            if (!model) {
-                json(res, 400, { ok: false, reason: "model 必填 —— 口语化写就行 ('opus' / 'haiku' / 'sonnet 5')" });
+            const effort = parseEffort(b.effort);
+            if (b.effort !== undefined && !effort) {
+                json(res, 400, { ok: false, reason: `effort 只有这几档: ${EFFORTS.join(" / ")}` });
+                return;
+            }
+            if (!model && !effort) {
+                json(res, 400, { ok: false, reason: "model / effort 至少给一个 —— model 口语化写就行 ('opus' / 'haiku' / 'sonnet 5')" });
                 return;
             }
             const scope = (b.scope ?? "session").toString().trim();
@@ -1727,8 +2157,18 @@ const main = async () => {
                 json(res, r.status, { ok: false, reason: r.reason, candidates: r.candidates });
                 return;
             }
-            const done = await m.setModel(r.target, model, scope);
-            json(res, done.ok ? 200 : 502, { ...done, target: r.target, name: briefOf(self, r.target).name, ...(done.ok ? { model: done.applied } : {}) });
+            const done = model ? await m.setModel(r.target, model, scope) : undefined;
+            const eff = effort && (done?.ok ?? true) ? await m.setEffort(r.target, effort) : undefined;
+            const ok = (done?.ok ?? true) && (eff?.ok ?? true);
+            json(res, ok ? 200 : 502, {
+                ...done,
+                ok,
+                target: r.target,
+                name: briefOf(self, r.target).name,
+                ...(done?.ok ? { model: done.applied } : {}),
+                ...(eff?.ok ? { effort: eff.applied } : {}),
+                ...(eff && !eff.ok ? { reason: [done?.reason, `effort: ${eff.reason}`].filter(Boolean).join("; ") } : {}),
+            });
         });
         // 自我交接: 上下文撑不住了, 自己把工作压成简报, /new 换一个全新进程, 再把简报贴
         // 回去。和 /handoff 的区别是**简报由调用方自己写在入参里** —— 它没法在自己
@@ -1740,15 +2180,8 @@ const main = async () => {
                 json(res, 400, { ok: false, reason: "cannot resolve caller session" });
                 return;
             }
-            const brief = (body.brief ?? "").toString().trim();
-            if (brief.length < 40) {
-                json(res, 400, { ok: false, reason: "brief 太短 —— 要写到零上下文也能接手: 目标 / 已完成 / 当前状态 / 下一步 / 关键文件与坑" });
-                return;
-            }
-            const info = m.sessionInfo(self);
-            // 应答之后再干活: 调用方此刻还在生成, 交接要等它把话说完 (见 handoff.ts)。
-            const r = handoffs.self(self, brief);
-            json(res, r.ok ? 200 : 409, r.ok ? { ok: true, target: self, contextTokens: info?.contextTokens ?? 0, scheduled: true } : { ok: false, reason: r.reason });
+            const r = handoffSelf(self, (body.brief ?? "").toString().trim());
+            json(res, r.status, r.body);
         });
         // ── Job: 一次 fan-out 的工单 ─────────────────────────────────────────
         // 账本, 不是编排器: 控制流留在发起的那个 wizard 手里 (它自己 spawn / wait /
@@ -1762,19 +2195,23 @@ const main = async () => {
             }
             const b = body;
             const title = (b.title ?? "").toString().trim();
+            const expect = Math.min(JOB_MEMBER_MAX, Math.max(0, Math.floor(Number(b.expect) || 0)));
             if (!title) {
                 json(res, 400, { ok: false, reason: "title required —— 一句话说清这个工单要干成什么" });
                 return;
             }
             const base = baseOfKey(self);
-            const job = jobs.open(base, self, title);
-            notifyChat(base, renderJobOpen(job, (b.plan ?? "").toString()));
+            const maxTurns = Math.min(200, Math.max(0, Math.floor(Number(b.maxTurns) || 0)));
+            const plan = (b.plan ?? "").toString().trim();
+            // 不出群气泡: 工单是私下的过程, 人看到的只有发起者那一轮的最终回复。
+            const accept = ACCEPTS.find((x) => x === b.accept);
+            const job = jobs.open(base, self, title, { ...(plan ? { plan } : {}), ...(accept ? { accept } : {}), ...(expect ? { expect } : {}), ...(maxTurns ? { maxTurns } : {}) });
             json(res, 200, {
                 ok: true,
                 job: job.id,
                 title,
                 memberMax: JOB_MEMBER_MAX,
-                hint: "把这个 id 传给 spawn_wizard / clone_wizard / send_peer 的 `job` 参数, 它们就归到这个工单名下 (期间不再逐条出气泡); 活干完调 close_job 收尾并回收临时分身。",
+                hint: "把这个 id 传给 spawn_wizard / clone_wizard / tell_peer 的 `job` 参数, 它们就归到这个工单名下 (一律私聊, 不进群); 活干完调 close_job 留档并回收临时分身, 给人的结论写在你自己这一轮的最终回复里。",
             });
         });
         http.register("POST /jobs/close", async (req, res) => {
@@ -1798,9 +2235,18 @@ const main = async () => {
             // 活结束就被杀掉。调用方自己也不收 —— 那会在这次工具调用里把自己干掉。
             const recycle = b.stop !== false;
             const victims = recycle ? job.members.filter((mm) => mm.spawned && mm.target !== self) : [];
+            // 收掉之前把它们手上没落定的活记成 canceled: 不然发起者收工之后还会收到一串 dead 回执。
+            victims.forEach((mm) => receipts.cancel(mm.target, self));
+            // 留档要的 sessionId 得在回收之前取: killPane 连绑定一起删。
+            const sids = new Map([job.owner, ...job.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));
             const closed = jobs.close(id, (b.summary ?? "").toString());
-            notifyChat(job.base, renderJobClose(closed, (t) => relayLabel(t, job.base), killed));
+            // 收工结论留档到开单者名下 (与交接简报同一份 jsonl); 空工单 (没人、没结论) 不记。
+            if (closed.members.length || closed.summary?.trim()) {
+                const ep = jobEpisode(closed, { nameOf: episodeName, sidOf: (t) => sids.get(t) ?? "", chat: chatNameOf(cfg, job.base) || job.base });
+                if (!appendEpisode(episodePath(cfg.daemon.stateDir, ep.name), ep))
+                    log.warn({ job: id, name: ep.name }, "job episode not archived");
+            }
             json(res, 200, { ok: true, job: id, members: closed.members.length, recycled: killed, kept: victims.length - killed });
         });
         http.register("POST /jobs/list", async (req, res) => {
@@ -1809,6 +2255,7 @@ const main = async () => {
                 json(res, 400, { ok: false, reason: "cannot resolve caller session" });
                 return;
             }
+            const inflight = receipts.states();
             json(res, 200, {
                 ok: true,
                 jobs: jobs.openOf(baseOfKey(self)).map((j) => ({
@@ -1817,7 +2264,15 @@ const main = async () => {
                     owner: displayName(j.owner),
                     mine: j.owner === self,
                     openedAt: j.openedAt,
-                    members: j.members.map((mm) => ({ address: peerAddress(cfg, self, mm.target), task: mm.task.split("\n")[0] ?? "", spawned: mm.spawned })),
+                    ...jobs.tally(j.id),
+                    ...(j.maxTurns ? { budget: `${j.turns ?? 0}/${j.maxTurns}` } : {}),
+                    members: j.members.map((mm) => ({
+                        address: peerAddress(cfg, self, mm.target),
+                        task: mm.task.split("\n")[0] ?? "",
+                        spawned: mm.spawned,
+                        state: mm.outcome ?? inflight.find((x) => x.to === mm.target && x.job === j.id)?.state ?? "unknown",
+                        ...(mm.artifacts?.length ? { artifacts: mm.artifacts } : {}),
+                    })),
                 })),
             });
         });
@@ -1826,7 +2281,7 @@ const main = async () => {
         // (injectText), 所以 pane 死了会被拉起来, 输出照常落进群和详情页。
         /** 日程归谁: 排班那个 wizard (createdBy); 老文件没写就归执行它的那个。 */
         const ownerOf = (t) => t.owner || (cfg.defaultChat ?? "");
-        http.register("POST /tasks/schedule", async (req, res) => {
+        http.register("POST /tasks/schedule", guarded(async (req, res) => {
             const { self, body } = await readPeerBody(req);
             if (!self) {
                 json(res, 400, { ok: false, reason: "cannot resolve caller session" });
@@ -1865,7 +2320,7 @@ const main = async () => {
             const fresh = typeof b.fresh === "boolean" ? b.fresh : !tag || promptWantsFreshWizard(prompt);
             const note = (b.note ?? "").toString();
             const id = uniqueId(slugify((b.id ?? "").toString() || note || prompt.slice(0, 24), "task"), tasks.takenIds());
-            const created = tasks.create({ id, trigger, prompt, target, fresh, note, createdBy: self });
+            const created = tasks.create({ id, trigger, prompt, target, fresh, quiet: b.quiet === true, note, createdBy: self });
             if ("error" in created) {
                 json(res, 400, { ok: false, reason: created.error });
                 return;
@@ -1877,7 +2332,7 @@ const main = async () => {
                 address: peerAddress(cfg, self, target),
                 owner: peerAddress(cfg, self, self),
             });
-        });
+        }));
         http.register("POST /tasks/list", async (req, res) => {
             const { self, body } = await readPeerBody(req);
             if (!self) {
@@ -1920,12 +2375,13 @@ const main = async () => {
             }
             json(res, 200, { ok: true, removed: renderTask(gone, state) });
         });
-        // POST /config/set — modify daemon config from MCP
-        http.register("POST /config/set", async (req, res) => {
+        // POST /config/set — modify daemon config from MCP. 口令门见 `guarded`; 模型还得先过
+        // config_set 的审批卡 (danger.ts) 才走得到这里。
+        http.register("POST /config/set", guarded(async (req, res) => {
             const body = (await readBody(req));
             const r = configSet(cfg, sourcePath, body.key, body.value, body.action);
             json(res, r.ok ? 200 : 400, r);
-        });
+        }));
         http.register("POST /config/get", async (req, res) => {
             const body = (await readBody(req));
             const r = configGet(cfg, body.key);
@@ -2027,12 +2483,74 @@ const main = async () => {
         // 还要连触发时间点一起被它那一轮拖走。所以到点起一个白板 wizard 单独执行,
         // 跑完自动收掉。只有排班时点名了某个 wizard (fresh=false) 且它此刻闲着,
         // 才把这句话直接投进它那一轮 —— 「在已有会话里继续」是要求出来的, 不是默认。
-        scheduledTaskInject = async (target, text, { taskId, fresh }) => {
+        scheduledTaskInject = async (target, text, { taskId, fresh, quiet }) => {
+            // 安静任务私下跑 (channel ""): 镜像不推它的任何一句, 终句由 relayUnlessQuiet 判断要不要进群。
+            const inNamed = async () => {
+                const at = Date.now();
+                const turn = newTurn();
+                const inj = await m.injectText(target, text, undefined, quiet
+                    ? { from: { kind: "task", taskId }, channel: "", envelope: renderTaskEnvelope(taskId, { turn }) }
+                    : { fromChat: true, from: { kind: "task", taskId }, envelope: renderTaskEnvelope(taskId) });
+                if (inj.ok && quiet)
+                    void relayUnlessQuiet(target, at, turn, baseOfKey(target));
+                return inj;
+            };
             if (!fresh)
                 await handedOff(target); // 交接中途 pane 是空的, 别当成闲着投进去
             const busy = fresh ? false : await m.isBusy(target);
             if (!fresh && !busy)
-                return m.injectText(target, text, undefined, { fromChat: true, from: { kind: "task", taskId }, envelope: renderTaskEnvelope(taskId) });
+                return inNamed();
+            // 点名的目标正忙: 顺延到它这一轮结束再投 (与 tell_peer 默认的 normal 同一口径) ——
+            // 「在它那儿继续」是排班时要求的, 不该因为撞上它在干活就换成白板。后台等, 别拖住
+            // 调度器的其它任务; 等满 30 分钟仍忙才退回起白板。
+            const inRunner = (wasBusy) => runTaskInRunner(target, text, taskId, quiet, wasBusy);
+            if (!fresh && busy) {
+                // 同一条任务已有一枪在等这个目标: 这一枪并进去 —— 等它闲下来时几枪一起投, 会挤进同一个输入框。
+                if (postponed.has(taskId))
+                    return { ok: true, reason: "上一枪还在等它闲下来, 这一枪并入" };
+                postponed.add(taskId);
+                void (async () => {
+                    const wr = await m.untilIdle(target, TASK_POSTPONE_MS);
+                    postponed.delete(taskId);
+                    const r = wr.idle ? await inNamed() : await inRunner(true);
+                    log.info({ taskId, target, postponed: true, idle: wr.idle, ok: r.ok, reason: r.reason }, "scheduled task: 目标正忙, 顺延");
+                    if (!r.ok)
+                        notifyChat(baseOfKey(target), withTagHeader(target, `⏰ 定时任务 \`${taskId}\` 顺延后注入失败: ${r.reason ?? "unknown"}`));
+                })();
+                return { ok: true, reason: "目标正忙, 顺延到它闲下来" };
+            }
+            return inRunner(busy);
+        };
+        /** 顺延中的任务 (内存即可: reload 丢了只是少放一枪, 下一次到点照常)。 */
+        const postponed = new Set();
+        /** 安静任务那一轮的终句: 它私下跑, 镜像不推; 等它这一轮跑完, 终句不是 `QUIET` 就替它
+         *  发进群 (头写它的名字, 人知道是谁说的)。按信封件号定位答句 (同回执): 按时刻取会把紧随
+         *  其后的私聊 / 人话那一轮的答案当成它的, 把私下内容发进群。 */
+        const relayUnlessQuiet = async (t, at, turn, base) => {
+            quietRelays.set(turn, { target: t, at, base });
+            const end = at + TASK_QUIET_WAIT_MS;
+            // 先等它动起来: 刚注入时注册表还报 idle。
+            await sleep(5000);
+            while (Date.now() < end) {
+                await m.untilIdle(t, end - Date.now());
+                const reply = (m.replyToPeer(t, "", at, turn)?.text ?? "").trim();
+                if (reply && (await m.idleNow(t))) {
+                    if (!isQuiet(reply))
+                        notifyChat(base, withTagHeader(t, reply));
+                    log.info({ target: t, quiet: isQuiet(reply), len: reply.length }, "quiet task: 一轮结束");
+                    quietRelays.drop(turn);
+                    return;
+                }
+                await sleep(5000);
+            }
+            log.warn({ target: t }, "quiet task: 等满仍没收口, 不转发");
+            quietRelays.drop(turn);
+        };
+        // 落盘: 这个仓库里 reload 是常态, 守在内存里的那一轮一 reload 就既不转发也不说 QUIET 了。
+        const quietRelays = loadJsonMap(join(cfg.daemon.stateDir, "quiet-relays.json"), (rows) => Object.fromEntries(Object.entries(rows).filter(([, r]) => Date.now() - r.at < TASK_QUIET_WAIT_MS)));
+        void m.restored.then(() => Object.entries(quietRelays.all()).forEach(([turn, r]) => void relayUnlessQuiet(r.target, r.at, turn, r.base)));
+        /** 到点起一个白板 wizard 执行这一枪, 跑完自动收掉。 */
+        const runTaskInRunner = async (target, text, taskId, quiet, busy) => {
             // 执行体挂在日程的主人名下: 名字 `<主人>-task-xxxx`, parent = 主人 —— 它的
             // rolepage 里看得见这一枪是谁的日程放的。落在执行目标的群/目录里。
             const base = baseOfKey(target);
@@ -2056,10 +2574,16 @@ const main = async () => {
                 wizards.drop(runner);
                 return { ok: false, reason: `起白板 wizard 失败: ${spawned.reason ?? "unknown"}` };
             }
-            notifyChat(base, withTagHeader(target, busy
-                ? `⏰ 定时任务到点时正忙, 已起白板 wizard .${runnerName} 单独执行, 完成后自动收掉`
-                : `⏰ 定时任务已起白板 wizard .${runnerName} 执行, 完成后自动收掉`));
-            const inj = await m.injectText(runner, text, undefined, { fromChat: true, from: { kind: "task", taskId }, envelope: renderTaskEnvelope(taskId) });
+            if (!quiet) {
+                notifyChat(base, withTagHeader(target, busy
+                    ? `⏰ 定时任务到点时正忙, 已起白板 wizard .${runnerName} 单独执行, 完成后自动收掉`
+                    : `⏰ 定时任务已起白板 wizard .${runnerName} 执行, 完成后自动收掉`));
+            }
+            const at = Date.now();
+            const turn = newTurn();
+            const inj = await m.injectText(runner, text, undefined, quiet
+                ? { from: { kind: "task", taskId }, channel: "", envelope: renderTaskEnvelope(taskId, { turn }) }
+                : { fromChat: true, from: { kind: "task", taskId }, envelope: renderTaskEnvelope(taskId) });
             if (!inj.ok) {
                 wizards.drop(runner);
                 return inj;
@@ -2068,6 +2592,9 @@ const main = async () => {
             // 内没闲下来就放弃自动回收 (它大概率还在干一个长活), 留给人手动处理 ——
             // 比杀掉一个还在跑的 pane 安全。
             void (async () => {
+                // 安静任务先把终句取走 (收掉 pane 之后就读不到了)。
+                if (quiet)
+                    await relayUnlessQuiet(runner, at, turn, base);
                 const idle = await waitForIdle(runner, m.isBusy, 30 * 60_000, () => false);
                 if (!idle.idle) {
                     log.warn({ runner, reason: idle.reason }, "task runner: 30min 未闲下来, 放弃自动回收");
@@ -2078,6 +2605,66 @@ const main = async () => {
             })();
             return inj;
         };
+        // 记忆整理者的一轮: 在内部 key 上起白板 wizard, 私聊注入, 闲下来就收 —— 全程不碰
+        // 任何群 (silent spawn、channel ""、无 notifyChat)。它没有人能点审批卡, 所以这一轮
+        // 给它的 key 开一个 ⏱ 窗口; 危险名单照旧逐条要卡, 而它的活 (读收件箱、改 md) 不在其列。
+        stewardRun = async (prompt) => {
+            const target = STEWARD_TARGET;
+            wizards.upsert(target, { description: "共享记忆整理的一次性执行体 (守护进程内建, 不属于任何群)", bornAt: Date.now() });
+            const name = wizards.rename(target, "memsteward-run");
+            setAutoWindow(target, STEWARD_RUN_MS + 5 * 60_000);
+            const done = async (r) => {
+                await m.killPane(target).catch(() => undefined);
+                wizards.drop(target);
+                clearAutoWindow(target);
+                return r;
+            };
+            const spawned = await m.newSession(target, name, undefined, { cwd: memoryRoot(cfg.daemon.stateDir), silent: true, keepalive: false });
+            if (!spawned.ok)
+                return done({ ok: false, reason: `spawn: ${spawned.reason ?? "unknown"}` });
+            const inj = await m.injectText(target, prompt, undefined, { from: { kind: "task", taskId: STEWARD_ID }, channel: "", envelope: stewardEnvelope() });
+            if (!inj.ok)
+                return done(inj);
+            // 超时也收: 没人会对它喊 stop_wizard; 认领留着, 孤儿回收会再派一轮。
+            const idle = await waitForIdle(target, m.isBusy, STEWARD_RUN_MS, () => false);
+            return done(idle.idle ? { ok: true } : { ok: false, reason: idle.reason });
+        };
+        // 整理者与在场 wizard 之间的两根线 (memory.md ①②): 合并前给它看 CLAUDE.md /
+        // auto-memory 好去重, 合并后告诉读这份 md 的 wizard —— 它们的宪章是出生时的快照。
+        // md ↔ wizard 一律正向算 (mdsOf / cwdOfMd), 不从文件名反推。
+        const stateDir = cfg.daemon.stateDir;
+        // 全量绑定 (含冷的), 与 settleAll 同一份 —— 不依赖身份记录在不在。
+        const boundTargets = () => m.chatRoster("").flatMap((c) => c.targets).filter((t) => !isInternalKey(t));
+        const cwdOfTarget = (t) => { const c = m.getCwd(t); return c.runningCwd || c.defaultCwd; };
+        // 人和各家 CLI 自己读的那几份项目说明 + 各 backend 的 auto-memory 索引。
+        const PROJECT_DOCS = ["CLAUDE.md", "CODEBUDDY.md", "AGENTS.md", join(".claude", "CLAUDE.md")];
+        stewardWiring = {
+            refsOf: (md) => {
+                // cwd 候选: 提议里带的 (提议者可能早收工了) + 在场绑定的; 再正向算出 md 比对。
+                const cwds = [...new Set([...proposedCwds(stateDir), ...boundTargets().map(cwdOfTarget)].filter(Boolean))];
+                const cwd = cwdOfMd(stateDir, md, cwds);
+                if (!cwd)
+                    return [];
+                return [...PROJECT_DOCS.map((f) => join(cwd, f)), ...projectDirsFor(cwd).map((d) => join(d.dir, "memory", "MEMORY.md"))].filter((f) => existsSync(f));
+            },
+            // 只投给 pane 活着的: 冷的那些醒来时宪章重渲染, 新记忆已在里面, 再提一句就重复了。
+            onMerged: (mds) => void (async () => {
+                const changed = new Set(mds);
+                const snap = await runTmux(["list-panes", "-a", "-F", "#{pane_id}"]);
+                if (!snap.ok)
+                    return;
+                const live = new Set(snap.stdout.split("\n").map((l) => l.trim()).filter(Boolean));
+                for (const t of boundTargets()) {
+                    const pane = m.sessionInfo(t)?.tmuxPane;
+                    if (!pane || !live.has(pane))
+                        continue;
+                    const where = (scope) => (scope === "workspace" ? "本工作区" : baseOfKey(t).startsWith("user:") ? "本单聊" : "本群");
+                    for (const h of mdsOf(stateDir, baseOfKey(t), cwdOfTarget(t)).filter((x) => changed.has(x.md))) {
+                        notices.post([t], `${where(h.scope)}记忆已更新, 全文见 \`${h.md}\``);
+                    }
+                }
+            })().catch((e) => log.warn({ err: e.message }, "memory steward: notice fan-out failed")),
+        };
     }
     // 定时调度器 — 每 20s 检查任务表, 到点把 prompt 注入目标 wizard。
     migrateLegacySchedules(cfg, sourcePath, tasks, log.child({ mod: "tasks" }));
@@ -2090,6 +2677,10 @@ const main = async () => {
         cwdOf: (t) => { const c = bridge.getCwd(t); return c.runningCwd || c.pendingCwd || c.defaultCwd; },
         fallbackTarget: () => (cfg.defaultChat ?? "").trim(),
     });
+    // 共享记忆整理 — daemon 内建, 不进任务表 / 日程, 不出任何气泡。
+    const steward = stewardRun
+        ? startSteward({ root: memoryRoot(cfg.daemon.stateDir), log: log.child({ mod: "steward" }), run: stewardRun, ...stewardWiring })
+        : undefined;
     // pane 上限 — 每新建一个 wizard 数一次: 活着的会话 pane 超过 wrc.mirror.maxPanes
     // (默认 20, 0=关) 就从最久没动的收起。数量只在出生时增长, 所以不设定时器。只收
     // pane 不收绑定: 下一条消息 `--resume` 复活。豁免: 名下有定时任务的 wizard (调度
@@ -2114,6 +2705,7 @@ const main = async () => {
     const shutdown = async (signal) => {
         log.info({ signal }, "shutdown signal");
         scheduler.stop();
+        steward?.stop();
         tasks.stop();
         netWatch.stop();
         // 同 POST /shutdown: 先把挂着的审批长轮询了结成「稍后续接」, 再关连接。