cs-bots 0.9.0 → 0.9.1

package/CHANGELOG.md

@@ -13,6 +13,10 @@
 
 ---
 
+## [0.9.1] - 2026-11-12
+
+任务来源渠道；任务开议事厅；每轮 md 产出物；用户身份归一；清理退役 Bot。
+
 ## [0.9.0] - 2026-11-11
 
 > 第 1 批 = 定向唤醒 / kind 字段 / attachRoom（止血）

package/docs/01-/346/236/266/346/236/204/346/226/207/346/241/243.md

@@ -1,6 +1,6 @@
 # cs-bots 架构总览（改造07 · 分层架构 + 改造08 · 人机分治）
 
-> 版本：v0.9.0（改造07 分层 + 改造08 需求1–5 + 改造09 Boss 体验/任务可管理性/升级接续）
+> 版本：v0.9.1（改造07 分层 + 改造08 需求1–5 + 改造09 Boss 体验/任务可管理性/升级接续）
 > 日期：2026-11-10
 > 状态：改造09 进行中 —— 套件规模 1190 项，截至 2026-11-10 有 6 项失败待修（详见 `docs/CONTRACT-升级09-Boss体验.md` §10）。改完前**不要**把本文当作「全绿」依据。
 
@@ -50,7 +50,7 @@
 │                                                              │
 │  ┌──────────────────────────────────────────────────────┐   │
 │  │         AI 智能体调用接口（机器友好、可审计）          │   │
-│  │   43 个 bot_* 工具 + HTTP API                          │   │
+│  │   45 个 bot_* 工具 + HTTP API                          │   │
 │  └──────────────────────────────────────────────────────┘   │
 └─────────────────────────────────────────────────────────────┘
 ```
@@ -141,7 +141,7 @@
 | 后端运行时 | Node.js ≥22.5，ESM，零第三方运行时依赖 |
 | HTTP API | 宿主 `webServer.register`（前缀路由 `/cs-bots/api`） |
 | 前端 | React 18，宿主模块加载器 `window.__ModuleLoader__.load` |
-| 模型工具 | 宿主 `tools.register`，43 个 `bot_*` 工具 |
+| 模型工具 | 宿主 `tools.register`，45 个 `bot_*` 工具 |
 | 持久化 | JSONL 事件流 + 原子快照，SQLite 不引入 |
 | 安全 | 会话鉴权围栏 + 同源校验 + 受保护区 + CSRF 防护 |
 
@@ -212,7 +212,7 @@ src/subscription.js    任务订阅 + 房间扇出（改造07 新增）
 src/routing/           复杂度路由
 src/store.js           存储原语（jsonl + 快照 + 幂等集 + 原子写）
 src/kernel.js          宿主桥（唯一可引用宿主包的文件）
-src/tools.js           43 个模型工具
+src/tools.js           45 个模型工具
 src/index.js           装配入口
 ```
 
@@ -227,7 +227,7 @@ src/index.js           装配入口
 | 房间→任务 | 无连接 | Subscription 扇出 |
 | Bot 开工 | 无准备步骤 | prepare command |
 | 底层可见性 | 无（黑盒） | 穿透面板（7 区块） |
-| 工具数 | 38 个 | 41 个 | **43 个**（改造09 新增 `bot_task_phase`，bots04 新增 `bot_team_route`） |
+| 工具数 | 38 个 | 41 个 | **45 个**（改造09 新增 `bot_task_phase`，bots04 新增 `bot_team_route`，t-40 新增 `bot_roster_purge`、`bot_task_room`） |
 | 测试数 | 949 项 | 1036 项 |
 
 ---

package/docs/02-/351/234/200/346/261/202/350/247/204/346/240/274/344/271/246.md

@@ -1,6 +1,6 @@
 # cs-bots 改造07 + 改造08（需求1–5）需求规格书
 
-> 版本：v0.9.0（改造07 分层 + 改造08 需求1–5 + 改造09 + bots04 大团队）
+> 版本：v0.9.1（改造07 分层 + 改造08 需求1–5 + 改造09 + bots04 大团队）
 > 日期：2026-11-09
 > 状态：已实现
 

package/docs/03-/350/257/246/347/273/206/350/256/276/350/256/241.md

@@ -1,6 +1,6 @@
 # cs-bots 改造07 + 改造08（需求1–5）详细设计文档
 
-> 版本：v0.9.0（改造07 分层 + 改造08 需求1–5 + 改造09 + bots04 大团队）
+> 版本：v0.9.1（改造07 分层 + 改造08 需求1–5 + 改造09 + bots04 大团队）
 > 日期：2026-11-09
 > 状态：已实现，1263 项测试全通过（`bash test/run-all.sh` exit 0）
 

package/docs/04-/346/223/215/344/275/234/346/211/213/345/206/214.md

@@ -1,6 +1,6 @@
 # cs-bots 改造07 + 改造08（需求1–5）用户操作手册
 
-> 版本：v0.9.0（改造07 分层 + 改造08 需求1–5 + 改造09 + bots04 大团队）
+> 版本：v0.9.1（改造07 分层 + 改造08 需求1–5 + 改造09 + bots04 大团队）
 > 日期：2026-11-09
 > 适用对象：使用 cs-bots 协作平台的人（不是 AI）
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cs-bots",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "type": "module",
   "description": "跨团队桥 + 定向唤醒 + 升级可回滚。",
   "main": "src/index.js",
@@ -57,5 +57,13 @@
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/dsh": ">=0.2.2-rc.1 <0.3.0"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/dsh": {
+      "optional": true
+    }
   }
 }

package/src/api.js

@@ -865,6 +865,16 @@ function buildTaskAnchorText(task, notes = [], longrun = null) {
     lines.push(...describeMandate(mandate))
   }
 
+  // ── 产出物要求（2026-11-12 t-40 需求③）─────────────────────────────────
+  // Boss：「成果，任务的产出物在此，每轮会话的都应该有 md 产出物」。
+  // 只靠 `complete` 强制 artifacts 不够 —— 那是**收尾时**才校验，
+  // 执行者中途几轮可以什么都不留下，等到最后一次性补一份，过程全丢。
+  // 所以把这条要求写进**每次唤醒**都会看到的锚文本里，每轮结束都留一份 md。
+  lines.push('成果（t-40 需求③）：本轮要有可点开的 md 产出物，不要只写进对话里 ——')
+  lines.push(`  · 每轮结束都把结论写成 md 文件，再用 bot_task_update(action='complete', artifacts=[...]) 登记；`)
+  lines.push('  · 中途轮次同样要留文件（过程记录也算成果），别等收尾才一次性补；')
+  lines.push('  · 没写文件就当没交付 —— 对话里的内容别人打不开、也追溯不了。')
+
   lines.push('补充说明（按时间，全部有效，不得忽略）：')
   for (const note of notes) {
     lines.push(`- [${formatAnchorTime(note?.at)}] ${note?.text ?? ''}`)
@@ -1779,6 +1789,63 @@ async function ensureTeamForBot(services, botSessionId, by) {
   }
 }
 
