wezard 2.0.0 → 2.0.2

package/dist/daemon/index.js

@@ -7,9 +7,7 @@ import { startNetWatch } from "./net-watch.js";
 import { startHttp, json, readBody } from "./http.js";
 import { configGet, configSet } from "./config-api.js";
 import { installInboundRouter } from "./inbound.js";
-import { loadSessionStore } from "./sessions.js";
 import { loadMirrorStore } from "./mirror-store.js";
-import { makeBridge } from "./cc-bridge.js";
 import { startMirror, installMirrorEventListener } from "./mirror-bridge.js";
 import { setTmuxTimeoutReporter, spawnTmuxClaude } from "./spawn-tmux.js";
 import { installApprovalEventListener, makeApproveHandler } from "./approval.js";
@@ -28,9 +26,10 @@ 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 { appendMemory, forgetMemory, memoryPath, readMemory } from "./wizard-memory.js";
+import { clipForCharter, inboxPath, memoryPath, memoryRoot, proposeMemory, readMemory } from "./wizard-memory.js";
+import { ensureStewardTask } from "./memory-steward.js";
 import { applyChatNames, chatBaseOf, chatNameOf, clearChatName, listChatNames, normChatName, peerAddress, planChatNames, setChatName } from "./chat-name.js";
-import { bindWizardStore, loadWizardStore, wizardStore, settleName, settleAll, childrenOf, ancestorsOf, renderCharter, } from "./wizard.js";
+import { bindWizardStore, loadWizardStore, wizardStore, settleName, settleAll, evictStaleName, childrenOf, ancestorsOf, renderCharter, } from "./wizard.js";
 import { bindNoticeBox, createNoticeBox, chatAudience } from "./notices.js";
 import { loadJobStore, renderJobOpen, renderJobClose, JOB_MEMBER_MAX } from "./jobs.js";
 import { extractResult } from "./peers.js";
@@ -80,23 +79,22 @@ const main = async () => {
     // last-response tracker enables inbound's `quote` dedup of bot self-replies,
     // and its chat-gate drops header-only pushes (empty messages) daemon-wide.
     installResponseTracker(ws.client, log.child({ mod: "chat-gate" }));
-    const sessions = loadSessionStore(cfg.wrc.sessionMapFile);
     const mirrorStore = loadMirrorStore(cfg.wrc.mirror.attachmentsFile);
     // 定时任务表 —— 每条任务是 ~/.wezard/tasks/<id>.task.mjs 一份可注入代码的配置
     // (见 shared/task-file.ts)。目录是热加载的: wizard 改完文件不用 reload 守护进程。
-    const tasks = await openTaskRegistry(log.child({ mod: "tasks" }), (added, removed) => log.info({ added, removed }, "task files changed"));
-    const bridge = cfg.wrc.mode === "mirror"
-        ? startMirror({ cfg, log: log.child({ mod: "mirror" }), client: ws.client, store: mirrorStore })
-        : makeBridge({ cfg, log: log.child({ mod: "bridge" }), client: ws.client, sessions });
-    if (!bridge) {
-        log.fatal("bridge failed to start");
-        fatalExit("bridge failed to start");
+    // 共享记忆的整理者是一条定时任务 (memory-steward.ts), 缺了就补一份默认的。
+    try {
+        ensureStewardTask(memoryRoot(cfg.daemon.stateDir));
     }
+    catch (e) {
+        log.warn({ err: e.message }, "memory steward task not written");
+    }
+    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 });
     // 群里每个 `.name` 都挂它的 rolepage (见 session-label 的 TagLinker)。正文提及
-    // 只认真有其人的 —— 随手写的 `.gitignore` 不该变成一个开在空栏上的链接; headless
-    // 没有 wizard 名册, 只挂头。
-    const known = cfg.wrc.mode === "mirror" ? (t) => bridge.chatTargets(t).includes(t) : () => false;
-    // 名册在 mirror 块里才绑 (bindWizardStore) —— 这里全走 wizardStore() 惰性取。
+    // 只认真有其人的 —— 随手写的 `.gitignore` 不该变成一个开在空栏上的链接。
+    const known = (t) => bridge.chatTargets(t).includes(t);
+    // 名册在下面的 mirror 块里才绑 (bindWizardStore) —— 这里全走 wizardStore() 惰性取。
     bindTagLinker({
         urlOf: (t) => chatUrlFor(cfg.daemon, t, baseOfKey(t).replace(/^(user|chat|group):/, "")),
         resolve: (name) => {
@@ -109,50 +107,29 @@ const main = async () => {
     // approval click → finalize 当前 liveStream, 后续 tool/text 落到 standalone。
     // 规则 2: 用户点击授权那一刻就是"上一段对话"的边界, 截断 stream 让授权后的
     // 工作单独成块, 比让 stream 一直长到下一个 inbound / hardTimer 更清晰。
-    // headless 模式没有 liveStream 概念, onApproved 只在 mirror 模式接。
-    const onApproved = cfg.wrc.mode === "mirror"
-        ? (sid) => bridge.terminateLiveStream(sid)
-        : undefined;
+    const onApproved = (sid) => bridge.terminateLiveStream(sid);
     installApprovalEventListener(ws.client, log.child({ mod: "approval" }), cfg, onApproved);
     // Route approval cards to the WeCom chat bound to the requesting session.
-    // mirror: the chat this session's pane is attached to; headless: the principal
-    // (user:/chat:) that /wrc-dispatched this session — reverse of the sessions store.
-    // Falls back to cfg.approval.approvers / cfg.defaultChat when nothing is bound.
-    const getMirrorTarget = cfg.wrc.mode === "mirror"
-        ? (sid) => bridge.targetForSession(sid)
-        : (sid) => {
-            for (const [principal, s] of Object.entries(sessions.all())) {
-                if (s === sid)
-                    return principal;
-            }
-            return undefined;
-        };
+    // — the chat this session's pane is attached to. Falls back to
+    // cfg.approval.approvers / cfg.defaultChat when nothing is bound.
+    const getMirrorTarget = (sid) => bridge.targetForSession(sid);
     // Pre-card barrier: drain pending mirror text/tool markdown for this session
     // and await its FIFO so vote/approval cards never overtake the "thinking" bubble.
-    // Headless mode has no mirror pipe — leave undefined so approval skips the call.
-    const flushBeforeCard = cfg.wrc.mode === "mirror"
-        ? (sid, expect) => bridge.flushBeforeCard(sid, expect)
-        : undefined;
+    const flushBeforeCard = (sid, expect) => bridge.flushBeforeCard(sid, expect);
     // `.claude/**` 写守卫要用的四个 pane 原语。cancel/tell 复用现成的 target 级方法
     // (先 sessionId → target 再调), 只有 hasPane / answerNativeModal 是 pane 级新增。
-    // headless 模式没有 live pane 可按 → 留 undefined, 守卫自动不介入。
-    const nativeModal = cfg.wrc.mode === "mirror"
-        ? (() => {
-            const b = bridge;
-            return {
-                hasPane: (sid) => b.hasLivePane(sid),
-                answer: (sid, opts) => b.answerNativeModal(sid, opts),
-                cancel: async (sid) => {
-                    const t = b.targetForSession(sid);
-                    return t ? await b.interruptPane(t) : { ok: false, reason: "no mirror target for session" };
-                },
-                tell: async (sid, text) => {
-                    const t = b.targetForSession(sid);
-                    return t ? await b.injectText(t, text) : { ok: false, reason: "no mirror target for session" };
-                },
-            };
-        })()
-        : undefined;
+    const nativeModal = {
+        hasPane: (sid) => bridge.hasLivePane(sid),
+        answer: (sid, opts) => bridge.answerNativeModal(sid, opts),
+        cancel: async (sid) => {
+            const t = bridge.targetForSession(sid);
+            return t ? await bridge.interruptPane(t) : { ok: false, reason: "no mirror target for session" };
+        },
+        tell: async (sid, text) => {
+            const t = bridge.targetForSession(sid);
+            return t ? await bridge.injectText(t, text) : { ok: false, reason: "no mirror target for session" };
+        },
+    };
     const http = startHttp({ cfg, ws, log, sourcePath });
     http.register("POST /approve", makeApproveHandler({ cfg, log: log.child({ mod: "approval" }), client: ws.client, sourcePath, getMirrorTarget, flushBeforeCard, nativeModal }));
     http.register("POST /message", makeMessageHandler(ws.client, log.child({ mod: "outbound" })));
@@ -231,20 +208,11 @@ const main = async () => {
         });
         wedocLog.info("wedoc bridge ready");
     }
-    // Mirror-mode: expose attach/status so a slash command can pin the live session.
-    if (cfg.wrc.mode === "mirror") {
+    // Mirror-mode: status + the spawn/switch routes the chat side drives.
+    {
         const m = bridge;
         installMirrorEventListener(ws.client, m, log.child({ mod: "mirror" }));
         http.register("GET /mirror/status", (_req, res) => json(res, 200, m.status()));
-        http.register("POST /mirror/attach", async (req, res) => {
-            const body = (await readBody(req));
-            if (!body.sessionId || !body.jsonlPath) {
-                json(res, 400, { ok: false, reason: "sessionId and jsonlPath required" });
-                return;
-            }
-            const r = m.attach({ sessionId: body.sessionId, jsonlPath: body.jsonlPath, target: body.target, tmuxPane: body.tmuxPane, tmuxSession: body.tmuxSession });
-            json(res, r.ok ? 200 : 400, r);
-        });
         // Manual auto-spawn trigger — used by `wezard init` to materialize a
         // tmux+claude pane immediately after claim, instead of waiting for the
         // first inbound. Body: { target?: "user:xxx" | "chat:xxx" }. Falls back
@@ -375,7 +343,7 @@ const main = async () => {
                 return;
             }
             const foreign = base !== baseOfKey(self);
-            const slotR = await claimSlot(base, String(body.name ?? body.tag ?? ""), tagFromCwd(cwd) || "peer");
+            const slotR = await claimSlot(base, String(body.name ?? body.tag ?? ""), tagFromCwd(cwd) || "peer", [self]);
             if (!slotR.ok) {
                 json(res, slotR.status, slotR.body);
                 return;
@@ -609,20 +577,31 @@ const main = async () => {
         const channelOf = (self) => m.currentChannel(self) || baseOfKey(self);
         /** 入参里的地址: 新字段 `name`, 老 MCP 进程 (正在跑的 wizard) 仍在传 `tag`。 */
         const addrOf = (b) => String(b.name ?? b.tag ?? "");
+        /** 撞上的名字属于一个静默超过一天的 wizard → 顶掉它 (见 evictStaleName), 同群的
+         *  wizard 收到一行名册变动; 返回是否腾出了名字。 */
+        const displace = async (name, keep) => {
+            const gone = await evictStaleName(wizards, name, keep, { lastActivity: m.lastActivity, retire: m.killPane });
+            if (!gone)
+                return false;
+            const slot = !!tagOfKey(gone.target);
+            log.child({ mod: "wizard" }).info({ target: gone.target, name: gone.name, slot }, "stale name evicted");
+            postRoster(baseOfKey(gone.target), [], `**.${gone.name}** 静默超过一天, ${slot ? "已被同名的新 wizard 顶掉并收工" : "名字让给了同名的新 wizard"}`);
+            return true;
+        };
         /** 给一个要出生的 wizard 挑槽位 (target key) 并落定名字。名字全局唯一:
-         *  - 撞上的是一个还绑着会话的 wizard → 409, 附上它的死活, 调用方据此换名或先收掉它;
          *  - 撞上的只是目标群里同一个槽位的冷记录 (会话早没了) → 复用这个槽, 即原名重生,
          *    与从前「同一个 tag 重开」一样, 家谱/记忆都还在;
-         *  - 撞上别的群里的冷记录 → 409: 名字仍被那条记录占着。
+         *  - 撞上的 wizard 静默超过一天 (不在 `keep` 里) → 顶掉它, 名字归新的;
+         *  - 其余 (还新鲜的) → 409, 附上它的死活, 调用方据此换名或先收掉它。
          *  槽位 (key 里的 `#k`) 只是内部 id: 默认取名字本身, 被占了就加序号, 与名字无关。 */
-        const claimSlot = async (base, want, fallback) => {
+        const claimSlot = async (base, want, fallback, keep = []) => {
             const asked = normalizeTag(want);
             const clash = asked ? wizards.byName(asked) : undefined;
-            if (clash) {
-                const bound = m.chatTargets(baseOfKey(clash.target)).includes(clash.target);
-                const reusable = !bound && baseOfKey(clash.target) === base && !!tagOfKey(clash.target);
-                if (reusable)
-                    return { ok: true, target: clash.target, slot: tagOfKey(clash.target) };
+            const bound = !!clash && m.chatTargets(baseOfKey(clash.target)).includes(clash.target);
+            if (clash && !bound && baseOfKey(clash.target) === base && tagOfKey(clash.target)) {
+                return { ok: true, target: clash.target, slot: tagOfKey(clash.target) };
+            }
+            if (clash && !(await displace(asked, keep))) {
                 const info = bound ? (await m.peers(clash.target)).find((p) => p.target === clash.target) : undefined;
                 const alive = info?.paneAlive ?? false;
                 const idleForMs = info?.lastActivity ? Date.now() - info.lastActivity : undefined;
@@ -631,7 +610,7 @@ const main = async () => {
                     ? "它的 pane 还活着 —— 除非这就是同一件事的延续, 否则换个名字重新生, 别把不相关的活塞给一个已经有职责的 wizard"
                     : bound
                         ? `pane 已经不在了 (${idleDesc}), 真要复用这个名字就先 stop_wizard({name:"${clash.name}", mode:"end"}) 收掉, 再用同一个名字重新生 —— 拿到干净的上下文; 别直接 send_peer 唤醒它接手, 它会带着上一件事的记忆答你这件`
-                        : "这个名字被别的群里一个已经不在跑的 wizard 占着 —— 换个名字";
+                        : "这个名字被一个一天内还活动过、眼下没有会话的 wizard 占着 —— 换个名字 (它静默满一天后名字会自动让出)";
                 return {
                     ok: false,
                     status: 409,
@@ -1009,6 +988,7 @@ const main = async () => {
                     alive: p.paneAlive,
                     parent: w?.parent,
                     clonedFrom: w?.clonedFrom,
+                    forkOf: w?.forkOf,
                     bornAt: w?.bornAt,
                     lastActivity: p.lastActivity,
                     summary: p.summary,
@@ -1027,6 +1007,7 @@ const main = async () => {
                 busy: false, alive: false,
                 parent: w.parent,
                 clonedFrom: w.clonedFrom,
+                forkOf: w.forkOf,
                 bornAt: w.bornAt,
                 lastActivity: 0,
                 summary: "(未运行)",
@@ -1074,6 +1055,10 @@ const main = async () => {
         });
         /** 自己的地址 = 全局名字, 与住在哪个群无关。 */
         const selfAddress = (target) => settleName(wizards, chatNameOf(cfg, target), target);
+        const sharedMemory = (scope, key) => {
+            const path = memoryPath(cfg.daemon.stateDir, scope, key);
+            return clipForCharter(readMemory(path), path);
+        };
         /** 开局宪章。出生时的兄弟只是快照 —— 名册随时可查, 写进系统提示的那份只为了
          *  让它一睁眼就知道自己不是一个人在跑。 */
         const charterFor = (target, o) => renderCharter({
@@ -1083,14 +1068,16 @@ const main = async () => {
             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: readMemory(memoryPath(cfg.daemon.stateDir, "chat", baseOfKey(target))),
+            chatMemory: sharedMemory("chat", baseOfKey(target)),
             workspaceMemory: (() => {
                 const cwd = o.cwd || m.getCwd(target).runningCwd || m.getCwd(target).defaultCwd;
-                return cwd ? readMemory(memoryPath(cfg.daemon.stateDir, "workspace", cwd)) : "";
+                return cwd ? sharedMemory("workspace", cwd) : "";
             })(),
+            steward: !tagOfKey(target),
         });
         // 所有 spawn 路径 (群里手打 /new、pane 自愈重生、编排出来的分身) 都从这里
         // 取身份, 于是「是谁」不再取决于是哪段代码把它生出来的。
@@ -1100,7 +1087,7 @@ const main = async () => {
             // 「(未命名)」的地方。所以补名要发生在渲染之前, 不能等它以后自己去查。
             ensureChatNames(target);
             const rec = wizards.get(target);
-            return charterFor(target, { parent: rec?.parent, inherited: !!rec?.clonedFrom, cwd: ctx?.cwd });
+            return charterFor(target, { parent: rec?.parent, forkOf: rec?.forkOf, inherited: !!rec?.clonedFrom, cwd: ctx?.cwd });
         });
         // 开机也补一次: IM 侧的 `/peers`、`/help` 直接读名字, 不经过任何 MCP 路由。
         // 延后是因为附着表要先从盘上恢复完, 否则这一刻还看不见那些聊天; 补不全也无妨,
@@ -1132,6 +1119,7 @@ const main = async () => {
                 named: !!(rec?.name ?? "").trim(),
                 bornAt: rec?.bornAt,
                 inheritedFrom: rec?.clonedFrom || "",
+                ...(rec?.forkOf ? { forkOf: briefOf(self, rec.forkOf) } : {}),
                 memory: rec?.memory ?? [],
                 ...kinOf(self, wizards.all(), target),
                 sessionId: info?.sessionId ?? "",
@@ -1261,8 +1249,9 @@ const main = async () => {
                     : {}),
             });
         });
-        // 记忆三种作用域: self 跟着自己 (wizards.json); chat / workspace 是共享的 md,
-        // 每个在那个群 / 那个目录出生的 wizard 都会读到 (见 wizard-memory.ts)。
+        // 记忆三种作用域: self 跟着自己 (wizards.json), 直写; chat / workspace 是共享的 md,
+        // 每个在那个群 / 那个目录出生的 wizard 都会读到 —— 它们只收提议, 由整理者合并
+        // (见 wizard-memory.ts / memory-steward.ts)。
         http.register("POST /wizard/remember", async (req, res) => {
             const { self, body } = await readPeerBody(req);
             if (!self) {
@@ -1279,10 +1268,25 @@ const main = async () => {
                     json(res, 400, { ok: false, reason: "这个 wizard 没有工作区, 记不了 workspace 记忆" });
                     return;
                 }
+                if (!note && !forget) {
+                    json(res, 400, { ok: false, reason: "note 和 forget 至少给一个" });
+                    return;
+                }
                 const path = memoryPath(cfg.daemon.stateDir, scope, key);
-                const forgotten = forget ? forgetMemory(path, forget) : 0;
-                const added = note ? appendMemory(path, note) : false;
-                json(res, 200, { ok: true, scope, file: path, memory: readMemory(path), added, forgotten });
+                const queued = proposeMemory(inboxPath(cfg.daemon.stateDir, scope, key), {
+                    at: Date.now(),
+                    by: selfAddress(self),
+                    ...(note ? { note } : {}),
+                    ...(forget ? { forget } : {}),
+                });
+                if (!queued) {
+                    json(res, 500, { ok: false, reason: "提议没写进收件箱" });
+                    return;
+                }
+                json(res, 200, {
+                    ok: true, scope, queued, file: path, memory: readMemory(path),
+                    hint: "已提交给记忆整理者, 下一轮整理 (半小时内) 合并进上面这份记忆; 此后出生的 wizard 才读得到",
+                });
                 return;
             }
             const cur = wizards.get(self)?.memory ?? [];
@@ -1317,8 +1321,29 @@ const main = async () => {
                 json(res, 400, { ok: false, reason: "inherit 必填: true = fork 你此刻的上下文 (它开局就有你读过的材料, 必须留在同一个 cwd); false = 空白分身, 只继承身份" });
                 return;
             }
-            const alivePeers = await m.peers(self);
             const inherit = b.inherit;
+            // 克隆的源头: 默认是调用方自己; `from` 点名就 fork 那个 wizard 此刻的上下文。
+            // 分身仍归调用方管 (parent = self: 占它的预算、随它的工单回收), 只有上下文来自别处。
+            // 空串不能交给 resolvePeer —— 那是「本聊天的默认 wizard」, 不是「我自己」。
+            const fromAddr = (b.from ?? "").toString().trim();
+            if (fromAddr && !inherit) {
+                json(res, 400, { ok: false, reason: "from 只对克隆有意义 —— 白板生出来的 wizard 不带任何人的上下文" });
+                return;
+            }
+            const fromR = fromAddr ? resolvePeer(self, fromAddr) : { ok: true, target: self };
+            if (!fromR.ok) {
+                json(res, fromR.status, { ok: false, reason: fromR.reason, ...(fromR.candidates ? { candidates: fromR.candidates } : {}) });
+                return;
+            }
+            const source = fromR.target;
+            const sourceInfo = m.sessionInfo(source);
+            // 别人的会话 fork 不出来就是失败, 不能像克隆自己那样悄悄退化成白板 —— 调用方
+            // 要的恰恰是它的上下文, 给一张白纸等于答非所问。
+            if (source !== self && !sourceInfo?.sessionId) {
+                json(res, 409, { ok: false, reason: `${displayName(source)} 没有可 fork 的会话 (还没说过话, 或绑定已失效)` });
+                return;
+            }
+            const alivePeers = await m.peers(self);
             // 预算。撞到上限不是"不许再分", 是"先把干完活的收掉": stop_wizard 收单个,
             // close_job 整批回收一个工单的临时分身。只数**本聊天里**活着的 ——
             // 生到别的聊天去的归那边管, 为了数它们再探一遍 tmux 不值当。
@@ -1342,27 +1367,28 @@ const main = async () => {
                 return;
             }
             const askedName = String(b.name ?? b.tag ?? "");
-            const slotR = await claimSlot(base, askedName, normalizeTag(b.description?.split(/\s+/)[0]) || "clone");
+            const slotR = await claimSlot(base, askedName, normalizeTag(b.description?.split(/\s+/)[0]) || "clone", [self, source]);
             if (!slotR.ok) {
                 json(res, slotR.status, slotR.body);
                 return;
             }
             const { target, slot: tag } = slotR;
-            const parentInfo = m.sessionInfo(self);
+            const forkOf = inherit && source !== self ? source : undefined;
             // 先落身份再 spawn: 宪章是从注册表渲染出来的, 记录不在就渲染出一个无名分身。
             wizards.upsert(target, {
                 description: (b.description ?? "").toString().trim(),
                 parent: self,
                 bornAt: Date.now(),
-                clonedFrom: inherit ? parentInfo?.sessionId ?? "" : "",
+                clonedFrom: inherit ? sourceInfo?.sessionId ?? "" : "",
+                ...(forkOf ? { forkOf } : {}),
             });
             const name = wizards.rename(target, normalizeTag(askedName) || tag);
-            const charter = charterFor(target, { parent: self, inherited: inherit });
+            const charter = charterFor(target, { 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;
             const r = await m.cloneSession({
-                parent: self,
+                parent: source,
                 target,
                 windowName: name,
                 cli: b.cli,
@@ -1380,7 +1406,7 @@ const main = async () => {
                 json(res, 500, { ok: false, reason: r.reason });
                 return;
             }
-            wizards.upsert(target, { clonedFrom: r.inherited ? parentInfo?.sessionId ?? "" : "" });
+            wizards.upsert(target, { clonedFrom: r.inherited ? sourceInfo?.sessionId ?? "" : "", ...(r.inherited ? {} : { forkOf: undefined }) });
             const kid = briefOf(self, target);
             // r.model 是 spawnTmuxClaude 通过 /model 实测确认落地的那个 —— 可能跟调用方
             // 传的原始字符串不一样 (口语化 → 目录里匹配到的关键词), 播报要报实情。
@@ -1390,7 +1416,7 @@ const main = async () => {
             // 出生不再发群气泡 (人要看的是结论, 不是谁生了谁 —— 过程在 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 ? " (继承了它的上下文)" : ""}`);
+                postRoster(base, [target, self], `新 wizard **.${name}** 就位${kid.description ? ` · ${kid.description}` : ""}${r.cwd ? ` · 工作区 ${r.cwd}` : ""}${modelNote}${keepalive ? "" : " · 已关闭 keepalive"} —— ${displayName(self)} 的分身${r.inherited ? ` (继承了${forkOf ? ` ${displayName(forkOf)} ` : "它"}的上下文)` : ""}`);
             }
             // 继承路径上活已经随开场白进去了, 空白分身才需要在这里补一次注入 (私聊)。
             let dispatched = r.inherited && !!task;
@@ -1501,7 +1527,7 @@ const main = async () => {
                 job: job.id,
                 title,
                 memberMax: JOB_MEMBER_MAX,
-                hint: "把这个 id 传给 spawn_clone / send_peer 的 `job` 参数, 它们就归到这个工单名下 (期间不再逐条出气泡); 活干完调 close_job 收尾并回收临时分身。",
+                hint: "把这个 id 传给 spawn_wizard / clone_wizard / send_peer 的 `job` 参数, 它们就归到这个工单名下 (期间不再逐条出气泡); 活干完调 close_job 收尾并回收临时分身。",
             });
         });
         http.register("POST /jobs/close", async (req, res) => {
@@ -1805,49 +1831,42 @@ const main = async () => {
         };
     }
     // 定时调度器 — 每 20s 检查任务表, 到点把 prompt 注入目标 wizard。
-    // inject 只在 mirror 模式给得出 (headless 模式没有常驻会话可注入)。
     migrateLegacySchedules(cfg, sourcePath, tasks, log.child({ mod: "tasks" }));
     const scheduler = startScheduler({
         client: ws.client,
         registry: tasks,
         log: log.child({ mod: "tasks" }),
-        inject: cfg.wrc.mode === "mirror" ? scheduledTaskInject : undefined,
+        inject: scheduledTaskInject,
         // gate 里的 `sh` 默认就在目标 wizard 此刻的工作区跑 —— 任务文件里不必写死绝对路径。
-        cwdOf: cfg.wrc.mode === "mirror"
-            ? (t) => { const c = bridge.getCwd(t); return c.runningCwd || c.pendingCwd || c.defaultCwd; }
-            : undefined,
+        cwdOf: (t) => { const c = bridge.getCwd(t); return c.runningCwd || c.pendingCwd || c.defaultCwd; },
         fallbackTarget: () => (cfg.defaultChat ?? "").trim(),
     });
-    // 闲置 pane 收割机 — 默认 48h 静默才动 (wrc.mirror.idleReapHours, 0=关)。
-    // 只收 pane 不收绑定: 下一条消息 `--resume` 复活。豁免: 名下有定时任务的
-    // wizard (调度本身会唤醒/需要它), 挂着审批长轮询的会话 (hook 还停在等点击),
-    // 忙着的 / 人正盯着的 (bridge 内部判)。keepalive 会话靠 ping 刷新 transcript,
-    // 天然到不了阈值。
-    let reapTimer;
-    if (cfg.wrc.mode === "mirror" && cfg.wrc.mirror.idleReapHours > 0) {
-        const ttlMs = cfg.wrc.mirror.idleReapHours * 3.6e6;
+    // pane 上限 — 每新建一个 wizard 数一次: 活着的会话 pane 超过 wrc.mirror.maxPanes
+    // (默认 20, 0=关) 就从最久没动的收起。数量只在出生时增长, 所以不设定时器。只收
+    // pane 不收绑定: 下一条消息 `--resume` 复活。豁免: 名下有定时任务的 wizard (调度
+    // 本身会唤醒/需要它), 挂着审批长轮询的会话 (hook 还停在等点击), 忙着的 / 人正
+    // 盯着的 (bridge 内部判)。
+    if (cfg.wrc.mirror.maxPanes > 0) {
+        const max = cfg.wrc.mirror.maxPanes;
         const sweep = async () => {
             const taskOwners = new Set(tasks.list()
                 .filter((t) => t.enabled)
                 .map((t) => wizardStore()?.byName(t.owner)?.target)
                 .filter((t) => !!t));
             const pendingSids = new Set(listPending().map((p) => p.meta.sessionId).filter((s) => !!s));
-            const r = await bridge.reapIdle(ttlMs, (target, sid) => taskOwners.has(target) ? "owns scheduled task"
+            const r = await bridge.reapOverflow(max, (target, sid) => taskOwners.has(target) ? "owns scheduled task"
                 : pendingSids.has(sid) ? "pending approval"
                     : undefined);
             if (r.reaped.length)
-                log.info({ reaped: r.reaped.length, targets: r.reaped }, "idle reap sweep");
+                log.info({ reaped: r.reaped.length, targets: r.reaped, max }, "pane cap sweep");
         };
-        reapTimer = setInterval(() => void sweep().catch((e) => log.warn({ err: e.message }, "idle reap sweep failed")), 30 * 60_000);
-        reapTimer.unref();
+        bridge.onSpawn(() => void sweep().catch((e) => log.warn({ err: e.message }, "pane cap sweep failed")));
     }
     const shutdown = async (signal) => {
         log.info({ signal }, "shutdown signal");
         scheduler.stop();
         tasks.stop();
         netWatch.stop();
-        if (reapTimer)
-            clearInterval(reapTimer);
         // 同 POST /shutdown: 先把挂着的审批长轮询了结成「稍后续接」, 再关连接。
         log.info(drainForReload(), "pending drained for reload");
         // Hard-exit watchdog: http.close() blocks until every in-flight connection