cs-bots 0.8.0 → 0.9.1

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) {
@@ -2675,7 +2833,30 @@ export function installApi(ctx, { warn } = {}) {
           }
         }
 
-        sendJson(response, 200, { ok: true, message, wakes: toWake.length, revives, fanout })
+        // ── t-39 第2批 C：发言同步给 DSH 原生 team 的 Lead（Boss 体验 item 5）──
+        //
+        // Boss 在 cs-bots 议事厅说话时，原生 team 的 Lead 感知不到 —— 两套团队模型
+        // 是分离的。这一步把消息也投递给绑定的原生 Lead（root session 路径，合法）。
+        //
+        // 诚实原则：同步失败**不报** ok:false（房间消息本身成功了），而是
+        // `leadSync.synced:false` + `reason`，页面据此显示「同步失败：<原因>」。
+        // 绝不装成功 —— 那比不显示更糟。
+        let leadSync
+        try {
+          leadSync = await withService(services, 'teams', (t) =>
+            t.syncToNativeLead({
+              roomId: message.roomId,
+              messageId: message.id,
+              text: message.text,
+              by: body.from ?? 'ui',
+              dispatcher: services.dispatcher,
+            }))
+        } catch (error) {
+          // 同步是附加动作：异常也必须变成可见的 synced:false，而不是 500
+          leadSync = { ok: true, synced: false, reason: 'SYNC_ERROR', detail: String(error?.message ?? error) }
+        }
+
+        sendJson(response, 200, { ok: true, message, wakes: toWake.length, revives, fanout, leadSync })
         return
       }
 
@@ -5000,6 +5181,82 @@ export function installApi(ctx, { warn } = {}) {
         sendJson(response, 200, { ok: true, team: out })
         return
       }
