wezard 1.4.2 → 2.0.1

package/dist/daemon/index.js

@@ -7,27 +7,29 @@ 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";
-import { initDetailPersistence, makeDetailHandler, chatHandlers, configureRemoteForward, buildChatUrl, latestTurnIdFor, chatTicketFor, setWorldFactsProvider } from "./detail.js";
+import { initDetailPersistence, makeDetailHandler, chatHandlers, configureRemoteForward, chatUrlFor, setWorldFactsProvider } from "./detail.js";
 import { EMPTY_FACTS } from "../shared/world.js";
 import { initAutoWindowPersistence } from "./session-cache.js";
 import { makeMessageHandler } from "./outbound.js";
 import { makeCardHandler, makeAskHandler, installAskEventListener } from "./ask.js";
-import { drainForReload } from "./pending.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 { scanClaudeSessions } from "./session-scan.js";
-import { startScheduler, listSchedules, addSchedule, removeScheduleById, renderSchedule, } from "./tasks.js";
-import { describeWhen, nextFire, parseWhen } from "../shared/schedule-spec.js";
-import { baseOfKey, keyOf, labelFor, normalizeTag, tagFromCwd, tagOfKey, uniqueTag, withTagHeader } from "../shared/session-label.js";
+import { startScheduler, migrateLegacySchedules, promptWantsFreshWizard, renderTask, sinceOf, } 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 { applyChatNames, chatBaseOf, chatNameOf, clearChatName, listChatNames, normChatName, peerAddress, planChatNames, setChatName } from "./chat-name.js";
-import { bindWizardStore, loadWizardStore, wizardName, childrenOf, ancestorsOf, renderCharter, } from "./wizard.js";
+import { bindWizardStore, loadWizardStore, wizardStore, settleName, settleAll, 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";
@@ -47,6 +49,9 @@ const main = async () => {
         name: "wezard-daemon",
     });
     log.info({ sourcePath, pid: process.pid }, "daemon start");
+    // 定时调度器的 `inject` 真正实现, 赋值在 mirror-mode 的大块里 (要用到那里面的
+    // wizards / m / notifyChat), 但 startScheduler 在那块外面接线 —— 见文件尾。
+    let scheduledTaskInject;
     // Bind the CLI backend registry. `primary` (= defaultCli) drives new-session
     // spawns; `backends` is every installed CLI whose transcript root exists, so
     // sessions from all of them can be mirrored concurrently — each attachment
@@ -74,63 +79,57 @@ 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);
-    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");
+    // 定时任务表 —— 每条任务是 ~/.wezard/tasks/<id>.task.mjs 一份可注入代码的配置
+    // (见 shared/task-file.ts)。目录是热加载的: wizard 改完文件不用 reload 守护进程。
+    // 共享记忆的整理者是一条定时任务 (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` 不该变成一个开在空栏上的链接。
+    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) => {
+            const t = wizardStore()?.byName(name)?.target;
+            return t && known(t) ? t : undefined;
+        },
+        nameOf: (t) => settleName(wizardStore(), chatNameOf(cfg, t), t),
+    });
     installInboundRouter(ws.client, cfg, log, bridge, sourcePath);
     // 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" })));
@@ -209,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
@@ -353,21 +343,28 @@ const main = async () => {
                 return;
             }
             const foreign = base !== baseOfKey(self);
-            const taken = new Set(m.chatTargets(base).map(tagOfKey).filter(Boolean));
-            const asked = normalizeTag(body.tag);
-            // 复用一个活着的 tag 等于 respawn —— 也就是杀掉那个 wizard。调用方要的是
-            // 「再来一个」, 不是「把那个重启」; 让它换个名字。
-            if (asked && taken.has(asked)) {
-                json(res, 409, { ok: false, reason: `peer '#${asked}' already exists in ${foreign ? `chat '${wantChat}'` : "this chat"} — pick a different tag, or drive that one with send_peer`, tag: asked });
+            const slotR = await claimSlot(base, String(body.name ?? body.tag ?? ""), tagFromCwd(cwd) || "peer");
+            if (!slotR.ok) {
+                json(res, slotR.status, slotR.body);
                 return;
             }
-            const tag = asked || uniqueTag(tagFromCwd(cwd) || "peer", taken);
-            const target = keyOf(base, tag);
+            const { target, slot: tag } = slotR;
+            const existed = !!wizards.get(target);
+            const name = wizards.rename(target, normalizeTag(String(body.name ?? body.tag ?? "")) || tag);
             const model = (body.model ?? "").toString().trim();
-            log.child({ mod: "mirror", sub: "sessions-new", target }).info({ self, cwd, foreign, cli: body.cli, model }, "spawning peer session");
-            const r = await m.newSession(target, tag, body.cli, { cwd, model });
+            // 没点名就按配置的 keepalive.spawnDefault 来 —— 调用方明说的永远优先。
+            const keepalive = typeof body.keepalive === "boolean" ? body.keepalive : cfg.wrc.mirror.keepalive.spawnDefault;
+            log.child({ mod: "mirror", sub: "sessions-new", target }).info({ self, cwd, foreign, cli: body.cli, model, keepalive }, "spawning peer session");
+            const r = await m.newSession(target, name, body.cli, { cwd, model, keepalive });
+            if (!r.ok && !existed)
+                wizards.drop(target);
+            // r.model 是 spawnTmuxClaude 通过 /model 实测确认落地的那个 —— 可能跟调用方
+            // 传的原始字符串不一样 (口语化 → 目录里匹配到的关键词), 播报要报实情。
+            const modelNote = r.model
+                ? (r.modelWarning ? ` · 模型 ${r.model} (⚠️ ${r.modelWarning})` : ` · 模型 ${r.model}`)
+                : "";
             if (r.ok)
-                postRoster(base, [target, self], `新 wizard **#${tag}** 就位 · 地址 \`${peerAddress(cfg, base, target)}\`${r.cwd ? ` · 工作区 ${r.cwd}` : ""}${model ? ` · 模型 ${model}` : ""} —— 空白起步, 由 ${displayName(self)} 造的`);
+                postRoster(base, [target, self], `新 wizard **.${name}** 就位${r.cwd ? ` · 工作区 ${r.cwd}` : ""}${modelNote}${keepalive ? "" : " · 已关闭 keepalive"} —— 空白起步, 由 ${displayName(self)} 造的`);
             json(res, r.ok ? 200 : 500, r.ok
                 ? {
                     ok: true,
@@ -375,10 +372,12 @@ const main = async () => {
                     self,
                     target,
                     base,
-                    tag,
+                    name,
                     cwd: r.cwd,
-                    ...(model ? { model } : {}),
+                    ...(r.model ? { model: r.model } : {}),
+                    ...(r.modelWarning ? { modelWarning: r.modelWarning } : {}),
                     foreign,
+                    keepalive,
                     // 调用方之后拿这个串 send_peer / peek_peer 驱动它。
                     address: peerAddress(cfg, self, target),
                 }
@@ -432,8 +431,15 @@ const main = async () => {
                 json(res, 400, { ok: false, reason: "target required (or pass sessionId of an attached chat)" });
                 return;
             }
+            // keep = 人回答了「不用换, 就用现在这个」。只落一笔确认, 不碰 pane —— 把
+            // 「保持现状」也走成 setPendingCwd + newSession 的话, 代价是白杀一个会话。
+            if (body.keep === true) {
+                const c = m.confirmCwd(target);
+                json(res, c.ok ? 200 : 400, c.ok ? { ok: true, target, cwd: c.cwd, confirmed: true } : { ok: false, reason: c.reason, target });
+                return;
+            }
             if (!cwd) {
-                json(res, 400, { ok: false, reason: "cwd required" });
+                json(res, 400, { ok: false, reason: "cwd required (or keep:true to confirm the current one)" });
                 return;
             }
             const set = m.setPendingCwd(target, cwd);
@@ -484,7 +490,7 @@ const main = async () => {
                         target: t,
                         tag: tagOfKey(t),
                         address: self ? peerAddress(cfg, self, t) : t,
-                        name: wizardName(wizards.get(t), chatNameOf(cfg, t), t),
+                        name: settleName(wizards, chatNameOf(cfg, t), t),
                         description: wizards.get(t)?.description ?? "",
                         cwd: m.getCwd(t).runningCwd || m.getCwd(t).defaultCwd,
                     })),
@@ -507,7 +513,15 @@ const main = async () => {
             }
             const previous = chatNameOf(cfg, self);
             const r = setChatName(cfg, sourcePath, self, raw);
-            json(res, r.ok ? 200 : 409, r.ok ? { ok: true, base: r.base, name: r.name, previous } : { ok: false, reason: r.reason });
+            if (!r.ok) {
+                json(res, 409, { ok: false, reason: r.reason });
+                return;
+            }
+            // 默认 wizard 的名字取自聊天名; 它还叫旧聊天名 (没被单独改过) 就跟着改。
+            const home = baseOfKey(self);
+            const cur = wizards.get(home)?.name ?? "";
+            const wizardRenamed = previous && cur.toLowerCase() === previous.toLowerCase() ? wizards.rename(home, r.name) : undefined;
+            json(res, 200, { ok: true, base: r.base, name: r.name, previous, ...(wizardRenamed ? { wizardRenamed } : {}) });
         });
         const readPeerBody = async (req) => {
             const body = (await readBody(req));
@@ -525,63 +539,87 @@ const main = async () => {
         });
         // Push a plain markdown bubble into a chat. `base` may carry a `#tag` — a
         // tagged key strips down to the same WeCom chatid as its base.
