cs-bots 0.9.0 → 0.9.3

package/CHANGELOG.md

@@ -13,6 +13,18 @@
 
 ---
 
+## [0.9.3] - 2026-11-12
+
+建议可编辑：内容可改、等级可选（L1–L5）。
+
+## [0.9.2] - 2026-11-12
+
+任务栏对话合并：用户发言与执行者回复同屏。
+
+## [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.3（改造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.3（改造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.3（改造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.3（改造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.3",
   "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,71 @@ 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,
+      // ⚠️ 必须是 `everyone`，不能是 `admin`（2026-11-12 t-46 缺陷#5 实测修正）。
+      //
+      // 曾经的错误推理：「负责人是群主 ⇒ admin 模式（他能改名/归档）」。
+      // 但 `admin` 模式在 `src/room.js:1754` 会把**除群主外的所有成员**挡在门外：
+      //     ROOM_POST_FORBIDDEN：成员 … 无发言权
+      // 而这个房间的用途恰恰是「**别人**把长任务的结果回传进来」——
+      // 执行者不是群主，于是结果一条都发不出去，需求直接落空。
+      //
+      // 群主/负责人的特权用 `adminId` 之外的方式表达（成员表里首位 = 负责人），
+      // 不靠牺牲发言权来换。
+      mode: 'everyone',
+      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 +2273,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 +2365,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 +2420,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 +2456,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 +2674,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 +2764,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) {
@@ -4692,6 +4858,23 @@ export function installApi(ctx, { warn } = {}) {
         sendJson(response, 200, { ok: true, suggestion: applied })
         return
       }
+      // 修改待决建议（t-40）：内容 / 等级 / 类型都能改，改完仍是 pending。
+      // Boss：「用户应该可以修改完善并确定等级范围」——只给采纳/驳回，措辞不合意就只能驳回重等。
+      if (request.method === 'POST' && path === '/suggestions/edit') {
+        const body = (await readBody(request)) ?? {}
+        const item = await withService(services, 'suggest', (sg) => sg.edit({
+          id: body.id,
+          expectedRev: body.expectedRev,
+          kind: body.kind,
+          layer: body.layer,
+          title: body.title,
+          content: body.content,
+          payload: body.payload,
+          by: body.by ?? OWNER,
+        }))
+        sendJson(response, 200, { ok: true, suggestion: item })
+        return
+      }
       if (request.method === 'POST' && path === '/suggestions/reject') {
         const body = (await readBody(request)) ?? {}
         const item = await withService(services, 'suggest', (s) =>
@@ -5231,30 +5414,94 @@ export function installApi(ctx, { warn } = {}) {
           sendJson(response, 404, { ok: false, reason: `任务 ${id} 不存在` })
           return
         }
-        // 找执行者会话：assignee → ownerId → 平台伪身份排除
+        // ══ t-40 需求（2026-11-12）：任务栏要看到「用户说的话」+「Bot 的回复」═════
+        // 原实现只读**执行者的会话**，看不到用户自己说过什么：
+        // 用户在页面上发的指令走的是**用户自己的会话**（或只落进 task.note），
+        // 执行者会话里只有 Bot 的输出 —— 于是任务栏永远缺一半。
+        //
+        // 现在改成**多会话合并成一条时间线**，每条消息标注来源：
+        //   ① 执行者会话（Bot 怎么干的、说了什么）
+        //   ② 用户会话（用户下了什么令 —— 从 task.note 的 by 反查不到会话时，
+        //      仍用 note 行兜底，保证「用户说过的话」至少不会丢）
+        // 合并后按时间升序，前端按 role/source 区分气泡。
+        const HUMAN_IDS_ = new Set(['ui', 'user', 'person', 'anyone', 'system'])
         const candidates = [task.assignee, task.ownerId, task.anchor?.ownerId]
-          .filter((v) => typeof v === 'string' && v && !['ui', 'user', 'anyone', 'system'].includes(v))
-        if (candidates.length === 0) {
-          sendJson(response, 200, {
-            ok: false,
-            reason: '这个任务还没有执行者（未派活），没有对话可看',
-            code: 'NO_EXECUTOR',
-          })
-          return
-        }
-        // 把候选 sessionId 映射到 Bot 记录（拿真名）
+          .filter((v) => typeof v === 'string' && v && !HUMAN_IDS_.has(v))
+
+        // 执行者身份（拿真名用）
         let bot
         try {
           const all = services.roster?.list?.({ includeRetired: true }) ?? []
           bot = all.find((b) => candidates.includes(b.sessionId) || candidates.includes(b.id))
         } catch { bot = undefined }
         const sessionId = bot?.sessionId ?? candidates[0]
-        const limit = qn(url, 'limit')
-        const out = await readSessionMessages(ctx, sessionId, { limit: limit ?? 40 })
+
+        const limit = qn(url, 'limit') ?? 40
+        /** @type {Array<object>} 合并后的时间线 */
+        const timeline = []
+
+        if (sessionId) {
+          const out = await readSessionMessages(ctx, sessionId, { limit })
+          if (out?.ok && Array.isArray(out.messages)) {
+            for (const m of out.messages) {
+              timeline.push({
+                ...m,
+                source: 'executor',
+                speaker: bot?.name ?? sessionId,
+                sessionId,
+              })
+            }
+          }
+        }
+
+        // 用户侧：任务的补充说明（note）就是「用户在任务里说的话」的权威记录。
+        // 它**一定存在**且一定属于这个任务，比猜会话可靠 —— 所以以它为准，
+        // 不依赖「用户当时在哪个会话里」这种我们记录不到的信息。
+        try {
+          const notes = typeof readTaskNotes === 'function' ? readTaskNotes(services, id) : []
+          for (const n of notes) {
+            if (!n || typeof n.text !== 'string' || !n.text.trim()) continue
+            const by = typeof n.by === 'string' ? n.by : 'user'
+            timeline.push({
+              role: HUMAN_IDS_.has(by) ? 'user' : 'assistant',
+              kind: 'text',
+              text: n.text,
+              at: Number.isFinite(Number(n.at)) ? Number(n.at) : undefined,
+              source: 'note',
+              speaker: HUMAN_IDS_.has(by) ? 'Boss' : by,
+            })
+          }
+        } catch { /* notes 读不到不影响主时间线 */ }
+
+        // 时间升序；没有时间戳的排在前面（避免被甩到最后）
+        timeline.sort((a, b) => {
+          const ta = Number.isFinite(a.at) ? a.at : 0
+          const tb = Number.isFinite(b.at) ? b.at : 0
+          return ta - tb
+        })
+
+        if (timeline.length === 0) {
+          sendJson(response, 200, {
+            ok: false,
+            reason: '这个任务还没有对话记录（未派活、也没有补充说明）',
+            code: 'NO_CONVERSATION',
+          })
+          return
+        }
+
         sendJson(response, 200, {
+          ok: true,
           ...(bot ? { bot: { id: bot.id, name: bot.name, label: bot.label ?? null } } : {}),
-          sessionId,
-          ...out,
+          sessionId: sessionId ?? null,
+          messages: timeline,
+          total: timeline.length,
+          // 分开给，前端要单看某一侧时不用自己筛
+          counts: {
+            executor: timeline.filter((m) => m.source === 'executor').length,
+            note: timeline.filter((m) => m.source === 'note').length,
+            user: timeline.filter((m) => m.role === 'user').length,
+            assistant: timeline.filter((m) => m.role === 'assistant').length,
+          },
         })
         return
       }

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
   }