+      // ── 跨团队路由（t-39 第2批 A · HTTP 出口）───────────────────────────
+      //
+      // 为什么必须有这一条：页面上的「📤 发协作请求」按钮（client.js）就是打这个
+      // 路径的。只有 MCP 工具 `bot_team_route` 而没有 HTTP 出口 ⇒ Boss 点按钮 404。
+      //
+      // 复用 `teams.deliverRoute()` —— 与工具层**同一套序列编排**（决定 → 投递 →
+      // 留痕）。绝不在这里重写一遍，否则两条路的行为会漂。
+      if (request.method === 'POST' && path === '/teams/route') {
+        const body = (await readBody(request)) ?? {}
+        const out = await withService(services, 'teams', (t) =>
+          t.deliverRoute({
+            ...body,
+            by: body.by ?? OWNER,
+            // dispatcher 从装配层取出后注入：TeamsService 不反向依赖 dispatcher
+            dispatcher: services.dispatcher,
+          })).catch(markTeamError)
+        // refused 是**正常的业务结论**，不是服务器错误 ⇒ 200 带 decision:'refused'。
+        // 用 4xx 会让前端把它当异常处理，丢掉 reason 的可读性（DecisionKind 语义）。
+        sendJson(response, 200, out)
+        return
+      }
+
+      // ── 团队唤醒成本统计（t-39 第2批 D · HTTP 出口）─────────────────────
+      //
+      // 页面团队卡片要显示「今日唤醒 N 次」。数据源是 dispatcher 的 wakes.jsonl
+      // 按 teamId 聚合（`byTeam`）。不传 id ⇒ 返回全部团队的横向对比。
+      //
+      // `today` = 今日 0 点（本地时区）之后；`total` = 该团队历史累计。
+      if (request.method === 'GET' && path === '/teams/wake-stats') {
+        const id = qp(url, 'id')
+        const dispatcher = services.dispatcher
+        if (!dispatcher || typeof dispatcher.byTeam !== 'function') {
+          sendJson(response, 503, { ok: false, reason: 'DISPATCHER_UNAVAILABLE' })
+          return
+        }
+        const since = qn(url, 'since')
+        const nowMs = Date.now()
+        const midnight = since ?? new Date(nowMs).setHours(0, 0, 0, 0)
+        const todayAgg = dispatcher.byTeam({ since: midnight })
+        const allAgg = dispatcher.byTeam({})
+
+        const pick = (agg) => {
+          if (!id) {
+            return {
+              teams: agg.teams,
+              unassigned: agg.unassigned,
+              total: agg.total,
+            }
+          }
+          const hit = agg.teams.find((t) => t.teamId === id)
+          return hit ?? { teamId: id, count: 0, sent: 0, skipped: 0, failed: 0, pending: 0, targets: 0, targetsList: [] }
+        }
+        const today = pick(todayAgg)
+        const all = pick(allAgg)
+        if (id) {
+          sendJson(response, 200, {
+            ok: true,
+            id,
+            today: today.count ?? 0,
+            total: all.count ?? 0,
+            byResult: {
+              sent: today.sent ?? 0, skipped: today.skipped ?? 0,
+              failed: today.failed ?? 0, pending: today.pending ?? 0,
+            },
+            byResultAllTime: {
+              sent: all.sent ?? 0, skipped: all.skipped ?? 0,
+              failed: all.failed ?? 0, pending: all.pending ?? 0,
+            },
+            since: midnight,
+          })
+          return
+        }
+        sendJson(response, 200, { ok: true, since: midnight, today, all })
+        return
+      }
+
       // 管理策略（2026-11-09「管理员权限边界从页面控制」）：CAS 改团队的 adminPolicy。
       if (request.method === 'POST' && path === '/teams/policy') {
         const body = (await readBody(request)) ?? {}

package/src/board.js

@@ -87,6 +87,22 @@ const STATUSES = ['pending', 'in_progress', 'completed', 'blocked', 'deleted']
 const ACCEPT_RESULTS = ['pass', 'reject']
 /** 租约缺省 TTL（ms）。 */
 const DEFAULT_LEASE_MS = 300_000
+/**
+ * board 动作 → `src/metrics.js` 的 METRIC_KINDS 映射（bots04 欠账2）。
+ *
+ * 为什么需要这张表：board 的动作名（`claim`/`complete`/`accept`…）与 metrics 的
+ * 指标种类（`task_claim`/`task_complete`/`accept_pass`…）**不是同名**，而且不是一对一
+ * （`accept` 要按 result 拆成 pass/reject）。硬编码在 commit 里会变成一长串 if。
+ *
+ * 没有映射的动作（`create`/`edit`/`release`/`reopen`/`delete`）故意不记：
+ * metrics 的 METRIC_KINDS 里没有对应种类，**新增种类要同步改 metrics.js 与它的测试**，
+ * 不能在这里偷偷塞一个不认识的 kind（metrics.record 会抛错的）。
+ */
+const ACTION_TO_METRIC = Object.freeze({
+  claim: 'task_claim',
+  complete: 'task_complete',
+  block: 'task_blocked',
+})
 /** 复杂度档位（契约 §6 冻结；路由侧 `src/routing/complexity.js` 用同一套字面量）。 */
 const COMPLEXITY_TIERS = ['T0', 'T1', 'T2', 'T3']
 /**
@@ -346,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)) {
@@ -620,6 +696,31 @@ export function createBoard(ctx, config = {}) {
     : (Number.isFinite(config.wipLimitPerBot) && config.wipLimitPerBot >= 1 ? config.wipLimitPerBot : 2)
   const requireTriageForReady = settings.requireTriageForReady === true || config.requireTriageForReady === true
 
+  /**
+   * 指标旁路（bots04 欠账2）。
+   *
+   * 为什么是「注入」而不是从 ctx 取：服务注册表在 `src/registry.js` 用的是
+   * `WeakMap<ctx, services>`，且 `index.js` 里 **board 先于 metrics 装配的顺序不保证**。
+   * 用注入（`config.metrics`）能拿到**装配完成后的实例**，也避免 board→registry 的循环依赖。
+   *
+   * 取不到就不记（返回 false），绝不抛 —— 指标缺失是可接受的退化，
+   * 业务动作失败是不可接受的。
+   */
+  // ⚠️ 为什么支持函数：`index.js` 里 **board 先于 metrics 装配**（board 在 L130，
+  //    metrics 在 L276）。若只接受实例，board 装配时 metrics 还是 undefined，
+  //    埋点会永久静默失效 —— 那正是「256 条全是 turn_end」这类 bug 的成因。
+  //    传函数 ⇒ 每次记录时现取，装配顺序就不再影响正确性。
+  const metricsSink = config && config.metrics !== undefined ? config.metrics : null
+  function recordMetric(kind, taskId, by) {
+    let sink = metricsSink
+    if (typeof sink === 'function') {
+      try { sink = sink() } catch { sink = null }
+    }
+    if (!sink || typeof sink.record !== 'function') return false
+    sink.record({ kind, taskId: taskId ?? null, by: by ?? null })
+    return true
+  }
+
   const jsonlPath = statePath(stateDir, 'board.jsonl')
   const snapPath = statePath(stateDir, 'board.snap.json')
 
@@ -696,6 +797,20 @@ export function createBoard(ctx, config = {}) {
     }
     tasks.set(taskId, clone(after))
     events.push(event)
+    // ── 指标埋点（bots04 欠账2）─────────────────────────────────────────
+    // 为什么埋在 commit 而不是各个动作里：commit 是**所有**状态变更的唯一出口，
+    // 埋在这里才不会漏（create/update/claim/complete/accept 全过它）。
+    //
+    // 为什么必须**服务端**埋：此前 256 条 metrics 全是 `turn_end` —— 因为
+    // 只有 `index.js` 在回合结束自动记，其余 11 种 kind 只靠「谁主动调
+    // bot_metrics_record」才记，而没有任何业务代码主动调。PDCA 页面因此只看得见
+    // 「回合结束」一种指标，看不到验收通过率、任务认领率。
+    //
+    // 纪律：埋点失败**绝不能**影响业务动作 —— 主流程已经落盘成功，指标是旁路。
+    try {
+      const metricsAction = ACTION_TO_METRIC[action]
+      if (metricsAction) recordMetric(metricsAction, taskId, byId)
+    } catch { /* 指标是旁路，绝不影响主流程 */ }
     if (after.sourceSeq) {
       // 幂等键在这里登记（而不是在 create 开头），保证「校验/落盘失败不污染键」
       idem.check(after.sourceSeq)
@@ -822,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)
@@ -947,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(
@@ -977,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
@@ -1031,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')
@@ -1061,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')
 
@@ -1097,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',
@@ -1759,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
   }
@@ -1863,6 +2003,12 @@ export function createBoard(ctx, config = {}) {
       delete next.latestReport // 旧的收尾结论一并作废（重做后会重新产生）
       delete next.accepted // 驳回即取消「已验收」，与 acceptance.result='reject' 一致
     }
+    // 验收埋点（bots04 欠账2）：accept 的指标要按 result 拆成 pass/reject，
+    // 不能用 ACTION_TO_METRIC（那里是动作名→kind 的一对一映射）。
+    // 放在 commit **之前**：commit 成功后已经落盘，埋点是旁路，先记不影响主结果。
+    try {
+      recordMetric(result === 'pass' ? 'accept_pass' : 'accept_reject', taskId, actor)
+    } catch { /* 指标是旁路，绝不影响主流程 */ }
     return commit(taskId, 'accept', actor, at, before, next)
   }