+        // 头不走 withTagHeader 的那些 (relay / notify / 工单) 正文里的 tag 在这里挂链;
+        // 已挂过的 linkTags 认得出, 不会再套一层。
         const chatIdOf = (t) => baseOfKey(t).replace(/^(user|chat|group):/, "");
         const notifyChat = (base, markdown) => {
             const chatId = chatIdOf(base);
             void ws.client
-                .sendMessage(chatId, { msgtype: "markdown", markdown: { content: markdown } })
+                .sendMessage(chatId, { msgtype: "markdown", markdown: { content: linkTags(base, markdown) } })
                 .catch((e) => log.warn({ err: e.message }, "chat notify failed"));
         };
         // wizard 在群里的称呼, 只用在**正文**里。气泡的头照旧交给 withTagHeader ——
         // 那一段是路由信息 (`emoji #tag`), parseTagHeader 靠它反解, 群里引用一条气泡
         // 就能直接跟那个 wizard 说话; 把它换成名字会把这条通路弄断。
         const displayName = (t) => {
-            const tag = tagOfKey(t);
-            const name = wizardName(wizards.get(t), chatNameOf(cfg, t), t);
-            return name || (tag ? `#${tag}` : "默认 wizard");
+            const name = settleName(wizards, chatNameOf(cfg, t), t);
+            return name ? `.${name}` : "默认 wizard";
         };
-        // wizard 之间的往返本来是看不见的: 它发生在两个没人盯着的 pane 里。关键的那几
-        // 次 (派活、结论) 各自成一条气泡, 头写成 `<from> → <to>`, 方向一眼可读。
+        // wizard 之间的往返默认是私聊, 不进群。只有发话方判断「该当着人说」的那一次
+        // (send_peer public:true) 在公开频道里成一条气泡, 头写成 `.a → .b`, 方向一眼可读。
         const RELAY_MAX = 1200;
-        /** 一个 wizard 在 `dest` 群里的称呼。本群: 照旧 `emoji #tag` —— 那一段是路由
-         *  信息, parseTagHeader 靠它反解, 引用气泡就能直接跟它说话。外群: 换成带聊天
-         *  名的全称 `emoji chat#tag`, 一个裸 `#tag` 在别人群里既认不出是谁, 又会被当
-         *  成本群的 tag 误投到一个不存在的会话上。 */
-        const relayLabel = (t, dest) => {
-            const name = baseOfKey(t) === dest
-                ? withTagHeader(t, "").trim()
-                : `${tagOfKey(t) ? labelFor(tagOfKey(t)) : "🧙"} ${peerAddress(cfg, dest, t)}`;
-            const url = chatDetailUrl(t);
-            return url ? `[${name}](${url})` : name;
-        };
-        /** 头上的名字挂它自己的 chat 详情页 —— 看见「A → B」的人下一步想问的永远是
-         *  「A 那边在干嘛」, 链接就省掉他去翻群找 A 气泡这一步。票据优先取该 wizard 自己
-         *  最近那条 turn (mirror 的 linkedTagPrefix 同源), 取不到就退到它所在聊天的长期
-         *  票据 —— `?id=` 的授权范围本来就是整个聊天, 开在谁那一栏由 `target=` 明说, 所以
-         *  换票不多给权限也不会开错栏。少了这层兜底, `A → B` 里的 B 几乎总是不可点:
-         *  detail store 只留 24h, 而被派活的那个 wizard 恰恰常常是刚出生 / 闲了一天的,
-         *  跨聊天派活时它所在的那个群更可能整个群都没有 turn 记录。 */
-        const chatDetailUrl = (t) => {
-            const id = latestTurnIdFor(t) ?? chatTicketFor(baseOfKey(t));
-            return id ? buildChatUrl(cfg.daemon.detailPublicBase, cfg.daemon.host, cfg.daemon.port, id, chatIdOf(t), t) : undefined;
-        };
-        /** 一条 relay 只落在**收信那一方**的群里, 从不两头都发:
-         *  - 派活 → to 的群。同群时那就是双方共处的那个群 (行为照旧); 跨群时源头群
-         *    不再复述 —— 那句话本来就是它自己说出口的, 贴回自己群里只是噪音, 真正
-         *    需要看见的是 to 那边的人: 活是谁派来的。
-         *  - 回程结论 (`relayPeer(target, self)`) → 问话人的群。答话方自己的群里,
-         *    它的回复早就以它自己的气泡出现过了。 */
-        const relayPeer = (from, to, body) => {
+        /** 一个 wizard 在群里的称呼: `emoji .name`, 挂它的 rolepage。名字全局唯一, 不再
+         *  因为落在哪个群而换写法 —— 引用这一段就能跟它说话 (parseTagHeader 认得)。 */
+        const relayLabel = (t, _dest) => tagLink(t, tagHead(t));
+        /** 公开的 wizard 间对话: 落在 `channel` 这个群。 */
+        const relayPeer = (from, to, body, channel) => {
             const text = body.trim();
-            if (!text)
+            if (!text || !channel)
                 return;
-            const dest = baseOfKey(to);
-            const head = `${relayLabel(from, dest)} → ${relayLabel(to, dest)}`;
+            const head = `${relayLabel(from)} → ${relayLabel(to)}`;
             const clipped = text.length > RELAY_MAX ? `${text.slice(0, RELAY_MAX)}…` : text;
             // 头独占一行, 正文自成一个块 —— 只隔一个换行的话, markdown 会把正文首行
             // 当成头那一段的续行; 表格因此整张塌成一行带竖线的文字 (表格不能打断段落)。
-            // 方向已经写在头里了, 正文不再加任何引用/缩进标记。
-            notifyChat(dest, `${head}\n\n${clipped}`);
+            notifyChat(channel, `${head}\n\n${clipped}`);
+        };
+        /** 调用方这一轮所在的公开频道: 人从哪个群叫的它 / 公开 peer 轮的那个群;
+         *  私聊轮或无记录 → 它的 home 群。notify 与 public send_peer 默认发到这里。 */
+        const channelOf = (self) => m.currentChannel(self) || baseOfKey(self);
+        /** 入参里的地址: 新字段 `name`, 老 MCP 进程 (正在跑的 wizard) 仍在传 `tag`。 */
+        const addrOf = (b) => String(b.name ?? b.tag ?? "");
+        /** 给一个要出生的 wizard 挑槽位 (target key) 并落定名字。名字全局唯一:
+         *  - 撞上的是一个还绑着会话的 wizard → 409, 附上它的死活, 调用方据此换名或先收掉它;
+         *  - 撞上的只是目标群里同一个槽位的冷记录 (会话早没了) → 复用这个槽, 即原名重生,
+         *    与从前「同一个 tag 重开」一样, 家谱/记忆都还在;
+         *  - 撞上别的群里的冷记录 → 409: 名字仍被那条记录占着。
+         *  槽位 (key 里的 `#k`) 只是内部 id: 默认取名字本身, 被占了就加序号, 与名字无关。 */
+        const claimSlot = async (base, want, fallback) => {
+            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 info = bound ? (await m.peers(clash.target)).find((p) => p.target === clash.target) : undefined;
+                const alive = info?.paneAlive ?? false;
+                const idleForMs = info?.lastActivity ? Date.now() - info.lastActivity : undefined;
+                const idleDesc = idleForMs !== undefined ? `静默 ${Math.round(idleForMs / 60000)} 分钟` : "从没动过";
+                const advice = alive
+                    ? "它的 pane 还活着 —— 除非这就是同一件事的延续, 否则换个名字重新生, 别把不相关的活塞给一个已经有职责的 wizard"
+                    : bound
+                        ? `pane 已经不在了 (${idleDesc}), 真要复用这个名字就先 stop_wizard({name:"${clash.name}", mode:"end"}) 收掉, 再用同一个名字重新生 —— 拿到干净的上下文; 别直接 send_peer 唤醒它接手, 它会带着上一件事的记忆答你这件`
+                        : "这个名字被别的群里一个已经不在跑的 wizard 占着 —— 换个名字";
+                return {
+                    ok: false,
+                    status: 409,
+                    body: {
+                        ok: false,
+                        reason: `名字 '.${clash.name}' 已经属于一个${alive ? "活着的" : "不再活跃的"} wizard (名字全局唯一) —— ${advice}`,
+                        name: clash.name,
+                        address: clash.name,
+                        alive,
+                        busy: info?.busy ?? false,
+                        idleForMs,
+                    },
+                };
+            }
+            const taken = new Set([
+                ...m.chatTargets(base).map(tagOfKey),
+                ...wizards.all().filter((w) => baseOfKey(w.target) === base).map((w) => tagOfKey(w.target)),
+            ].filter(Boolean));
+            const slot = uniqueTag(asked || normalizeTag(fallback) || "wizard", taken);
+            return { ok: true, target: keyOf(base, slot), slot };
         };
         // ── 给人看的消息 ──────────────────────────────────────────────────
         // send_peer 把话塞进另一个 agent 的输入框 (驱动它干活); 这条把话贴进一个聊天
@@ -611,9 +649,9 @@ const main = async () => {
                 json(res, 400, { ok: false, reason: `认不出这些聊天: ${bad.join(", ")} (list_chats 看有哪些; 没起名的聊天寻址不到)` });
                 return;
             }
-            const dests = [...new Set(refs.length ? refs.map((r) => chatBaseOf(cfg, r)) : [baseOfKey(self)])];
+            const dests = [...new Set(refs.length ? refs.map((r) => chatBaseOf(cfg, r)) : [channelOf(self)])];
             for (const dest of dests)