+/**
+ * 给团队确保一个议事厅并返回它（Boss 2026-11-12 需求：长任务自动建房）。
+ *
+ * ## 为什么要它
+ *   `ensureTeamForBot()` 只建**团队**，不建**房间**。于是长任务建完后：
+ *   - 团队有了，但成员没有地方说话；
+ *   - 结果只能靠人挨个去问，没有一处「这个长任务进展/结论」的公共出口。
+ *   Boss 原话：「以后每个长任务都自动创建房间，结果传递给房间群主」。
+ *
+ * ## 语义
+ *   - 团队已有房间 ⇒ 直接复用（幂等，不重复建）
+ *   - 没有 ⇒ 建 `${team.name} · 议事厅`，成员 = 负责人 + 团队现有成员 + **委托人**
+ *   - `adminId = team.leadId`（群主 = 负责人），与建团队时 `adminPolicy:'lead-only'` 一致
+ *   - 负责人已在成员里 ⇒ `mode:'admin'`，让他能改名/归档
+ *
+ * ## 失败不阻断
+ *   任务和团队已经建好了，房间没建上只是少一个沟通出口 —— 返回 `{reason}` 让调用方
+ *   如实带回给页面，**绝不静默**。
+ *
+ * @returns {Promise<{room?: object, created?: boolean, reason?: string}>}
+ */
+async function ensureRoomForTeam(services, team, by) {
+  const rooms = services.room
+  if (!team || !rooms || typeof rooms.create !== 'function') return { reason: '没有可用的房间服务或团队' }
+  try {
+    if (team.roomId) {
+      const existing = rooms.get?.(team.roomId)
+      if (existing) return { room: existing, created: false }
+      // 团队记着 roomId 但房间已不存在（被归档/删除）⇒ 下面重建，并在结果里说明
+    }
+
+    // 成员：负责人（群主）+ 团队现有成员 + 委托人（谁派的活谁要能看到结果）
+    const leadId = team.leadId
+    const memberList = [leadId, ...(Array.isArray(team.members) ? team.members : []), by]
+      .filter((v) => typeof v === 'string' && v !== '')
+    const members = [...new Set(memberList)]
+
+    const room = rooms.create({
+      name: `${team.name} · 议事厅`,
+      members,
+      // 负责人是群主 ⇒ admin 模式（他能改名/归档）；他一定在 members 里（上面首位）
+      mode: 'admin',
+      adminId: leadId,
+      purpose: `长任务「${team.name}」的议事厅：负责人主持，进展与结论回传到此`,
+      byId: by ?? 'ui',
+    })
+
+    // 把房间记到团队上（幂等；已有 roomId 的情况在这里被覆盖为新房）
+    if (typeof services.teams?.attachRoom === 'function') {
+      services.teams.attachRoom({ id: team.id, roomId: room.id, by: by ?? 'ui' })
+    }
+    return { room, created: true }
+  } catch (error) {
+    return { reason: `自动建房间失败：${error?.message ?? error}` }
+  }
+}
+
 /** 
  * 投递能力预检（2026-11-09 修复「任务指派后卡在排队中、失败无声」）。
  *
@@ -2198,10 +2265,29 @@ export function installApi(ctx, { warn } = {}) {
   }
   mountPhaseWrite(getServices(ctx))
 
+  // ── t-40 需求②：把「给任务开议事厅」挂到 services（供 bot_task_room 工具调用）──
+  // 与 HTTP `POST /tasks/room` 共用同一个实现，避免「页面能开、Bot 开不了」的漂移。
+  const openTaskRoom = async (services, taskId, by) => {
+    const task = await withService(services, 'board', (b) => b.get(taskId))
+    if (!task) return { ok: false, reason: `任务 ${taskId} 不存在` }
+    const who = task.assignee ?? task.ownerId ?? by
+    const got = await ensureTeamForBot(services, who, by)
+    if (!got?.team) return { ok: false, reason: '这个任务没有可用团队（没有负责人？）——先指派负责人再开议事厅' }
+    const r = await ensureRoomForTeam(services, got.team, by)
+    if (!r?.room) return { ok: false, reason: r?.reason ?? '建房失败' }
+    return { ok: true, roomId: r.room.id, name: r.room.name, created: r.created === true, teamId: got.team.id }
+  }
+  const mountTaskRoom = (services) => {
+    if (!services || typeof services !== 'object') return
+    services.openTaskRoom = (taskId, by) => openTaskRoom(services, taskId, by)
+  }
+  mountTaskRoom(getServices(ctx))
+
   const handler = async (request, response) => {
     const services = getServices(ctx)
     // 幂等重挂：services 若在 installApi 之后才注册，这里补上（写同一个 key）
     mountPhaseWrite(services)
+    mountTaskRoom(services)
     // 鉴权先于一切业务逻辑（连 URL 解析都不做，避免攻击面）
     const verdict = fence.judgeHttp(request)
     if (!verdict.ok) {
@@ -2271,7 +2357,8 @@ export function installApi(ctx, { warn } = {}) {
         const source = qp(url, 'source')
         const sort = qp(url, 'sort')
         const byId = qp(url, 'byId')
-        const opts = { status: status ?? undefined, attention: attention || undefined, priority: priority ?? undefined, source: source ?? undefined, sort: sort ?? undefined, byId }
+        const channel = qp(url, 'channel')
+        const opts = { status: status ?? undefined, attention: attention || undefined, priority: priority ?? undefined, source: source ?? undefined, channel: channel ?? undefined, sort: sort ?? undefined, byId }
         const tasks = await withService(services, 'board', (b) =>
           onlyReady ? b.ready() : b.list(opts),
         )
@@ -2325,6 +2412,29 @@ export function installApi(ctx, { warn } = {}) {
           autoTeam = await ensureTeamForBot(services, rest.assignee, rest.byId ?? 'ui')
         }
 
+        // ── 长任务自动建房间（Boss 2026-11-12 需求）────────────────────────
+        // 原话：「以后每个长任务都自动创建房间，结果传递给房间群主」。
+        // 为什么只给长任务建：普通任务一两天就结束，建房只会留下大量死房间；
+        // 长任务跨多次唤醒、要多个阶段交付，需要一个**公共出口**让群主看到进展与结论。
+        // 复用 autoTeam 的团队（不另建），团队没有就现场补一个。
+        let autoRoom
+        if (wantsLongrun && rest.autoRoom !== false) {
+          const by = rest.byId ?? 'ui'
+          let team = autoTeam?.team
+          if (!team) {
+            autoTeam = await ensureTeamForBot(services, rest.assignee ?? by, by)
+            team = autoTeam?.team
+          }
+          if (team) {
+            const got = await ensureRoomForTeam(services, team, by)
+            autoRoom = got.room
+              ? { roomId: got.room.id, name: got.room.name, created: got.created }
+              : { reason: got.reason }
+          } else {
+            autoRoom = { reason: autoTeam?.reason ?? '没有团队可用于建房' }
+          }
+        }
+
         // 阶段清单落在 task-meta.jsonl（与 evolve 同一份存储、同一形状）⇒
         // `buildTaskAnchorText` 自动带上，第一次唤醒就可见，不需要再转。
         if (wantsLongrun) {
@@ -2338,7 +2448,9 @@ export function installApi(ctx, { warn } = {}) {
           })
           sendJson(response, 200, {
             ok: true, task, phases: normalizedPhases, longrun: true, autoTeam,
-            note: '已按长任务创建；此后每次唤醒都会带上阶段清单',
+            ...(autoRoom ? { autoRoom } : {}),
+            note: '已按长任务创建；此后每次唤醒都会带上阶段清单'
+              + (autoRoom?.roomId ? `，进展与结论请回传到议事厅 ${autoRoom.roomId}` : ''),
           })
           return
         }
@@ -2554,6 +2666,42 @@ export function installApi(ctx, { warn } = {}) {
         return
       }
 
+      // ── 任务开议事厅（t-40 需求②）────────────────────────────────────────
+      // Boss：「只有长任务默认建房间，其他短任务默认不建房间，防止房间爆炸，
+      //        在任务页有『开议事厅』按钮，用户需要的时候再建」
+      // 长任务在 /tasks 创建时已自动建；短任务走这个端点按需建，幂等（已有就复用）。
+      if (request.method === 'POST' && path === '/tasks/room') {
+        const body = (await readBody(request)) ?? {}
+        const by = body.byId ?? 'ui'
+        const taskId = String(body.id ?? '').trim()
+        if (!taskId) { sendJson(response, 400, { ok: false, reason: 'id 必填' }); return }
+        // 与 bot_task_room 工具共用 openTaskRoom 一份实现（不写两套）
+        const r = await openTaskRoom(services, taskId, by)
+        if (!r.ok) {
+          sendJson(response, r.reason?.includes('不存在') ? 404 : 409, { ok: false, reason: r.reason })
+          return
+        }
+        sendJson(response, 200, {
+          ...r,
+          note: r.created === true ? '议事厅已建好' : '该任务已有议事厅，直接复用',
+        })
+        return
+      }
+
+      // 清理已退役 Bot（t-40）：retire 只是标记，这里把记录真正移出注册表。
+      // 只允许清 retired；不碰 cwd、不杀会话。
+      if (request.method === 'POST' && path === '/roster/purge') {
+        const body = (await readBody(request)) ?? {}
+        const result = await withService(services, 'roster', (r) => r.purge({
+          ids: body.ids,
+          allRetired: body.allRetired,
+          reason: body.reason,
+          byId: body.byId ?? 'ui',
+        }))
+        sendJson(response, 200, { ok: true, ...result })
+        return
+      }
+
       // ── 房间 ──────────────────────────────────────────────────────────────
       if (request.method === 'GET' && path === '/rooms') {
         // includeArchived=1 时连归档房一起返回（超级管理员的"回收站"视图）
@@ -2608,11 +2756,21 @@ export function installApi(ctx, { warn } = {}) {
         //   - 房间设置 `allowBotAutoPost` 为 false 时跳过（给用户关开关的权利）；
         //   - dedupKey 用消息 ID，天然幂等，同一消息不会重复唤醒；
         //   - dispatcher 缺失时降级为「只落消息不唤醒」，不抛错。
+        //
+        // ⚠️ 修复（2026-11-12 t-40-B）：目标计算改走 room 服务的 `computeWakeTargets`。
+        //   此前这里是裸的 `members.filter((m) => m !== skipSelf)`，**既不看
+        //   `mentionOnly`、也不排除人类 id** —— 实测 6 个房间全部设了
+        //   `mentionOnly: true`，却一次都没生效；8 成员房间一条消息 = 8 次模型调用，
+        //   打给 `ui/user/person` 的那几次必然 agent-not-live。
+        //   现在与 `room.relay()` 共用同一份四档规则（见 room.js computeWakeTargets）。
         const room = await withService(services, 'room', (r) => r.get(message.roomId))
         const senderSession = body.from ?? 'ui'
-        const members = room?.members ?? []
-        const skipSelf = (senderSession !== 'ui' && senderSession)
-        const toWake = members.filter((m) => m !== skipSelf)
+        const decided = await withService(services, 'room', (r) =>
+          r.computeWakeTargets(
+            { members: room?.members ?? [], settings: room?.settings },
+            { from: senderSession, text: message.text, mentions: message.mentions },
+          ))
+        const toWake = decided?.targets ?? []
         const wakeByTarget = new Map()
         if (toWake.length > 0 && room?.settings?.allowBotAutoPost !== false) {
           for (const target of toWake) {

package/src/board.js

@@ -362,6 +362,66 @@ function normalizeRequiresPaid(value, where) {
 }
 
 /** labels 归一：必须是字符串数组（可选；undefined ⇒ 不写字段）。 */