-                notifyChat(dest, `${relayLabel(self, dest)}\n\n${content}`);
+                notifyChat(dest, `${relayLabel(self)}\n\n${content}`);
             json(res, 200, { ok: true, sent: dests.map((d) => chatNameOf(cfg, d) || d) });
         });
         http.register("POST /peers/peek", async (req, res) => {
@@ -622,7 +660,7 @@ const main = async () => {
                 json(res, 400, { ok: false, reason: "cannot resolve caller session" });
                 return;
             }
-            const r = resolvePeer(self, body.tag ?? "");
+            const r = resolvePeer(self, addrOf(body));
             if (!r.ok) {
                 json(res, r.status, { ok: false, reason: r.reason, candidates: r.candidates });
                 return;
@@ -663,12 +701,16 @@ const main = async () => {
                     return;
                 }
             }
-            const r = resolvePeer(self, body.tag ?? "");
+            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;
+            // 公开与否由发话方 (LLM) 判断: 公开 = 在它这一轮的公开频道里说, 气泡进群、对方
+            // 那一轮的回复也发进这个群; 私聊 (默认) = 只落双方的 rolepage, 回复靠 wait_peer 取。
+            const isPublic = body.public === true;
+            const channel = isPublic ? 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) {
@@ -694,17 +736,18 @@ const main = async () => {
                     return;
                 }
             }
-            const inj = await m.injectText(target, text, undefined, { from: { kind: "peer", from: self, ...(jobId ? { job: jobId } : {}) } });
-            // 归到工单名下的往返不单独出气泡: 五路 fan-out 的每一次派活都发一条, 群里
-            // 就只剩交叉的气泡, 读不出结构。它照旧落在对方的 chat 详情页里, 收工那一条
-            // 会把成员和各自那段活一起列出来。
+            const inj = await m.injectText(target, text, undefined, {
+                from: { kind: "peer", from: self, ...(jobId ? { job: jobId } : {}), ...(isPublic ? { public: true } : {}) },
+                channel,
+            });
+            // 工单成员照旧记账 (收工那一条会列出各自那段活); 公开的那一句在群里成气泡。
             if (inj.ok && jobId)
                 jobs.attach(jobId, { target, task: text, spawned: false });
-            if (inj.ok && !jobId)
-                relayPeer(self, target, text);
+            if (inj.ok && isPublic)
+                relayPeer(self, target, text, channel);
             // `wasBusy` 是给调用方的判断依据: 立刻投给一个正在生成的会话, 这句话会排在
             // 它这一轮后面, 而不是马上被读到。
-            json(res, inj.ok ? 200 : 502, { ...inj, target, foreign, when, wasBusy, waitedMs, ...(jobId ? { job: jobId } : {}) });
+            json(res, inj.ok ? 200 : 502, { ...inj, target, name: peerAddress(cfg, self, target), foreign, public: isPublic, when, wasBusy, waitedMs, ...(jobId ? { job: jobId } : {}) });
         });
         // 等一个 wizard, 或者等一**组**。fan-out 之后 join 必须是并行的: 串行地等五个
         // 分身, 墙钟是五个之和, 而它们本来就在同时干活。`need` 把 all / any / 过半收进
@@ -716,7 +759,8 @@ const main = async () => {
                 return;
             }
             const b = body;
-            const asked = (Array.isArray(b.tags) && b.tags.length > 0 ? b.tags : [b.tag ?? ""]).map((x) => String(x ?? ""));
+            const many = Array.isArray(b.names) && b.names.length > 0 ? b.names : b.tags;
+            const asked = (Array.isArray(many) && many.length > 0 ? many : [addrOf(b)]).map((x) => String(x ?? ""));
             if (asked.length > 16) {
                 json(res, 400, { ok: false, reason: "一次最多等 16 个 wizard" });
                 return;
@@ -741,13 +785,7 @@ const main = async () => {
             const results = uniq.map((h, i) => {
                 const wr = wrs[i];
                 const lastText = m.lastText(h.target);
-                // 回程只在跨聊天时下发。同一个群里, 对方的回复本来就会以它自己的 `emoji #tag`
-                // 气泡出现 —— 再 relay 一条 `B → A` 就是同一句话在同一个群里出现两次, 正是
-                // 「A 告诉 B 之后不必再展示 B 收到了」要消灭的那种重复。跨聊天则相反: A 的群
-                // 里看不到 B 的任何气泡, 这条 relay 是那边唯一能看见结论的地方 —— 所以它落在
-                // self (问话人) 的群, 而不是答话方那边。
-                if (wr.idle && h.foreign)
-                    relayPeer(h.target, self, lastText);
+                // 回程不再进群: 私聊的结论由调用方自己收口给人; 公开轮的回复 mirror 早已发进那个群。
                 // `result` 是它自己收口的那一行 (见 peers.extractResult); 捞不到就是 "",
                 // 调用方照旧读 lastText。
                 return { address: h.address, target: h.target, foreign: h.foreign, idle: wr.idle, reason: wr.reason, result: extractResult(lastText), lastText };
@@ -784,7 +822,7 @@ const main = async () => {
                 }
             }
             else {
-                const r = resolvePeer(self, body.tag ?? "");
+                const r = resolvePeer(self, addrOf(body));
                 if (!r.ok) {
                     json(res, r.status, { ok: false, reason: r.reason, candidates: r.candidates });
                     return;
@@ -839,8 +877,8 @@ const main = async () => {
                 : { ok: false, target, brief, reason: `handoff carry inject failed: ${inj2.reason}` });
         });
         // ── Wizard: 会话的身份层 ────────────────────────────────────────────
-        // 一个会话 (`chat:xxx#tag`) 从此是一个 wizard: 名字 (= 聊天名, 带 tag 的分身读作
-        // `chat#tag`)、一句职责、一份跨会话的记忆、一条家谱。身份不靠"在对话里讲一遍"
+        // 一个会话 (`chat:xxx#k`) 从此是一个 wizard: 一个全局唯一的名字 (默认会话出生时
+        // 取聊天名, 分身取自己的名字)、一句职责、一份跨会话的记忆、一条家谱。身份不靠"在对话里讲一遍"
         // 维持 —— spawn 时以 `--append-system-prompt` 压进那个进程, `/clear` 抹不掉、
         // 上下文窗口也挤不掉。
         // 这里只做三件事: 读身份、改身份、按身份生/收分身。tmux 一概不碰, 动作全在
@@ -885,10 +923,14 @@ const main = async () => {
                 log.info({ base, name }, "chat: auto-named from workspace");
                 // 群里不发气泡 (一次补名会命中十几个群, 那是刷屏), 但住在里面的 wizard
                 // 得知道自己的地址变了 —— 它的 charter 里写的还是「(未命名)」。
-                postRoster(base, [], `这个聊天现在叫 **${name}** (按工作区自动起的) —— 别的聊天从此能以 \`${name}#tag\` 叫到这里, 你的地址也随之可读了。`);
+                postRoster(base, [], `这个聊天现在叫 **${name}** (按工作区自动起的) —— notify / new_claude_session 可以用这个名字指到这里。`);
             }
             return named;
         };
+        // 名字全局唯一 (见 wizard.ts): 先给没名字的聊天补名, 再按「默认会话先挑」把
+        // 每个已知 wizard 的名字落定 —— 老记录 (名字还跟着聊天走的那一代) 在这里一次迁完。
+        ensureChatNames(cfg.defaultChat || "");
+        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);
@@ -925,7 +967,7 @@ const main = async () => {
                 const w = byTarget.get(p.target);
                 return {
                     target: p.target,
-                    name: wizardName(w, chatNameOf(cfg, p.target), p.target),
+                    name: settleName(wizards, chatNameOf(cfg, p.target), p.target),
                     description: w?.description ?? "",
                     chat: chatNameOf(cfg, p.target) || p.chat,
                     cwd: p.cwd,
@@ -935,6 +977,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,
@@ -946,13 +989,14 @@ const main = async () => {
                 .filter((w) => !seen.has(w.target))
                 .map((w) => ({
                 target: w.target,
-                name: wizardName(w, chatNameOf(cfg, w.target), w.target),
+                name: settleName(wizards, chatNameOf(cfg, w.target), w.target),
                 description: w.description,
                 chat: chatNameOf(cfg, w.target),
                 cwd: "", model: "", cli: "",
                 busy: false, alive: false,
                 parent: w.parent,
                 clonedFrom: w.clonedFrom,
+                forkOf: w.forkOf,
                 bornAt: w.bornAt,
                 lastActivity: 0,
                 summary: "(未运行)",
@@ -965,16 +1009,20 @@ const main = async () => {
                     openedAt: j.openedAt, closedAt: j.closedAt, summary: j.summary,
                     members: j.members.map((mm) => ({ target: mm.target, task: mm.task, spawned: mm.spawned })),
                 })),
-                schedules: cfg.schedules.map((x) => ({
-                    id: x.id,
-                    target: x.target,
-                    when: describeWhen(x.when),
-                    nextAt: nextFire(x.when, x.lastFired ?? x.createdAt, nowDate),
-                    lastFired: x.lastFired,
-                    prompt: x.prompt,
-                    note: x.note,
-                    createdBy: x.createdBy,
-                })),
+                schedules: tasks.list().filter((x) => x.enabled).map((x) => {
+                    const st = tasks.stateOf(x.id);
+                    return {
+                        id: x.id,
+                        target: x.target || (cfg.defaultChat ?? ""),
+                        when: describeTrigger(x.trigger),
+                        nextAt: nextFire(x.trigger, sinceOf(st), nowDate),
+                        lastFired: st.lastFired,
+                        prompt: x.prompt,
+                        note: x.note,
+                        createdBy: x.createdBy,
+                        owner: x.owner || (cfg.defaultChat ?? ""),
+                    };
+                }),
                 chatNames: Object.fromEntries(listChatNames(cfg).map((c) => [c.base, c.name])),
             };
         };
@@ -989,39 +1037,46 @@ const main = async () => {
          *  给交接那一轮本身 —— 提示而已, 决定权在 wizard 自己。 */
         const HANDOFF_HINT_TOKENS = 140_000;
         const briefOf = (self, target) => ({
-            name: wizardName(wizards.get(target), chatNameOf(cfg, target), target),
+            name: settleName(wizards, chatNameOf(cfg, target), target),
             address: peerAddress(cfg, self, target),
             description: wizards.get(target)?.description ?? "",
             cwd: m.getCwd(target).runningCwd,
         });
-        /** 自己的地址要写成**全局**形态 (`聊天名#tag`), 不是同群内部的裸 tag —— 宪章
-         *  和 whoami 里的这个串会被它原样贴给别的聊天的 wizard, 裸 tag 到了那边只有
-         *  在全机唯一时才碰巧能解析。聊天没起名时只能退回裸 tag。 */
-        const selfAddress = (target) => {
-            const chat = chatNameOf(cfg, target);
-            const tag = tagOfKey(target);
-            return chat ? `${chat}#${tag}` : tag;
+        /** 自己的地址 = 全局名字, 与住在哪个群无关。 */
+        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({
-            self: { ...briefOf(target, target), address: selfAddress(target) },
+            // 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),
         });
         // 所有 spawn 路径 (群里手打 /new、pane 自愈重生、编排出来的分身) 都从这里
         // 取身份, 于是「是谁」不再取决于是哪段代码把它生出来的。
-        m.setCharterProvider((target) => {
+        m.setCharterProvider((target, ctx) => {
             // 这里是最要紧的那道拦截: 宪章把「所在聊天」写进系统提示, 而系统提示是随进程
             // 终身的 —— 一个在聊天还没名字时出生的 wizard, 会一辈子以为自己住在一个
             // 「(未命名)」的地方。所以补名要发生在渲染之前, 不能等它以后自己去查。
             ensureChatNames(target);
             const rec = wizards.get(target);
-            return charterFor(target, { parent: rec?.parent, inherited: !!rec?.clonedFrom });
+            return charterFor(target, { parent: rec?.parent, forkOf: rec?.forkOf, inherited: !!rec?.clonedFrom, cwd: ctx?.cwd });
         });
         // 开机也补一次: IM 侧的 `/peers`、`/help` 直接读名字, 不经过任何 MCP 路由。
         // 延后是因为附着表要先从盘上恢复完, 否则这一刻还看不见那些聊天; 补不全也无妨,
@@ -1050,9 +1105,10 @@ const main = async () => {
                 chat: chatNameOf(cfg, target),
                 principal: baseOfKey(target),
                 tag: tagOfKey(target),
-                named: !!(rec?.name ?? "").trim() || !!chatNameOf(cfg, target),
+                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 ?? "",
@@ -1114,9 +1170,8 @@ const main = async () => {
             ensureChatNames(self);
             json(res, 200, { ok: true, ...identityOf(self, self), peers: (await m.peers(self)).filter((p) => !p.self).length });
         });
-        // 起名字 / 写职责。默认会话的名字就是聊天的名字 (需求: wizard 的名字 = chat
-        // 的名字), 所以那一路同时写 chats 表 —— 否则别的聊天仍然叫不到它。带 tag 的
-        // 分身只写自己的记录, 它的地址本来就是 `chat#tag`。
+        // 改名字 / 写职责。名字全局唯一、与聊天名脱钩 (默认会话只是出生时取了聊天名):
+        // 撞名自动挂 `-N`, 返回里的 `name` 才是落定的那个。
         http.register("POST /wizard/identity", async (req, res) => {
             const { self, body } = await readPeerBody(req);
             if (!self) {
@@ -1124,31 +1179,26 @@ const main = async () => {
                 return;
             }
             const b = body;
-            const name = (b.name ?? "").toString().trim();
+            const asked = normalizeTag((b.name ?? "").toString());
             const description = (b.description ?? "").toString().trim();
-            const wasNamed = !!wizardName(wizards.get(self), chatNameOf(cfg, self), self);
-            let chatNamed;
-            if (name && !tagOfKey(self)) {
-                const r = setChatName(cfg, sourcePath, self, name);
-                if (!r.ok) {
-                    json(res, 409, { ok: false, reason: r.reason });
-                    return;
-                }
-                chatNamed = r.name;
+            if ((b.name ?? "").toString().trim() && !asked) {
+                json(res, 400, { ok: false, reason: "名字只能是 1-32 位字母/数字/`_`/`-`" });
+                return;
             }
-            wizards.upsert(self, {
-                ...(name ? { name: chatNamed ?? name } : {}),
-                ...(description ? { description } : {}),
-            });
+            const before = settleName(wizards, chatNameOf(cfg, self), self);
+            const name = asked ? wizards.rename(self, asked) : before;
+            if (description)
+                wizards.upsert(self, { description });
             const me = identityOf(self, self);
-            // 起名是稀有事件, 值得在群里留一条 —— 人得知道群里这个角色叫什么了。
-            if (name && !wasNamed)
-                notifyChat(self, withTagHeader(self, `我是 **${me.name}**${description ? ` · ${description}` : ""}`));
-            // 职责是别人决定"该不该找你"的依据, 改了就得让同群的人知道 —— 否则他们照着
+            // 职责是别人决定"该不该找你"的依据, 改了就得让同群的知道 —— 否则他们照着
             // 出生快照里那句旧的 (或者空的) 职责派活。
-            if (name || description)
-                postRoster(baseOfKey(self), [self], `**${me.name || me.address}** 改了身份 · 地址 \`${peerAddress(cfg, baseOfKey(self), self)}\`${description ? ` · 职责: ${description}` : ""}`);
-            json(res, 200, { ok: true, ...me, chatNamed });
+            if (asked || description)
+                postRoster(baseOfKey(self), [self], `${before && before !== name ? `**.${before}** 改名为 **.${name}**` : `**.${name}** 改了身份`}${description ? ` · 职责: ${description}` : ""}`);
+            json(res, 200, {
+                ok: true,
+                ...me,
+                ...(asked && name.toLowerCase() !== asked.toLowerCase() ? { renamed: `'.${asked}' 已被占用, 落定为 '.${name}'` } : {}),
+            });
         });
         // 名册是**索引**, 不是转储: 这台机器上现在有 300+ 个会话, 整表吐出来是三万
         // token —— 一个 wizard 每次想找人都付这个价, 等于找不到人。所以服务端过滤
@@ -1188,6 +1238,9 @@ const main = async () => {
                     : {}),
             });
         });
+        // 记忆三种作用域: 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) {
@@ -1195,14 +1248,42 @@ const main = async () => {
                 return;
             }
             const b = body;
-            const cur = wizards.get(self)?.memory ?? [];
             const note = (b.note ?? "").toString().trim();
             const forget = (b.forget ?? "").toString().trim();
+            const scope = (b.scope ?? "self").toString();
+            if (scope === "chat" || scope === "workspace") {
+                const key = scope === "chat" ? baseOfKey(self) : (m.getCwd(self).runningCwd || m.getCwd(self).defaultCwd);
+                if (!key) {
+                    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 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 ?? [];
             // 忘记按子串匹配: 模型记不住自己当初一字不差写了什么, 但记得大意。
             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, memory, added: !!note, forgotten: cur.length - next.length });
+            json(res, 200, { ok: true, scope: "self", memory, added: !!note, forgotten: cur.length - next.length });
         });
         // 生分身。默认 fork 调用方此刻的上下文 —— 这是"先把公共材料读进来, 再分出 N
         // 个干活的"之所以省事的原因: 材料只读一遍, 却进了 N 份上下文。
@@ -1229,8 +1310,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 不值当。
@@ -1253,48 +1355,31 @@ const main = async () => {
                 });
                 return;
             }
-            const taken = new Set(m.chatTargets(base).map(tagOfKey).filter(Boolean));
-            const asked = normalizeTag(b.tag);
-            if (asked && taken.has(asked)) {
-                // "活着" 不能只看 taken 里有没有这个 tag —— taken 是 chatTargets(), 连早就
-                // 断线的冷绑定也算数。真探一次活, 把结论 (alive/busy/多久没动过) 和能直接
-                // 回传给 send_peer/stop_wizard 的完整地址一起吐回去, 调用方才判断得出这是
-                // "该换个名字" 还是"值得 stop_wizard 收掉腾地方再复用"。
-                const existing = keyOf(base, asked);
-                const info = (await m.peers(existing)).find((p) => p.target === existing);
-                const alive = info?.paneAlive ?? false;
-                const idleForMs = info?.lastActivity ? Date.now() - info.lastActivity : undefined;
-                const idleDesc = idleForMs !== undefined ? `静默 ${Math.round(idleForMs / 60000)} 分钟` : "从没动过";
-                const advice = alive
-                    ? "它的 pane 还活着 —— 除非这就是同一件事的延续, 否则换个 tag 重新 spawn_clone, 别把不相关的活塞给一个已经有职责的 wizard"
-                    : `pane 已经不在了 (${idleDesc}), 真要复用这个 tag 就先 stop_wizard({tag:"${asked}", mode:"end"}) 收掉腾出名字, 再用同一个 tag 重新 spawn_clone —— 拿到干净的上下文; 别直接 send_peer 唤醒它接手, 它会带着上一件事的记忆答你这件`;
-                json(res, 409, {
-                    ok: false,
-                    reason: `'#${asked}' 已经是一个${alive ? "活着的" : "不再活跃的"} wizard —— ${advice}`,
-                    tag: asked,
-                    address: peerAddress(cfg, self, existing),
-                    alive,
-                    busy: info?.busy ?? false,
-                    idleForMs,
-                });
+            const askedName = String(b.name ?? b.tag ?? "");
+            const slotR = await claimSlot(base, askedName, normalizeTag(b.description?.split(/\s+/)[0]) || "clone");
+            if (!slotR.ok) {
+                json(res, slotR.status, slotR.body);
                 return;
             }
-            const tag = asked || uniqueTag(normalizeTag(b.description?.split(/\s+/)[0]) || "clone", taken);
-            const target = keyOf(base, tag);
-            const parentInfo = m.sessionInfo(self);
+            const { target, slot: tag } = slotR;
+            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 charter = charterFor(target, { parent: self, inherited: inherit });
+            const name = wizards.rename(target, normalizeTag(askedName) || tag);
+            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: tag,
+                windowName: name,
                 cli: b.cli,
                 model: b.model,
                 cwd: b.cwd,
@@ -1303,34 +1388,34 @@ const main = async () => {
                 // 继承路径上第一句话是分叉的触发器, 所以直接把活当开场白 —— 少一次往返,
                 // 也少一次"就位了但没事干"的空转。
                 bootstrap: task || undefined,
+                keepalive,
             });
             if (!r.ok) {
                 wizards.drop(target);
                 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);
-            // 分身出生要在群里留一条 —— 群里多了一个成员, 人有权当场知道。
-            // 工单里的分身是临时工: 出生、派活各发一条气泡, 五路 fan-out 就是十条交叉的
-            // 气泡, 人从里面读不出结构。它们攒到收工那一条里一起交代 (成员 + 各自那段活),
-            // 中间过程照旧在各自的 chat 详情页。同理不惊动同群的其他 wizard。
+            // r.model 是 spawnTmuxClaude 通过 /model 实测确认落地的那个 —— 可能跟调用方
+            // 传的原始字符串不一样 (口语化 → 目录里匹配到的关键词), 播报要报实情。
+            const modelNote = r.model
+                ? (r.modelWarning ? ` · 模型 ${r.model} (⚠️ ${r.modelWarning})` : ` · 模型 ${r.model}`)
+                : "";
+            // 出生不再发群气泡 (人要看的是结论, 不是谁生了谁 —— 过程在 rolepage 里);
+            // 同群的 wizard 仍要知道群里多了一个成员。工单里的临时工连这条也省掉。
             if (!jobId) {
-                notifyChat(base, withTagHeader(target, `已就位 · ${r.inherited ? `${displayName(self)} 的分身 (继承了它的上下文)` : "全新 wizard (空白上下文)"}${kid.description ? ` · ${kid.description}` : ""}`));
-                postRoster(base, [target, self], `新 wizard **${kid.name || tag}** 就位 · 地址 \`${peerAddress(cfg, base, target)}\`${kid.description ? ` · ${kid.description}` : ""}${r.cwd ? ` · 工作区 ${r.cwd}` : ""}${b.model?.trim() ? ` · 模型 ${b.model.trim()}` : ""} —— ${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;
             if (task && !r.inherited) {
-                const inj = await m.injectText(target, task, undefined, { from: { kind: "peer", from: self, ...(jobId ? { job: jobId } : {}) } });
+                const inj = await m.injectText(target, task, undefined, { from: { kind: "peer", from: self, ...(jobId ? { job: jobId } : {}) }, channel: "" });
                 dispatched = inj.ok;
             }
             if (jobId)
                 jobs.attach(jobId, { target, task, spawned: true });
-            else if (dispatched)
-                relayPeer(self, target, task);
-            json(res, 200, { ok: true, target, tag, address: peerAddress(cfg, self, target), name: kid.name, inherited: r.inherited, sessionId: r.sessionId, cwd: r.cwd, dispatched, ...(jobId ? { job: jobId } : {}) });
+            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 } : {}) });
         });
         // 收掉一个 wizard。interrupt = 打断它这一轮 (Esc); end = 结束它并回收 pane。
         // 自己终结自己是合法的 (分身干完活自我了结), 代价是这次工具调用不会返回 ——
@@ -1342,7 +1427,7 @@ const main = async () => {
                 return;
             }
             const b = body;
-            const r = resolvePeer(self, b.tag ?? "");
+            const r = resolvePeer(self, addrOf(b));
             if (!r.ok) {
                 json(res, r.status, { ok: false, reason: r.reason, candidates: r.candidates });
                 return;
@@ -1390,6 +1475,9 @@ const main = async () => {
                 const idle = await waitForIdle(self, m.isBusy, 10 * 60_000, () => false);
                 if (!idle.idle) {
                     lg.warn({ reason: idle.reason }, "self-handoff: 目标一直忙, 放弃");
+                    // 之前这里只写日志: 调用方早就拿到 `scheduled:true` 挂了, 交接静悄悄
+                    // 放弃, 群里没有任何气泡告诉人。补一条 notify, 对齐它成功时的那条。
+                    notifyChat(self, withTagHeader(self, `上下文交接放弃: 一直没能闲下来 (${idle.reason}), 上下文和之前一样没动, 有空再试一次`));
                     return;
                 }
                 const clr = await m.injectText(self, "/clear");
@@ -1428,7 +1516,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) => {
@@ -1478,6 +1566,8 @@ const main = async () => {
         // ── 定时任务 ────────────────────────────────────────────────────
         // 到点把一句 prompt 注入一个 wizard 会话 —— 和人在群里对它说话走的是同一条路
         // (injectText), 所以 pane 死了会被拉起来, 输出照常落进群和详情页。
+        /** 日程归谁: 排班那个 wizard (createdBy); 老文件没写就归执行它的那个。 */
+        const ownerOf = (t) => t.owner || (cfg.defaultChat ?? "");
         http.register("POST /tasks/schedule", async (req, res) => {
             const { self, body } = await readPeerBody(req);
             if (!self) {
@@ -1491,15 +1581,15 @@ const main = async () => {
                 json(res, 400, { ok: false, reason: "prompt required" });
                 return;
             }
-            const when = parseWhen(whenText, new Date());
-            if (!when) {
-                json(res, 400, { ok: false, reason: `无法理解「${whenText}」。能认的说法: 每天/每个工作日/每周三 + 时刻 (晚上9:30 / 21:30 / 九点半), 每隔 N 分钟|小时, N 分钟后, 明早 9 点。` });
+            const trigger = parseTrigger(whenText, new Date());
+            if (!trigger) {
+                json(res, 400, { ok: false, reason: WHEN_HELP(whenText) });
                 return;
             }
             // tag 省略 = 排给调用者自己。这是最常见的用法: wizard 给自己定一个夜里跑的活。
             // 注入自身在**当下**是死锁 (往正在生成的输入框里打字), 但定时是未来的事,
             // 那时这一轮早已收工, 所以这里不套 /peers/send 的自我保护。
-            const tag = (body.tag ?? "").toString().trim();
+            const tag = addrOf(body).trim();
             let target = self;
             if (tag) {
                 const r = resolvePeer(self, tag);
@@ -1509,8 +1599,26 @@ const main = async () => {
                 }
                 target = r.target;
             }
-            const rec = addSchedule(cfg, sourcePath, { when, target, prompt, createdBy: self, note: (b.note ?? "").toString() });
-            json(res, 200, { ok: true, ...renderSchedule(rec), address: peerAddress(cfg, self, target) });
+            // 到点是新建还是续用, 在**排班时**就定死。两条都指向新建:
+            //   · 没点名 wizard —— 定时的 prompt 本就要求零上下文自洽, 没理由挑一个会话挤进去;
+            //   · prompt 自己就在说「建两个 wizard 去干 xxx」—— 这时 tag 只是「在谁的聊天/
+            //     目录下办」, 不是「在它的上下文里续」。
+            // `fresh` 显式传入压过这两条推断 (要强行在 tag 那一轮里续就传 false)。
+            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 });
+            if ("error" in created) {
+                json(res, 400, { ok: false, reason: created.error });
+                return;
+            }
+            tasks.patchState(id, { createdAt: Date.now() });
+            json(res, 200, {
+                ok: true,
+                ...renderTask(created, tasks.stateOf(id)),
+                address: peerAddress(cfg, self, target),
+                owner: peerAddress(cfg, self, self),
+            });
         });
         http.register("POST /tasks/list", async (req, res) => {
             const { self, body } = await readPeerBody(req);
@@ -1520,9 +1628,20 @@ const main = async () => {
             }
             const mineOnly = body.mine === true;
             const now = new Date();
-            const tasks = listSchedules(cfg, mineOnly ? self : undefined)
-                .map((x) => ({ ...renderSchedule(x, now), address: peerAddress(cfg, self, x.target) }));
-            json(res, 200, { ok: true, self, tasks });
+            const errs = tasks.errors();
+            const rows = tasks.list()
+                .filter((t) => !mineOnly || ownerOf(t) === self)
+                .map((t) => ({
+                ...renderTask(t, tasks.stateOf(t.id), now, errs[t.id]),
+                address: peerAddress(cfg, self, t.target || (cfg.defaultChat ?? "")),
+                owner: peerAddress(cfg, self, ownerOf(t)),
+            }));
+            // 加载失败的那些没有记录可回显, 但必须出现在列表里 —— 否则 wizard 改错了
+            // 一个字, 那条定时就像凭空消失了。
+            const broken = Object.entries(errs)
+                .filter(([id]) => !tasks.get(id))
+                .map(([id, loadError]) => ({ id, file: `${tasks.dir}/${id}.task.mjs`, loadError }));
+            json(res, 200, { ok: true, self, dir: tasks.dir, tasks: [...rows, ...broken] });
         });
         http.register("POST /tasks/cancel", async (req, res) => {
             const { self, body } = await readPeerBody(req);
@@ -1535,12 +1654,13 @@ const main = async () => {
                 json(res, 400, { ok: false, reason: "id required (list_tasks 里那个 id)" });
                 return;
             }
-            const gone = removeScheduleById(cfg, sourcePath, id);
+            const state = tasks.stateOf(id);
+            const gone = tasks.remove(id);
             if (!gone) {
                 json(res, 404, { ok: false, reason: `no schedule with id ${id}` });
                 return;
             }
-            json(res, 200, { ok: true, removed: renderSchedule(gone) });
+            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) => {
@@ -1643,22 +1763,103 @@ const main = async () => {
             }
             json(res, 200, { ok: true, target, ...m.getCwd(target) });
         });
+        // 定时任务的执行体。schedule_task 的 prompt 设计上本就要求"零上下文也能执行"
+        // (到点时目标可能早已 /clear 过, 它只看得见这一句) —— 既然如此, 默认就不在任何
+        // 已有会话里跑: 硬塞进去会把两件不相关的事挤进同一个 transcript, 目标正忙时
+        // 还要连触发时间点一起被它那一轮拖走。所以到点起一个白板 wizard 单独执行,
+        // 跑完自动收掉。只有排班时点名了某个 wizard (fresh=false) 且它此刻闲着,
+        // 才把这句话直接投进它那一轮 —— 「在已有会话里继续」是要求出来的, 不是默认。
+        scheduledTaskInject = async (target, text, { taskId, fresh }) => {
+            const busy = fresh ? false : await m.isBusy(target);
+            if (!fresh && !busy)
+                return m.injectText(target, text, undefined, { fromChat: true, from: { kind: "task", taskId } });
+            // 执行体挂在日程的主人名下: 名字 `<主人>-task-xxxx`, parent = 主人 —— 它的
+            // rolepage 里看得见这一枪是谁的日程放的。落在执行目标的群/目录里。
+            const base = baseOfKey(target);
+            const rec = tasks.get(taskId);
+            const owner = rec ? ownerOf(rec) : target;
+            const ownerName = settleName(wizards, chatNameOf(cfg, owner), owner) || "task";
+            const slotR = await claimSlot(base, "", `${ownerName}-task-${taskId.slice(0, 4)}`);
+            if (!slotR.ok)
+                return { ok: false, reason: "起白板 wizard 失败: 挑不出槽位" };
+            const runner = slotR.target;
+            const info = m.sessionInfo(target);
+            const why = busy ? ` (起因: ${displayName(target)} 当时正忙)` : "";
+            wizards.upsert(runner, {
+                description: `定时任务 ${taskId} 的一次性执行体${why}`,
+                parent: owner,
+                bornAt: Date.now(),
+            });
+            const runnerName = wizards.rename(runner, `${ownerName}-task-${taskId.slice(0, 4)}`);
+            const spawned = await m.newSession(runner, runnerName, info?.cli, { cwd: info?.cwd, model: info?.model, silent: true });
+            if (!spawned.ok) {
+                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 } });
+            if (!inj.ok) {
+                wizards.drop(runner);
+                return inj;
+            }
+            // 没有人会对这个一次性分身喊 stop_wizard, 只能自己等它闲下来再收。30min
+            // 内没闲下来就放弃自动回收 (它大概率还在干一个长活), 留给人手动处理 ——
+            // 比杀掉一个还在跑的 pane 安全。
+            void (async () => {
+                const idle = await waitForIdle(runner, m.isBusy, 30 * 60_000, () => false);
+                if (!idle.idle) {
+                    log.warn({ runner, reason: idle.reason }, "task runner: 30min 未闲下来, 放弃自动回收");
+                    return;
+                }
+                await m.killPane(runner);
+                wizards.drop(runner);
+            })();
+            return inj;
+        };
     }
-    // 定时调度器 — 每 20s 检查 cfg.schedules, 到点把 prompt 注入目标 wizard。
-    // inject 只在 mirror 模式给得出 (headless 模式没有常驻会话可注入)。
+    // 定时调度器 — 每 20s 检查任务表, 到点把 prompt 注入目标 wizard。
+    migrateLegacySchedules(cfg, sourcePath, tasks, log.child({ mod: "tasks" }));
     const scheduler = startScheduler({
         client: ws.client,
-        cfg,
-        sourcePath,
+        registry: tasks,
         log: log.child({ mod: "tasks" }),
-        inject: cfg.wrc.mode === "mirror"
-            ? (target, text, taskId) => bridge.injectText(target, text, undefined, { fromChat: true, from: { kind: "task", taskId } })
-            : undefined,
+        inject: scheduledTaskInject,
+        // gate 里的 `sh` 默认就在目标 wizard 此刻的工作区跑 —— 任务文件里不必写死绝对路径。
+        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.mirror.idleReapHours > 0) {
+        const ttlMs = cfg.wrc.mirror.idleReapHours * 3.6e6;
+        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"
+                : pendingSids.has(sid) ? "pending approval"
+                    : undefined);
+            if (r.reaped.length)
+                log.info({ reaped: r.reaped.length, targets: r.reaped }, "idle reap sweep");
+        };
+        reapTimer = setInterval(() => void sweep().catch((e) => log.warn({ err: e.message }, "idle reap sweep failed")), 30 * 60_000);
+        reapTimer.unref();
+    }
     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