+/**
+ * 任务来源渠道（2026-11-12 t-40 需求①，「后续可以接其他任务来源」）。
+ *
+ * 为什么与 `source` 分成两个字段：
+ *   - `source` 回答「**谁**下的令」：`human`（人） / `ai`（智能体）——二分的归属问题；
+ *   - `channel` 回答「**从哪个入口**下的令」：UI 手工建 / 会话里产出 / 外部渠道接入……
+ * 两者正交：将来接「外部工单系统」时，它既是 `source:'external'` 也可能是人发起。
+ * 合成一个字段的话，每加一个渠道都要改 `source` 的判定，早晚把二分搞脏。
+ *
+ * 未知 channel 一律拒绝（`BOARD_BAD_CHANNEL`）而不是静默落一个拼错的值 ——
+ * 拼错的值会永久留在事件流里，之后所有按渠道统计都是错的。
+ */
+const TASK_CHANNELS = Object.freeze(['user', 'session', 'external'])
+
+/** 归一 `source`：显式给了就只接受 human/ai；没给就按 byId 推断（人是 ui/user/person）。 */
+function normalizeSource(value, byId, where) {
+  if (value === undefined || value === null || value === '') {
+    return isHumanId(byId) ? 'human' : 'ai'
+  }
+  if (value !== 'human' && value !== 'ai') {
+    const error = new Error(
+      `board.${where}：source 只能是 'human' 或 'ai'，收到 ${JSON.stringify(value)}`,
+    )
+    error.status = 400
+    error.code = 'BOARD_BAD_SOURCE'
+    throw error
+  }
+  return value
+}
+
+/**
+ * 归一 `channel`：没给就按来源推断 —— 人 → `user`，智能体 → `session`。
+ * `external` 留给「后续增加的其他渠道」显式声明（目前没有生产方，但字段与校验已就位）。
+ */
+function normalizeChannel(value, source, byId, where) {
+  if (value === undefined || value === null || value === '') {
+    return isHumanId(byId) || source === 'human' ? 'user' : 'session'
+  }
+  if (!TASK_CHANNELS.includes(value)) {
+    const error = new Error(
+      `board.${where}：channel 只能是 ${TASK_CHANNELS.join(' | ')}，收到 ${JSON.stringify(value)}`,
+    )
+    error.status = 400
+    error.code = 'BOARD_BAD_CHANNEL'
+    throw error
+  }
+  return value
+}
+
+/**
+ * 人类身份（与 room/teams 的 HUMAN_IDS 同口径）。
+ * 需求⑤：`ui`/`person` 都是历史写法，规范 id 统一为 `user`；这里仍全认（读侧兼容）。
+ */
+function isHumanId(id) {
+  return id === 'ui' || id === 'user' || id === 'person'
+}
+
+/** 规范用户 id（写侧一律用它）。 */
+const CANONICAL_USER = 'user'
+
 function normalizeLabels(value, where) {
   if (value === undefined || value === null) return undefined
   if (!Array.isArray(value)) {
@@ -877,6 +937,9 @@ export function createBoard(ctx, config = {}) {
       tasks.set(ev.taskId, t)
       events.push(clone(ev))
       idCounter = Math.max(idCounter, idNumber(ev.taskId))
+      // 老数据没有 channel（本字段 2026-11-12 才有）：回放时按 source 补默认值，
+      // 保证「读侧永远非空」，而不是让 UI 到处判空。
+      if (t && t.channel === undefined) t.channel = t.source === 'human' ? 'user' : 'session'
       if (t.sourceSeq) {
         sourceSeqIndex.set(t.sourceSeq, ev.taskId)
         idem.check(t.sourceSeq)
@@ -1002,7 +1065,7 @@ export function createBoard(ctx, config = {}) {
   }
 
   function list(options = {}) {
-    const { status, attention, priority, dueAt, source, sort, triaged } = options ?? {}
+    const { status, attention, priority, dueAt, source, channel, sort, triaged } = options ?? {}
     if (status !== undefined && status !== null) {
       if (!STATUSES.includes(status)) {
         throw new BoardError(
@@ -1032,6 +1095,10 @@ export function createBoard(ctx, config = {}) {
       if (source !== undefined && source !== null) {
         if (t.source !== source) continue
       }
+      // 需求①：按渠道过滤（user / session / external）——「后续接其他渠道」时无需改这里
+      if (channel !== undefined && channel !== null) {
+        if (t.channel !== channel) continue
+      }
       if (triaged !== undefined && triaged !== null) {
         const want = triaged === true || triaged === '1' || triaged === 'true'
         if ((t.triaged === true) !== want) continue
@@ -1086,15 +1153,17 @@ export function createBoard(ctx, config = {}) {
   function create(input = {}) {
     const {
       subject, description, blockedBy, writeScopes, priority, dueAt, byId, sourceSeq, now,
-      expectedComplexity, requiresPaid, source,
+      expectedComplexity, requiresPaid, source, channel,
       labels, milestone, cycle, estimate, assignee, reviewer, progress, triaged,
       mandate,
     } = input ?? {}
     const by = requireString(byId, 'byId', 'create')
-    // 来源判定：显式传了 source 就采信；否则按 byId 推断
-    // （'ui'/'user' → 人；其他（会话 ID/Bot ID）→ 智能体）
-    const src = source === 'human' || source === 'ai' ? source
-      : (by === 'ui' || by === 'user' ? 'human' : 'ai')
+    // 来源判定（2026-11-12 t-40 需求①）：
+    //   显式传了 source 就按白名单采信；否则**按 byId 推断**（'ui'/'user'/'person' → 人）。
+    //   新增 `channel` 字段承载「具体渠道」，source 仍是二分的「人/智能体」——
+    //   因为「谁下的令」与「从哪个入口下的令」是两个正交问题，混成一个字段必然打补丁。
+    const src = normalizeSource(source, by, 'create')
+    const chan = normalizeChannel(channel, src, by, 'create')
     const subj = requireString(subject, 'subject', 'create')
     const desc = normalizeDescription(description, 'create')
     const deps = stringList(blockedBy, 'blockedBy', 'create')
@@ -1116,6 +1185,7 @@ export function createBoard(ctx, config = {}) {
     const reviewerNorm = normalizeOptionalString(reviewer, 'reviewer', 'create')
     const progressNorm = normalizeProgress(progress, 'create')
     const triagedNorm = normalizeTriaged(triaged, 'create')
+    // 渠道归一（需求①：为「其他渠道」预留位置）
     // Mandate 授权留痕（可选；不给就是「未记录依据」，不伪造一个）
     const mandateNorm = normalizeMandate(mandate, 'create')
 
@@ -1152,7 +1222,7 @@ export function createBoard(ctx, config = {}) {
     /** @type {Record<string, unknown>} */
     const task = {
       id: taskId,
-      rev: 1, source: src,
+      rev: 1, source: src, channel: chan,
       subject: subj,
       description: desc,
       status: 'pending',
@@ -1814,10 +1884,25 @@ export function createBoard(ctx, config = {}) {
       next.rev = current.rev + 1
       next.status = 'pending'
       delete next.lease
-      delete next.ownerId
+      // ⚠️ **不删 ownerId**（2026-11-12 t-40-A 修复，Boss 原话「负责人不用切换，避免内容丢失」）。
+      //   旧行为是 `delete next.ownerId` —— 租约一过期就把「谁负责这个任务」这条事实抹掉，
+      //   任务打回 pending 后任何 Bot 都能领走，长任务的上下文归属就此断裂。
+      //   租约（lease）本来就该失效，但它失效**不代表负责人不再负责**：
+      //   - `lease` 是「谁现在正在动手」，过期即失效，必须清（否则任务永远不可被重新领取）；
+      //   - `assignee` 是「这个活归谁管」，**与租约生命周期无关**，不该被回收动作改写。
+      //   保留 ownerId 后，被回收的任务在板上显示「待领（原负责人 X）」，重派也仍可追溯。
+      const keeper = current.ownerId ?? current.assignee
+      if (typeof keeper === 'string' && keeper !== '') next.ownerId = keeper
+      else delete next.ownerId
+      // 回收原因留档：让人一眼看出「这条不是被释放的，是过期被回收的」
+      next.lastLeaseExpiredAt = at
+      next.lastLeaseExpiredOwner = current.lease.ownerId ?? null
       commit(current.id, 'lease_expired', current.lease.ownerId ?? null, at, before, next)
       recycled.push(current.id)
-      info(`[cs-bots/board] 租约回收：${current.id} 由 ${current.lease.ownerId} 于 ${new Date(exp).toISOString()} 过期 → pending`)
+      info(
+        `[cs-bots/board] 租约回收：${current.id} 由 ${current.lease.ownerId} 于 ${new Date(exp).toISOString()} 过期`
+        + ` → pending（负责人保留为 ${next.ownerId ?? '无'}）`,
+      )
     }
     return recycled
   }

package/src/room.js

@@ -162,10 +162,30 @@ const USER = 'user'
  * 缺省广播把 Boss 自己也算成唤醒目标，每次必失败一条。
  */
 const HUMAN_IDS = Object.freeze(['ui', 'user', 'person'])
-/** 是否为人类身份（房间转发一律跳过）。 */
+
+/**
+ * **规范用户 id**（2026-11-12 t-40 需求⑤）。
+ *
+ * Boss：「以后要统一一下名称……人=用户=boss=user=我」。
+ * 历史数据里同一个人有三种写法（`ui` 来自页面层、`user` 来自 API 层、`person` 来自早期约定），
+ * 于是「这是谁」在每一处都要判三遍，迟早漏一处。
+ *
+ * 采用**读兼容 + 写统一**，而不是一刀切改写历史：
+ *   - 读：`ui`/`person` 一律视为 `user`（`HUMAN_IDS` 仍然认它们，老数据不会失效）；
+ *   - 写：新写入一律用 `user`。
+ * 这样不破坏历史事件流（append-only，改历史等于伪造），又能让新数据只有一个写法。
+ */
+const CANONICAL_USER = 'user'
+
+/** 是否为人类身份（`ui`/`user`/`person` 都认 —— 读侧兼容）。 */
 function isHumanId(id) {
   return typeof id === 'string' && HUMAN_IDS.includes(id)
 }
+
+/** 把任意人类写法归一成规范 id `user`；非人类身份原样返回。 */
+function normalizeHumanId(id) {
+  return isHumanId(id) ? CANONICAL_USER : id
+}
 /** 房间事件类型集合（审计流可枚举）。 */
 const EVENTS = [
   'room_created',
@@ -352,6 +372,64 @@ function collectMentions(message, members) {
   return out
 }
 
+/**
+ * 计算「一条房间消息该唤醒谁」—— **唤醒风暴的唯一真相源**。
+ *
+ * 为什么抽成独立函数（2026-11-12 t-40-B 修复）：
+ * 房间有**两条**唤醒路径，过去各写一份目标计算，于是必然漂移：
+ *   - `room.relay()`（`POST /rooms/relay`）实现了四档规则；
+ *   - `POST /rooms/post`（Bot 用 `bot_room_post`、Boss 用 UI **都走这条**）却是
+ *     裸的 `members.filter((m) => m !== skipSelf)` —— 不看 `mentionOnly`、
+ *     不排除人类 id。实测 6 个房间全设了 `mentionOnly:true`，**一次都没生效**；
+ *     8 成员房间 ⇒ 一条消息 8 次模型调用，其中打给人类 id 的必然失败。
+ *
+ * 所以这里只留**一份**规则，两个调用点都用它。改规则只改这里。
+ *
+ * 四档，**顺序即优先级**（与 relay 原注释一致）：
+ *   ① 显式 targets → 原样采信（剔除人类，并 warn：那是调用方的错）
+ *   ② mentionOnly=true 且 @ 了某人 → 只打给被 @ 的成员（不含发送者/人类）
+ *   ③ mentionOnly=true 但没 @ → **空**（只落消息不唤醒，合法结果，不是错误）
+ *   ④ mentionOnly=false（显式关掉定向）→ 除发送者外的全部成员，**仍排除人类**
+ *
+ * @param {{ members?: string[], settings?: object, from?: string }} room 房间快照
+ * @param {{ from?: string, text?: string, mentions?: string[] }} message 消息
+ * @param {{ targets?: unknown, warn?: (m: string) => void }} [options]
+ *        显式目标（仅 relay 用）；`warn` 注入调用方所在作用域的日志器
+ *        （工厂内部有 `warn`，模块顶层没有 —— 这里显式注入，不靠隐式作用域）
+ * @returns {{ targets: string[], source: 'explicit'|'mention'|'mention-only-no-target'|'broadcast' }}
+ */
+function computeWakeTargets(room, message, options = {}) {
+  const members = Array.isArray(room?.members) ? room.members : []
+  const settings = room?.settings ?? DEFAULT_SETTINGS
+  const mentionOnly = settings.mentionOnly !== false
+  // 发送者自己永远不唤醒（发消息的人不需要被自己的消息叫醒）
+  const sender = message?.from ?? room?.from
+  /** 唤醒排除表：人类一律不算唤醒目标（人没有会话，唤醒必然 agent-not-live）。 */
+  const wakeable = (id) => id !== sender && !isHumanId(id)
+
+  if (options?.targets !== undefined && options?.targets !== null) {
+    let list = stringList(options.targets, 'targets', 'relay')
+    const humans = list.filter((t) => isHumanId(t))
+    if (humans.length > 0) {
+      const say = typeof options.warn === 'function' ? options.warn : () => {}
+      say(`[cs-bots/room] 显式 targets 含人类身份 ${humans.join(',')} —— 已剔除（人不可被唤醒）`)
+      list = list.filter((t) => !isHumanId(t))
+    }
+    return { targets: list, source: 'explicit' }
+  }
+
+  if (mentionOnly) {
+    const mentioned = collectMentions(message, members)
+    const targets = mentioned.filter(wakeable)
+    return targets.length > 0
+      ? { targets, source: 'mention' }
+      : { targets: [], source: 'mention-only-no-target' }
+  }
+
+  // ④ 显式关掉定向才广播 —— 即便如此也不唤醒人类、不唤醒发送者自己
+  return { targets: members.filter(wakeable), source: 'broadcast' }
+}
+
 /** 时间参数归一：缺省 now；支持 ms 数字与 Date。 */
 function normalizeNow(value, where) {
   if (value === undefined || value === null) return Date.now()
@@ -1966,42 +2044,29 @@ export function createRoom(ctx, config = {}) {
     let targetSource
     let noTargetReason
 
-    if (targets !== undefined && targets !== null) {
-      targetList = stringList(targets, 'targets', 'relay')
-      if (targetList.length === 0) {
-        throw new RoomError(
-          `room.relay：targets 是空数组 —— 拒绝空转发（静默无操作），请显式给出目标或省略该字段走缺省`,
-          'ROOM_NO_TARGETS',
-          { roomId: room.id, messageId: mid },
-        )
-      }
-      targetSource = 'explicit'
-      // 显式 targets 可能混进人类 —— 剔除，但这是**调用方的错**，如实 warn 不静默
-      const humans = targetList.filter((t) => isHumanId(t))
-      if (humans.length > 0) {
-        warn(`[cs-bots/room] relay 显式 targets 含人类身份 ${humans.join(',')} —— 已剔除（人不可被唤醒）`)
-        targetList = targetList.filter((t) => !isHumanId(t))
-      }
-    } else if (mentionOnly) {
-      // 从消息里解析「被 @ 的人」：mentions 字段 + text 里的 `@id`（与 admission.isAddressed 同口径）
-      const mentioned = collectMentions(message, room.members)
-      targetList = mentioned.filter(wakeable)
-      targetSource = 'mention'
-      if (targetList.length === 0) {
-        targetSource = 'mention-only-no-target'
-        noTargetReason = 'mention-only-no-target'
-      }
-    } else {
-      targetList = room.members.filter(wakeable)
-      targetSource = 'broadcast'
-      if (targetList.length === 0) {
-        throw new RoomError(
-          `room.relay：房间 ${room.id} 除发送者（${message.from}）外没有其他可唤醒成员，且未显式指定 targets`
-          + ' —— 拒绝空转发（静默无操作）',
-          'ROOM_NO_TARGETS',
-          { roomId: room.id, messageId: mid, from: message.from },
-        )
-      }
+    // 规则统一在 computeWakeTargets（t-40-B）：与 `POST /rooms/post` 共用同一份，
+    // 避免两条唤醒路径各写一套而再度漂移。
+    const decided = computeWakeTargets(room, message, { targets, warn })
+    targetList = decided.targets
+    targetSource = decided.source
+    if (targetSource === 'mention-only-no-target') noTargetReason = 'mention-only-no-target'
+    // 显式 targets 给了空数组 ⇒ 调用方契约违反，抛错（computeWakeTargets 只管剔除人类）
+    if (targetSource === 'explicit' && Array.isArray(targets) && targets.length === 0) {
+      throw new RoomError(
+        `room.relay：targets 是空数组 —— 拒绝空转发（静默无操作），请显式给出目标或省略该字段走缺省`,
+        'ROOM_NO_TARGETS',
+        { roomId: room.id, messageId: mid },
+      )
+    }
+    // 广播档但「除发送者外全是人类」⇒ 这是**配置错误**（没有 bot 可广播），抛错比静默诚实。
+    // 注意：mention 档的空结果不算错（③「只记录不打扰」是合法结果），二者不能混。
+    if (targetSource === 'broadcast' && targetList.length === 0) {
+      throw new RoomError(
+        `room.relay：房间 ${room.id} 除发送者（${message.from}）外没有其他可唤醒成员，且未显式指定 targets`
+        + ' —— 拒绝空转发（静默无操作）',
+        'ROOM_NO_TARGETS',
+        { roomId: room.id, messageId: mid, from: message.from },
+      )
     }
 
     // ── ③「没 @ 到谁」：合法空转发 —— 记事件、返回 relayed:0，**不抛错** ──────
@@ -2304,6 +2369,14 @@ export function createRoom(ctx, config = {}) {
     leave,
     post,
     relay,
+    /**
+     * 计算「这条消息该唤醒谁」（t-40-B）。
+     * 暴露给 `POST /rooms/post` 复用，保证两条唤醒路径共用同一份规则；
+     * 纯函数、不落盘、不唤醒，调用方自己决定要不要投递。
+     * 绑定本实例的 `warn`，这样 HTTP 路径的告警与 relay 走同一个 logger。
+     */
+    computeWakeTargets: (room, message, options = {}) =>
+      computeWakeTargets(room, message, { ...options, warn }),
     readBody,
     listMessages,
     // DESIGN-v2 ①：房间配置 / 归档 / 硬删 / 成员角色（签名见 DESIGN 契约，勿改名）
@@ -2338,5 +2411,6 @@ export const ROOM_DEFAULT_SETTINGS = Object.freeze({ ...DEFAULT_SETTINGS })
 
 /** 用户（人类）发送者 id（`from` 允许的特殊值）。 */
 export const ROOM_USER = USER
+export const ROOM_CANONICAL_USER = CANONICAL_USER
 
 export default createRoom

package/src/roster.js

@@ -100,6 +100,7 @@ const ACTIONS = [
   'create',
   'rename',
   'retire',
+  'purge',
   'set_cwd',
   'claim',
   'release',
@@ -517,6 +518,8 @@ export function createRoster(ctx, config = {}) {
         skipped += 1
         continue
       }
+      // purge 是终态：重放时把它从内存表移除，而不是复活成一条记录
+      if (ev.after.state === 'purged') { bots.delete(ev.botId); events.push(clone(ev)); continue }
       bots.set(ev.botId, clone(ev.after))
       events.push(clone(ev))
     }
@@ -694,7 +697,7 @@ export function createRoster(ctx, config = {}) {
    * @throws {RosterError} 缺字段 / 非法 cwd / 重名 / 会话创建失败 / 事件落盘失败
    */
   async function create(input = {}) {
-    const { name, cwd, label, model, instructions, preset, permission, profile, prepareCommand, byId, now } = input ?? {}
+    const { name, cwd, label, model, instructions, preset, permission, profile, prepareCommand, byId, now, adoptSession } = input ?? {}
     const by = requireString(byId, 'byId', 'create')
     const displayName = requireString(name, 'name', 'create')
     const dir = assertBotCwd(cwd, 'create')
@@ -707,6 +710,28 @@ export function createRoster(ctx, config = {}) {
     // ── 唯一性（校验通过后才动会话，避免「建了会话才发现重名」的资源泄漏）──
     assertNameFree(displayName, undefined, 'create')
 
+    // ── adoptSession：把**已存在的会话**注册成 Bot（2026-11-11 Boss 需求）──
+    // 为什么需要：`create()` 原本只会**新建**会话（`bot-${randomUUID()}`），
+    //   无法接管一个已经在跑、已有上下文的会话。Boss 要把当前会话（带着全部上下文）
+    //   变成可在协作平台派活的 Bot ⇒ 会话 id 必须保持不变。
+    // 语义边界：
+    //   - `adoptSession` 给出时**不建新会话**，注册表直接引用它；
+    //   - 该 sessionId 不能已被别的活跃 Bot 占用（`hasSession` 查重）；
+    //   - 退役 Bot 里的同名 session 不阻止接管（终态已释放名额）。
+    const adopt = optionalString(adoptSession, 'adoptSession', 'create')
+    if (adopt !== undefined) {
+      for (const other of bots.values()) {
+        if (other.state !== 'retired' && other.sessionId === adopt) {
+          throw new RosterError(
+            `roster.create：会话 ${adopt} 已被 Bot「${other.name}」（${other.id}）占用——`
+            + '同一会话不能注册成两个 Bot',
+            'ROSTER_SESSION_TAKEN',
+            { sessionId: adopt, occupiedBy: other.id },
+          )
+        }
+      }
+    }
+
     // ── 同 cwd 提示（非阻塞）：两个活 Bot 共用一个目录会撞 fs 写入边界 ──
     for (const other of bots.values()) {
       if (other.state !== 'retired' && other.cwd === dir) {
@@ -717,29 +742,41 @@ export function createRoster(ctx, config = {}) {
       }
     }
 
-    // ── 会话创建：**唯一能指定 cwd 的路径**（kernel.js:249-287）──
-    const id = `bot-${randomUUID()}`
-    let handle
-    try {
-      handle = await kernel.createSession(ctx, {
-        sessionId: id,
-        cwd: dir,
-        warn,
-        ...(preset !== undefined && preset !== null && preset !== '' ? { agentPreset: String(preset) } : {}),
-      })
-    } catch (error) {
-      throw new RosterError(
-        `roster.create：Bot「${displayName}」的会话创建失败（cwd=${dir}）→ ${error?.message ?? error}`
-        + '——已中止注册（不产生半成品 Bot）',
-        'ROSTER_SESSION_CREATE_FAILED',
-        { name: displayName, cwd: dir, cause: String(error?.message ?? error) },
-      )
-    }
-    const sessionId = pickSessionId(handle, id)
-    if (sessionId !== id) {
-      warn(
-        `[cs-bots/roster] 宿主返回的会话 id（${sessionId}）与请求的（${id}）不同——以宿主返回为准并记入注册表`,
-      )
+    // ── 会话：要么新建，要么接管已有（adoptSession）──
+    //
+    // 新建时这是**唯一能指定 cwd 的路径**（kernel.js:249-287）。
+    // 接管时**不碰会话**：那个会话已经在跑、有自己的 cwd 与上下文，
+    // 我们只是把它登记进注册表 —— 因此 `id` 直接沿用该 sessionId
+    // （不生成 `bot-xxx`），这样 `wake`/任务派活的目标 id 与真实会话对得上。
+    let id
+    let sessionId
+    if (adopt !== undefined) {
+      id = adopt
+      sessionId = adopt
+    } else {
+      id = `bot-${randomUUID()}`
+      let handle
+      try {
+        handle = await kernel.createSession(ctx, {
+          sessionId: id,
+          cwd: dir,
+          warn,
+          ...(preset !== undefined && preset !== null && preset !== '' ? { agentPreset: String(preset) } : {}),
+        })
+      } catch (error) {
+        throw new RosterError(
+          `roster.create：Bot「${displayName}」的会话创建失败（cwd=${dir}）→ ${error?.message ?? error}`
+          + '——已中止注册（不产生半成品 Bot）',
+          'ROSTER_SESSION_CREATE_FAILED',
+          { name: displayName, cwd: dir, cause: String(error?.message ?? error) },
+        )
+      }
+      sessionId = pickSessionId(handle, id)
+      if (sessionId !== id) {
+        warn(
+          `[cs-bots/roster] 宿主返回的会话 id（${sessionId}）与请求的（${id}）不同——以宿主返回为准并记入注册表`,
+        )
+      }
     }
 
     /** @type {Record<string, unknown>} */
@@ -929,6 +966,74 @@ export function createRoster(ctx, config = {}) {
     return committed
   }
 
+  /**
+   * 清理（purge）已退役的 Bot —— **把记录从注册表里真正移走**（2026-11-12 t-40，Boss 要求）。
+   *
+   * 为什么 retire 不够：`retire` 只是把 `state` 置为 `retired`，**记录永远留在注册表里**
+   * （`listRetired()` 能查到、`roster.jsonl` 里一堆测试残留），时间一长注册表就被
+   * 一堆没用的测试 Bot 撑满，管理页看不清到底有哪些在役 Bot。
+   *
+   * 语义边界（必须守住的四条）：
+   *   1. **只能清已退役的** —— 在役 Bot 一律拒绝（`ROSTER_PURGE_ACTIVE`）。
+   *      退役是"我不用它了"，清理是"把这条记录抹掉"；两步分开，避免手滑删在役 Bot。
+   *   2. **只动注册表，绝不动 cwd 目录、绝不动会话** —— Bot 的工作目录里可能有真实产物
+   *      （实测 `/home/ubuntu/output/开发测试001` 里存着 t36 调研报告），
+   *      删目录是不可逆且越权的，本函数**不碰文件系统**。
+   *   3. **事件流仍留档**：往 `roster.jsonl` 追加一条 `purge` 事件（`after` = 清理后的状态），
+   *      重放时据此把该 Bot 从内存表里移除 —— 这样「谁在什么时候清了谁」可审计，
+   *      而不是把历史抹得干干净净。
+   *   4. **幂等**：已清理的再清一次直接跳过（计入 `skipped`），不抛错。
+   *
+   * @param {{ ids?: string[], allRetired?: boolean, reason?: string, byId: string, now?: number }} input
+   *        `ids` 指定要清的 Bot；`allRetired: true` 清全部已退役的（与 `ids` 二选一）
+   * @returns {{ purged: string[], skipped: string[], refused: Array<{id: string, reason: string}> }}
+   */
+  function purge(input = {}) {
+    const { ids, allRetired, reason, byId, now } = input ?? {}
+    const by = requireString(byId, 'byId', 'purge')
+    const note = optionalString(reason, 'reason', 'purge')
+    const at = normalizeNow(now, 'purge')
+
+    let targets = []
+    if (allRetired === true) {
+      for (const b of bots.values()) if (b.state === 'retired') targets.push(b.id)
+    } else if (Array.isArray(ids)) {
+      targets = ids.map((x, i) => requireString(x, `ids[${i}]`, 'purge'))
+    } else {
+      throw new RosterError(
+        'roster.purge：必须给 ids（数组）或 allRetired:true（二选一）—— 拒绝无目标清理',
+        'ROSTER_PURGE_NO_TARGET',
+        {},
+      )
+    }
+
+    const purged = []
+    const skipped = []
+    const refused = []
+    for (const botId of targets) {
+      const current = bots.get(botId)
+      if (!current) { skipped.push(botId); continue }
+      if (current.state !== 'retired') {
+        // 在役 Bot 绝不清理：这是本条 API 最重要的护栏
+        refused.push({ id: botId, reason: `在役（state=${current.state}）—— 先 retire 再 purge` })
+        continue
+      }
+      const before = clone(current)
+      const next = clone(current)
+      next.rev = current.rev + 1
+      next.state = 'purged'
+      next.purgedAt = at
+      next.purgedBy = by
+      if (note !== undefined) next.purgeReason = note
+      // 写事件而不是把它从 jsonl 里抠掉：留档「谁清的、何时清的」
+      commit(botId, 'purge', by, at, before, next)
+      bots.delete(botId)
+      purged.push(botId)
+      info(`[cs-bots/roster] Bot ${botId}（「${current.name}」）已清理出注册表`)
+    }
+    return { purged, skipped, refused }
+  }
+
   /**
    * 换工作目录（**官方完全没有的语义**：teammate 强制继承父 cwd）。
    *
@@ -1461,6 +1566,7 @@ export function createRoster(ctx, config = {}) {
     hasSession,
     rename,
     retire,
+    purge,
     setPreset,
     setCwd,
     setPrepareCommand,

package/src/tools.js

@@ -94,6 +94,18 @@ const DEFS = [
         priority: { type: 'number', description: '优先级（数值越大越先）' },
         dueAt: { type: 'number', description: '截止时间（epoch ms）' },
         sourceSeq: { type: 'string', description: '幂等键：同键重复创建只产生一条' },
+        source: {
+          type: 'string',
+          enum: ['human', 'ai'],
+          description: '谁下的令：human=人（Boss）/ ai=智能体。不传则按调用者身份自动推断。',
+        },
+        channel: {
+          type: 'string',
+          enum: ['user', 'session', 'external'],
+          description:
+            '从哪个入口下的令（t-40 需求①）：user=用户在页面手工建 / session=会话里产出 / '
+            + 'external=外部渠道接入（预留）。不传则按 source 推断（人→user，智能体→session）。',
+        },
         expectedComplexity: {
           type: 'string',
           enum: ['T0', 'T1', 'T2', 'T3'],
@@ -144,7 +156,9 @@ const DEFS = [
   },
   {
     name: 'bot_task_list',
-    description: '列出 cs-bots 任务板上的任务。默认不含已删除（tombstone）；传 status 可只看某状态。',
+    description:
+      '列出 cs-bots 任务板上的任务。默认不含已删除（tombstone）；传 status 可只看某状态；'
+      + '传 source / channel 可按「谁下的令 / 从哪个入口下的令」筛选（t-40 需求①）。',
     parameters: {
       type: 'object',
       properties: {
@@ -153,12 +167,46 @@ const DEFS = [
           enum: ['pending', 'in_progress', 'completed', 'blocked', 'deleted'],
           description: '只看该状态',
         },
+        source: { type: 'string', enum: ['human', 'ai'], description: '只看该来源（人 / 智能体）' },
+        channel: {
+          type: 'string',
+          enum: ['user', 'session', 'external'],
+          description: '只看该渠道（用户手工 / 会话产出 / 外部接入）',
+        },
       },
       additionalProperties: false,
     },
     run: (s, a) => {
       if (!s.board) return failure('board-unavailable')
-      return success({ tasks: s.board.list(a?.status ? { status: a.status } : {}) })
+      // 只把**给了的**过滤条件传下去：给 undefined 会命中 `!== null` 分支造成误筛
+      const opts = {}
+      if (a?.status) opts.status = a.status
+      if (a?.source) opts.source = a.source
+      if (a?.channel) opts.channel = a.channel
+      return success({ tasks: s.board.list(opts) })
+    },
+  },
+  {
+    name: 'bot_task_room',
+    description:
+      '给任务开一个议事厅（群聊房间）。**长任务在建任务时就自动有了**，本工具用于：' +
+      '① 短任务按需开（Boss：「短任务默认不建房间，防止房间爆炸，需要时再建」）；' +
+      '② 长任务的议事厅丢了/想补一个。幂等：已有就复用，不会重复建。' +
+      '需要任务有负责人（没负责人就没有团队可挂）。',
+    parameters: {
+      type: 'object',
+      properties: { id: { type: 'string', description: '任务 id' } },
+      required: ['id'],
+      additionalProperties: false,
+    },
+    run: async (s, a, exec) => {
+      if (typeof s.openTaskRoom !== 'function') return failure('task-room-unavailable', { hint: '后端未注入 openTaskRoom' })
+      try {
+        const r = await s.openTaskRoom(String(a.id ?? ''), callerOf(exec))
+        return r.ok ? success(r) : failure('task-room-failed', { message: r.reason })
+      } catch (error) {
+        return failure(error?.code ?? 'task-room-failed', { message: String(error?.message ?? error) })
+      }
     },
   },
   {
@@ -428,6 +476,31 @@ const DEFS = [
       return success({ bots: [...live, ...retired] })
     },
   },
+  {
+    name: 'bot_roster_purge',
+    description:
+      '把**已退役**的 Bot 从注册表里真正清掉（retire 只是标记，记录会一直留着）。' +
+      '**只能清已退役的**：在役 Bot 一律拒绝。**不删工作目录、不杀会话** —— ' +
+      '只移除注册表记录，cwd 里的产物原样保留。清理动作在审计流里留档，可追溯。' +
+      'allRetired:true 一次清干净；或用 ids 指定。（**官方 roster 没有这个能力**）',
+    parameters: {
+      type: 'object',
+      properties: {
+        allRetired: { type: 'boolean', description: '清全部已退役的 Bot（与 ids 二选一）' },
+        ids: { type: 'array', items: { type: 'string' }, description: '指定要清的 Bot id 列表' },
+        reason: { type: 'string', description: '清理原因（写进审计流）' },
+      },
+      additionalProperties: false,
+    },
+    run: (s, a, exec) => {
+      if (!s.roster) return failure('roster-unavailable')
+      try {
+        return success(s.roster.purge({ ids: a.ids, allRetired: a.allRetired, reason: a.reason, byId: callerOf(exec) }))
+      } catch (error) {
+        return failure(error?.code ?? 'ROSTER_PURGE_FAILED', { message: String(error?.message ?? error) })
+      }
+    },
+  },
   {
     name: 'bot_roster_manage',
     description: