dsh-agent-board 1.0.0

package/lib/core.mjs

@@ -0,0 +1,140 @@
+// dsh-agent-board — 纯逻辑核心（lib/core.mjs）
+// 不依赖任何 ctx/服务/IO：任务状态机、依赖校验、管线分类、prompt 构建、输出解析。
+// index.mjs（IO 编排层）从这里 import；单元测试直接跑本文件（node --test）。
+
+// ===== 常量 =====
+export const MAX_CLAIMED = 3
+export const CLAIMABLE = ['pending', 'blocked']
+export const PRIO_RANK = { critical: 4, high: 3, medium: 2, low: 1 }
+
+// ===== 任务数据工具 =====
+export function ah(t, f, to, ac, n) { if (!Array.isArray(t.history)) t.history = []; t.history.push({ from: f, to: to, timestamp: new Date().toISOString(), actor: ac, note: n || '' }) }
+export function isb(t) { return t.parentId != null }
+export function gsb(p, a) { return a.filter(function (x) { return x.parentId === p }) }
+export function gpt(t, a) { return isb(t) ? a.find(function (x) { return x.id === t.parentId }) : undefined }
+export function vt(d) { return d && typeof d === 'object' && Array.isArray(d.tasks) }
+
+// ===== 依赖校验（#18）=====
+// 存在性 + 自引用 + DFS 环检测；返回错误消息或 null
+export function validateDeps(d, taskId, deps) {
+  if (!Array.isArray(deps)) return 'dependsOn must be array'
+  for (var i = 0; i < deps.length; i++) {
+    var dep = deps[i]
+    if (dep === taskId) return 'self-dependency: ' + dep
+    if (!d.tasks.find(function (x) { return x.id === dep })) return 'dependency not found: ' + dep
+  }
+  var visited = {}
+  function reaches(cur) {
+    if (cur === taskId) return true
+    if (visited[cur]) return false
+    visited[cur] = true
+    var ct = d.tasks.find(function (x) { return x.id === cur })
+    var cd = (ct && Array.isArray(ct.dependsOn)) ? ct.dependsOn : []
+    for (var k = 0; k < cd.length; k++) { if (reaches(cd[k])) return true }
+    return false
+  }
+  for (var j = 0; j < deps.length; j++) { if (reaches(deps[j])) return 'circular dependency via: ' + deps[j] }
+  return null
+}
+// 依赖全部满足（resolved/archived 视为满足）
+export function depsSatisfied(d, t) {
+  if (!Array.isArray(t.dependsOn) || t.dependsOn.length === 0) return true
+  return t.dependsOn.every(function (id) { var x = d.tasks.find(function (y) { return y.id === id }); return x && (x.status === 'resolved' || x.status === 'archived') })
+}
+// 依赖被永久阻断（依赖已 cancelled）
+export function depsCancelled(d, t) {
+  if (!Array.isArray(t.dependsOn) || t.dependsOn.length === 0) return false
+  return t.dependsOn.some(function (id) { var x = d.tasks.find(function (y) { return y.id === id }); return x && x.status === 'cancelled' })
+}
+
+// ===== 管线分类（#19）：规则先行，兜底 full（宁严勿漏）=====
+export function classifyPipeline(t) {
+  if (t.acceptance && String(t.acceptance).trim()) return 'full'
+  var text = ((t.title || '') + ' ' + (t.description || '')).toLowerCase()
+  if (/解释|为什么|是什么|区别|对比|说明一下|是什么意思|how to|what is|why /.test(text)) return 'direct'
+  if (/文档|调研|整理|总结|报告|指南|白皮书|readme|分析文/.test(text)) return 'work'
+  return 'full'
+}
+
+// ===== 配置（一次性派发模型：max*=并发上限；min* 字段保留仅为兼容旧看板文件，引擎不使用）=====
+export function cfg(d) { return { minWorkers: Math.max(0, Math.min(10, d.minWorkers || 1)), maxWorkers: Math.max(1, Math.min(10, d.maxWorkers || 3)), minVerifiers: Math.max(0, Math.min(5, d.minVerifiers || 0)), maxVerifiers: Math.max(0, Math.min(5, d.maxVerifiers || 2)) } }
+
+// ===== 看板文件种子 =====
+export function seed(sid) { return { version: 12, ownerSession: sid, boardMode: 'auto', teamMode: false, minWorkers: 1, maxWorkers: 3, minVerifiers: 0, maxVerifiers: 2, workerModel: '', verifierModel: '', tasks: [] } }
+
+// ===== 状态流转 =====
+export function claimCheck(d, t, sid) { if (CLAIMABLE.indexOf(t.status) < 0) return 'cannot claim in ' + t.status; if (t.claimedBy && t.claimedBy !== sid && t.status === 'in-progress') return 'claimed by ' + t.claimedBy; if (d.boardMode === 'manual' || t.assignMode === 'manual') { if (t.assignee && t.assignee !== sid) return 'assigned to ' + t.assignee }; if (isb(t)) { var p = gpt(t, d.tasks); if (!p) return 'parent not found'; if (p.status !== 'in-progress' && p.status !== 'verifying') return 'parent not in-progress' }; var mc = d.tasks.filter(function (x) { return x.claimedBy === sid && (x.status === 'in-progress' || x.status === 'verifying') && !isb(x) }); if (!isb(t) && mc.length >= MAX_CLAIMED) return 'max ' + MAX_CLAIMED + ' active'; return null }
+export function claimApply(d, t, sid, note) { var ps = t.status; t.status = 'in-progress'; t.claimedBy = sid; t.claimedAt = new Date().toISOString(); ah(t, ps, 'in-progress', sid, note) }
+export function checkParentAuto(d, t) { if (!isb(t)) return null; var p = gpt(t, d.tasks); if (!p || p.status !== 'in-progress') return null; var s = gsb(p.id, d.tasks); if (s.every(function (x) { return x.status === 'resolved' })) { p.status = 'verifying'; p.resolvedAt = new Date().toISOString(); p.resolution = 'all subtasks resolved'; ah(p, 'in-progress', 'verifying', 'system', 'auto: all subtasks resolved'); return p }; return null }
+export function resolveApply(d, t, sid, status, resolution, note) { var ps = t.status; if (status === 'verifying' && t.pipeline && t.pipeline !== 'full') { status = 'resolved' } t.status = status; t.resolution = resolution || null; t.resolvedAt = new Date().toISOString(); ah(t, ps, status, sid, note); var r = { ok: true, task: t }; if (status === 'verifying' && isb(t)) { var s = gsb(t.parentId, d.tasks); if (s.every(function (x) { return x.status === 'resolved' || x.id === t.id })) { var p = gpt(t, d.tasks); if (p && p.status === 'in-progress') { p.status = 'verifying'; p.resolvedAt = new Date().toISOString(); p.resolution = 'all subtasks done'; ah(p, 'in-progress', 'verifying', 'system', 'auto'); r.parentUpdated = true } } }; return r }
+export function verifyApply(d, t, sid, verdict, comment) { var ps = t.status; if (verdict === 'approved') { t.status = 'resolved'; t.verifiedAt = new Date().toISOString(); t.verifiedBy = sid; ah(t, ps, 'resolved', sid, 'approved' + (comment ? ': ' + comment : '')) } else { t.status = 'in-progress'; t.resolvedAt = null; t.resolution = null; ah(t, ps, 'in-progress', sid, 'rejected' + (comment ? ': ' + comment : '')) }; var r = { ok: true, task: t }; if (verdict === 'approved' && isb(t)) { var p = checkParentAuto(d, t); if (p) { r.parentUpdated = true } }; return r }
+
+// ===== 输出解析（文本降级路径）=====
+// parseSections: 解析 ## 分段输出为结构化字段（容错：无分段时返回空对象，调用方降级）
+export function parseSections(text) {
+  var out = {}
+  if (!text) return out
+  var re = /^##\s+(.+?)\s*$/gm, m, matches = []
+  while ((m = re.exec(text))) matches.push({ title: m[1], idx: m.index, end: m.index + m[0].length })
+  for (var i = 0; i < matches.length; i++) {
+    var body = text.slice(matches[i].end, i + 1 < matches.length ? matches[i + 1].idx : text.length).trim()
+    var title = matches[i].title
+    if (/开发描述/.test(title)) out.summary = body
+    else if (/改动/.test(title)) out.changes = body
+    else if (/自测/.test(title)) out.selfTest = body
+    else if (/测试概要|验证概要|审查概要/.test(title)) out.verifySummary = body
+    else if (/核对项|核验项|检查项/.test(title)) out.checks = body
+  }
+  return out
+}
+// verifier 结论：行首锚定 APPROVED/REJECTED（输出中提到历史驳回字眼不应误判）；null = 无法判定
+export function parseVerdict(output) { var m = (output || '').trim().match(/^[ \t>*#\-\s]*(APPROVED|REJECTED)\b/im); return m ? m[1].toUpperCase() : null }
+// worker 歧义标记
+export function isEscalation(output) { return /\[ESCALATE\]/i.test(output || '') }
+// 从 run.result.output（ContentBlock[]）提取纯文本
+export function outputText(res) { if (!res || !res.output) return ''; var parts = []; for (var i = 0; i < res.output.length; i++) { var b = res.output[i]; if (b && b.type === 'text' && b.text) parts.push(b.text) } return parts.join('\n') }
+
+// ===== 一次性子代理 prompt 构建（上下文由主窗口 agent 写入 description/instructions，系统只追加生命周期记录）=====
+// 过程记录注入：驳回/裁决/干预 history + messages（裁决答案/干预指令/歧义原文）是系统管理的，必须带给子代理
+export function histNotes(t) { return (t.history || []).filter(function (h) { return h.note && (/歧义|裁决|驳回|干预|rejected/i.test(h.note)) }).map(function (h) { return '- [' + h.timestamp + '] ' + String(h.note).slice(0, 300) }).join('\n') }
+export function buildMessages(t) {
+  if (!Array.isArray(t.messages) || t.messages.length === 0) return ''
+  return t.messages.map(function (m) { return '### [' + (m.kind || 'note') + '] (' + (m.at || '') + ' by ' + (m.by || '') + ')\n' + String(m.text || '').slice(0, 2000) }).join('\n\n')
+}
+export function buildWorkerPrompt(t) {
+  var notes = histNotes(t)
+  var msgs = buildMessages(t)
+  var p = '你是一个一次性任务执行 Worker。完成下面这个任务，完成后本会话即销毁。\n\ntaskId: ' + t.id + '\n任务: ' + t.title + '\n描述: ' + (t.description || '')
+  if (t.context && t.context.instructions) p += '\n指引: ' + t.context.instructions
+  if (t.acceptance) p += '\n硬性验收脚本: ' + t.acceptance + '\n（必须实际运行该命令并在自测情况中粘贴真实输出；未通过不得上报完成）'
+  if (notes) p += '\n\n该任务的过程记录（歧义上报/主窗口裁决/驳回/干预，请务必遵循最新裁决方向）：\n' + notes
+  if (msgs) p += '\n\n该任务的详细消息（裁决答案/干预指令/歧义原文等，请务必遵循）：\n' + msgs
+  p += '\n\n完成契约（双模，工具优先）：\n1. 完成时：优先调用 board_report 工具（kind=complete, taskId=' + t.id + '，summary=开发描述/changes=改动清单/selfTest=自测情况）；工具不可用则按分段格式输出（## 开发描述 / ## 改动清单 / ## 自测情况）。\n2. 歧义/信息不足/需用户决策时：优先调用 board_report（kind=escalate, taskId=' + t.id + ', question=疑问）；工具不可用则输出以 [ESCALATE] 开头的说明。不要猜测。上报歧义后直接结束本轮——裁决后会有新 Worker 带着裁决答案接手。'
+  return p
+}
+export function buildVerifierPrompt(t) {
+  var notes = histNotes(t)
+  var msgs = buildMessages(t)
+  var p = '你是一个一次性任务审核 Verifier。审查下面这个任务的完成质量，给出结论后本会话即销毁。\n\ntaskId: ' + t.id + '\n任务: ' + t.title + '\n描述: ' + (t.description || '').slice(0, 500)
+  p += '\n完成说明: ' + (t.resolution || '(无)')
+  p += '\n交付物: ' + (t.deliverable ? ('开发描述: ' + (t.deliverable.summary || '') + '\n改动清单: ' + (t.deliverable.changes || '') + '\n自测情况: ' + (t.deliverable.selfTest || '')) : '(无)').slice(0, 1500)
+  if (t.context && t.context.instructions) p += '\n指引: ' + t.context.instructions
+  if (t.acceptance) p += '\n硬性验收脚本: ' + t.acceptance + '\n（必须独立复跑该命令并把真实输出贴进核对项；脚本失败必须 REJECTED）'
+  if (notes) p += '\n\n该任务的过程记录（歧义上报/主窗口裁决/驳回/干预，若有）：\n' + notes + '\n注意：若过程记录显示主窗口已裁决改变任务方向，以裁决后的方向为验收标准。'
+  if (msgs) p += '\n\n该任务的详细消息（裁决答案/干预指令/歧义原文等）：\n' + msgs
+  p += '\n\n结论契约（双模，工具优先）：\n1. 优先调用 board_verdict 工具（taskId=' + t.id + ', verdict=approved/rejected, summary=测试概要, checks=逐条核对证据含行号）。\n2. 工具不可用则首行 APPROVED: <结论> 或 REJECTED: <结论>，然后 ## 测试概要 / ## 核对项 分段。'
+  return p
+}
+
+// ===== 派发决策（纯函数版，poolCycle 持锁段调用）=====
+// 返回 { pendings, verifs }：按优先级排序的可派发任务清单
+export function pickDispatch(d, capW, capV, busyTaskIds) {
+  var pendings = capW > 0 ? d.tasks.filter(function (t) { return t.status === 'pending' && !t.claimedBy && t.assignMode !== 'manual' && t.pipeline !== 'direct' && depsSatisfied(d, t) && !t.escalation })
+    .sort(function (a, b) { var p = (PRIO_RANK[b.priority] || 2) - (PRIO_RANK[a.priority] || 2); return p !== 0 ? p : (a.createdAt || '').localeCompare(b.createdAt || '') }).slice(0, capW) : []
+  var verifs = capV > 0 ? d.tasks.filter(function (t) { return t.status === 'verifying' && (!t.pipeline || t.pipeline === 'full') && !t.escalation && !(busyTaskIds && busyTaskIds[t.id]) }).slice(0, capV) : []
+  return { pendings: pendings, verifs: verifs }
+}
+// 孤儿回收判定：in-progress 且 claimedBy 非主会话、无活跃 run、无 escalation、超 2 分钟
+export function isOrphan(d, t, runs, now) {
+  return t.status === 'in-progress' && t.claimedBy && t.claimedBy !== d.ownerSession && !(runs && runs[t.id]) && !t.escalation && (now - new Date(t.claimedAt || 0).getTime()) > 120000
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "dsh-agent-board",
+  "description": "DeepSeek Harness 智能看板：任务卡片 + 一次性 Worker/Verifier 派发 + 依赖调度 + 管线分档 + Team 模式（歧义上报主窗口裁决）",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "./index.mjs",
+  "scripts": {
+    "test": "node --test test/core.test.mjs",
+    "prepublishOnly": "node --check index.mjs && node --check lib/client.js && node --check lib/core.mjs && npm test"
+  },
+  "exports": {
+    ".": "./index.mjs",
+    "./client": "./lib/client.js",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-runtime"
+      ],
+      "platform": "web"
+    }
+  },
+  "files": [
+    "index.mjs",
+    "lib/core.mjs",
+    "lib/client.js",
+    "cordis.patch.yml",
+    "README.md",
+    "test/"
+  ],
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "deepseek-harness",
+    "task-board",
+    "kanban",
+    "agent",
+    "subagent",
+    "task-dispatch"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/PPawnsir/task-board-plugin.git",
+    "directory": "packages/dsh-agent-board"
+  },
+  "homepage": "https://github.com/PPawnsir/task-board-plugin#readme",
+  "bugs": "https://github.com/PPawnsir/task-board-plugin/issues",
+  "engines": {
+    "node": ">=22"
+  },
+  "license": "MIT"
+}

package/test/core.test.mjs

@@ -0,0 +1,252 @@
+// dsh-agent-board 纯逻辑单元测试 — node --test packages/dsh-agent-board/test/
+// 覆盖：状态机流转 / 依赖校验与环检测 / 管线分类 / 输出解析 / prompt 构建 / 派发决策 / 孤儿回收
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import * as core from '../lib/core.mjs'
+
+function mkTask(over) { return Object.assign({ id: 't1', title: 'T', description: '', status: 'pending', priority: 'medium', tags: [], parentId: null, assignMode: 'auto', assignee: null, context: { instructions: '' }, acceptance: '', dependsOn: [], pipeline: 'full', claimedBy: null, claimedAt: null, createdAt: '2026-01-01T00:00:00Z', resolvedAt: null, history: [], messages: [] }, over || {}) }
+function mkBoard(tasks) { return { version: 11, ownerSession: 's1', boardMode: 'auto', tasks: tasks || [] } }
+
+// ===== 状态机 =====
+test('claimApply: pending → in-progress，记 history', () => {
+  const t = mkTask(); const d = mkBoard([t])
+  core.claimApply(d, t, 'actor1', 'test')
+  assert.equal(t.status, 'in-progress'); assert.equal(t.claimedBy, 'actor1')
+  assert.equal(t.history.length, 1); assert.equal(t.history[0].to, 'in-progress')
+})
+
+test('claimCheck: 非可认领状态拒绝', () => {
+  const t = mkTask({ status: 'verifying' }); const d = mkBoard([t])
+  assert.match(core.claimCheck(d, t, 'a'), /cannot claim/)
+})
+
+test('claimCheck: 已被他人认领拒绝（in-progress 首先被 CLAIMABLE 拦住）', () => {
+  const t = mkTask({ status: 'in-progress', claimedBy: 'other' }); const d = mkBoard([t])
+  assert.match(core.claimCheck(d, t, 'a'), /cannot claim/) // CLAIMABLE 只含 pending/blocked，in-progress 先被拦
+  // claimedBy 分支的实际生效场景：blocked 状态被他人认领后重派
+  const t2 = mkTask({ status: 'blocked', claimedBy: 'other' }); const d2 = mkBoard([t2])
+  assert.equal(core.claimCheck(d2, t2, 'a'), null) // blocked 可重派（claimedBy 分支只在 in-progress 才有意义）
+})
+
+test('claimCheck: 手动模式+指定 assignee 拒绝他人', () => {
+  const t = mkTask({ assignMode: 'manual', assignee: 'bob' }); const d = mkBoard([t])
+  assert.match(core.claimCheck(d, t, 'alice'), /assigned to bob/)
+  assert.equal(core.claimCheck(d, t, 'bob'), null)
+})
+
+test('claimCheck: 超过 MAX_CLAIMED 拒绝', () => {
+  const mine = [1, 2, 3].map(i => mkTask({ id: 'm' + i, status: 'in-progress', claimedBy: 'me' }))
+  const t = mkTask({ id: 'new' }); const d = mkBoard(mine.concat([t]))
+  assert.match(core.claimCheck(d, t, 'me'), /max 3 active/)
+})
+
+test('resolveApply: full 档 → verifying；work/direct 档 → 直接 resolved', () => {
+  const tf = mkTask({ pipeline: 'full' }); core.resolveApply(mkBoard([tf]), tf, 'w', 'verifying', 'done')
+  assert.equal(tf.status, 'verifying')
+  const tw = mkTask({ pipeline: 'work' }); core.resolveApply(mkBoard([tw]), tw, 'w', 'verifying', 'done')
+  assert.equal(tw.status, 'resolved')
+})
+
+test('verifyApply: approved → resolved；rejected → 回 in-progress', () => {
+  const t = mkTask({ status: 'verifying' }); core.verifyApply(mkBoard([t]), t, 'v', 'approved', 'ok')
+  assert.equal(t.status, 'resolved'); assert.ok(t.verifiedAt)
+  const t2 = mkTask({ status: 'verifying' }); core.verifyApply(mkBoard([t2]), t2, 'v', 'rejected', 'bad')
+  assert.equal(t2.status, 'in-progress'); assert.equal(t2.resolution, null)
+})
+
+test('子任务全 resolved → 父任务自动 verifying', () => {
+  const p = mkTask({ id: 'p', status: 'in-progress' })
+  const c1 = mkTask({ id: 'c1', parentId: 'p', status: 'verifying' })
+  const c2 = mkTask({ id: 'c2', parentId: 'p', status: 'resolved' })
+  const d = mkBoard([p, c1, c2])
+  const r = core.verifyApply(d, c1, 'v', 'approved')
+  assert.equal(r.parentUpdated, true); assert.equal(p.status, 'verifying')
+})
+
+// ===== 依赖 =====
+test('validateDeps: 自引用/不存在/成环 全拒绝', () => {
+  const a = mkTask({ id: 'a' }); const b = mkTask({ id: 'b', dependsOn: ['a'] })
+  const d = mkBoard([a, b])
+  assert.match(core.validateDeps(d, 'a', ['a']), /self-dependency/)
+  assert.match(core.validateDeps(d, 'a', ['ghost']), /not found/)
+  // a 依赖 b，b 已依赖 a → 成环
+  const d2 = mkBoard([mkTask({ id: 'a', dependsOn: ['b'] }), mkTask({ id: 'b', dependsOn: ['a'] })])
+  assert.match(core.validateDeps(d2, 'a', ['b']), /circular/)
+})
+
+test('depsSatisfied: resolved/archived 算满足，其余不算', () => {
+  const dep = mkTask({ id: 'dep', status: 'resolved' })
+  const t = mkTask({ dependsOn: ['dep'] }); const d = mkBoard([dep, t])
+  assert.equal(core.depsSatisfied(d, t), true)
+  dep.status = 'in-progress'
+  assert.equal(core.depsSatisfied(d, t), false)
+  dep.status = 'archived'
+  assert.equal(core.depsSatisfied(d, t), true)
+})
+
+test('depsCancelled: 依赖被取消 → true', () => {
+  const dep = mkTask({ id: 'dep', status: 'cancelled' })
+  const t = mkTask({ dependsOn: ['dep'] })
+  assert.equal(core.depsCancelled(mkBoard([dep, t]), t), true)
+})
+
+// ===== 管线分类 =====
+test('classifyPipeline: 验收脚本→full；问答→direct；文档→work；兜底 full', () => {
+  assert.equal(core.classifyPipeline(mkTask({ acceptance: 'npm test' })), 'full')
+  assert.equal(core.classifyPipeline(mkTask({ title: '解释一下这个函数' })), 'direct')
+  assert.equal(core.classifyPipeline(mkTask({ title: '整理 API 文档' })), 'work')
+  assert.equal(core.classifyPipeline(mkTask({ title: '实现登录功能' })), 'full')
+})
+
+// ===== 输出解析 =====
+test('parseSections: 分段解析', () => {
+  const out = core.parseSections('前言\n## 开发描述\n做了 A\n## 改动清单\n改了 x.js\n## 自测情况\nnpm test pass')
+  assert.equal(out.summary, '做了 A'); assert.equal(out.changes, '改了 x.js'); assert.equal(out.selfTest, 'npm test pass')
+  assert.deepEqual(core.parseSections(''), {})
+  assert.deepEqual(core.parseSections('没有分段的纯文本'), {})
+})
+
+test('parseVerdict: 行首锚定，历史提及不误判', () => {
+  assert.equal(core.parseVerdict('APPROVED: 通过'), 'APPROVED')
+  assert.equal(core.parseVerdict('REJECTED: 不达标'), 'REJECTED')
+  assert.equal(core.parseVerdict('> APPROVED\n引用块里的也算'), 'APPROVED') // 引用块前缀允许
+  assert.equal(core.parseVerdict('上次被 REJECTED 了，这次我觉得行'), null) // 非行首锚定 → 不误判
+  assert.equal(core.parseVerdict(''), null)
+})
+
+test('isEscalation: [ESCALATE] 标记', () => {
+  assert.equal(core.isEscalation('[ESCALATE] 缺少需求'), true)
+  assert.equal(core.isEscalation('正常完成'), false)
+})
+
+test('outputText: ContentBlock[] 提取文本', () => {
+  assert.equal(core.outputText({ output: [{ type: 'text', text: 'a' }, { type: 'image' }, { type: 'text', text: 'b' }] }), 'a\nb')
+  assert.equal(core.outputText(null), '')
+  assert.equal(core.outputText({}), '')
+})
+
+// ===== prompt 构建 =====
+test('buildWorkerPrompt: 注入 taskId/描述/验收脚本/过程记录', () => {
+  const t = mkTask({ id: 'tx', description: '做个功能', acceptance: 'npm test', history: [{ note: '驳回: 缺测试', timestamp: '2026-01-01' }] })
+  const p = core.buildWorkerPrompt(t)
+  assert.match(p, /taskId: tx/); assert.match(p, /做个功能/); assert.match(p, /npm test/); assert.match(p, /驳回: 缺测试/); assert.match(p, /board_report/)
+})
+
+test('buildWorkerPrompt: 不自动注入 context.files/docs（由主窗口写入 description）', () => {
+  const t = mkTask({ id: 'ctx', context: { instructions: '看 README', files: ['src/x.js'], docs: ['设计文档'], relatedTasks: ['task-a'], prerequisites: 'Node 22+' } })
+  const p = core.buildWorkerPrompt(t)
+  assert.match(p, /看 README/)          // instructions 注入（主窗口写的指引）
+  assert.doesNotMatch(p, /src\/x\.js/)  // files 不自动注入
+  assert.doesNotMatch(p, /设计文档/)    // docs 不自动注入
+  assert.doesNotMatch(p, /task-a/)      // relatedTasks 不自动注入
+  assert.doesNotMatch(p, /Node 22/)     // prerequisites 不自动注入
+})
+
+test('buildWorkerPrompt: 注入 messages（裁决答案/干预指令/歧义原文——系统管理的生命周期记录）', () => {
+  const t = mkTask({ id: 'msg', messages: [{ kind: 'arbitration', text: '用方案B', at: '2026-01-01', by: 'main' }, { kind: 'intervention', text: '注意边界', at: '2026-01-02', by: 'main' }] })
+  const p = core.buildWorkerPrompt(t)
+  assert.match(p, /用方案B/); assert.match(p, /注意边界/); assert.match(p, /arbitration/); assert.match(p, /intervention/)
+})
+
+test('buildVerifierPrompt: 注入交付物 + 验收脚本 + messages', () => {
+  const t = mkTask({ id: 'tx', acceptance: 'npm test', deliverable: { summary: '做完了', changes: 'x.js', selfTest: 'pass' }, messages: [{ kind: 'arbitration', text: '方案B', at: '2026-01-01', by: 'main' }] })
+  const p = core.buildVerifierPrompt(t)
+  assert.match(p, /做完了/); assert.match(p, /npm test/); assert.match(p, /board_verdict/); assert.match(p, /方案B/)
+})
+
+// ===== 派发决策 =====
+test('pickDispatch: 优先级排序 + 并发上限 + 排除项', () => {
+  const tasks = [
+    mkTask({ id: 'lo', priority: 'low', createdAt: '2026-01-02' }),
+    mkTask({ id: 'hi', priority: 'critical', createdAt: '2026-01-03' }),
+    mkTask({ id: 'claimed', claimedBy: 'someone' }),
+    mkTask({ id: 'manual', assignMode: 'manual' }),
+    mkTask({ id: 'direct', pipeline: 'direct' }),
+    mkTask({ id: 'esc', escalation: { question: 'q' } }),
+  ]
+  const d = mkBoard(tasks)
+  const r = core.pickDispatch(d, 3, 0, null)
+  assert.deepEqual(r.pendings.map(t => t.id), ['hi', 'lo']) // critical 优先，claimed/manual/direct/escalation 全排除
+  assert.equal(r.verifs.length, 0) // capV=0
+  const r2 = core.pickDispatch(d, 1, 0, null)
+  assert.equal(r2.pendings.length, 1) // cap 生效
+})
+
+test('pickDispatch: 依赖未满足不派发', () => {
+  const dep = mkTask({ id: 'dep', status: 'in-progress' })
+  const t = mkTask({ id: 'w8', dependsOn: ['dep'] })
+  const r = core.pickDispatch(mkBoard([dep, t]), 5, 0, null)
+  assert.equal(r.pendings.length, 0)
+  dep.status = 'resolved'
+  const r2 = core.pickDispatch(mkBoard([dep, t]), 5, 0, null)
+  assert.equal(r2.pendings.length, 1)
+})
+
+test('pickDispatch: verifying 只派 full 档，排除 escalation 和忙中', () => {
+  const tasks = [
+    mkTask({ id: 'vf', status: 'verifying', pipeline: 'full' }),
+    mkTask({ id: 'vw', status: 'verifying', pipeline: 'work' }),
+    mkTask({ id: 've', status: 'verifying', pipeline: 'full', escalation: { question: 'q' } }),
+    mkTask({ id: 'vb', status: 'verifying', pipeline: 'full' }),
+  ]
+  const r = core.pickDispatch(mkBoard(tasks), 0, 5, { vb: true })
+  assert.deepEqual(r.verifs.map(t => t.id), ['vf']) // work 档不派审、escalation 不派、忙中不派
+})
+
+// ===== 孤儿回收 =====
+test('isOrphan: 认领者非主会话 + 无活跃 run + 超 2 分钟', () => {
+  const old = new Date(Date.now() - 200000).toISOString()
+  const t = mkTask({ status: 'in-progress', claimedBy: 'run-123', claimedAt: old })
+  const d = mkBoard([t])
+  assert.equal(core.isOrphan(d, t, {}, Date.now()), true)
+  assert.equal(core.isOrphan(d, t, { t1: {} }, Date.now()), false) // 有活跃 run
+  t.claimedBy = 's1' // 主会话自己认领的
+  assert.equal(core.isOrphan(d, t, {}, Date.now()), false)
+  t.claimedBy = 'run-123'; t.escalation = { question: 'q' }
+  assert.equal(core.isOrphan(d, t, {}, Date.now()), false) // 待裁决的不回收
+  delete t.escalation; t.claimedAt = new Date().toISOString()
+  assert.equal(core.isOrphan(d, t, {}, Date.now()), false) // 刚认领不超 2 分钟
+})
+
+// ===== 种子与配置 =====
+test('seed: 初始看板结构', () => {
+  const d = core.seed('s1')
+  assert.equal(d.ownerSession, 's1'); assert.equal(d.boardMode, 'auto'); assert.deepEqual(d.tasks, [])
+  assert.ok(core.vt(d))
+})
+
+test('cfg: 边界夹紧', () => {
+  const c = core.cfg({ minWorkers: -1, maxWorkers: 99, minVerifiers: 99, maxVerifiers: -1 })
+  assert.equal(c.minWorkers, 0); assert.equal(c.maxWorkers, 10); assert.equal(c.minVerifiers, 5); assert.equal(c.maxVerifiers, 0)
+})
+
+// ===== 回归：PRIO_RANK 使用一致性 =====
+test('PRIO_RANK: 与 pickDispatch 排序一致', () => {
+  // PRIO_RANK 必须有 4 档，且值与 pickDispatch 的 sort 逻辑一致
+  assert.equal(core.PRIO_RANK.critical, 4); assert.equal(core.PRIO_RANK.high, 3)
+  assert.equal(core.PRIO_RANK.medium, 2); assert.equal(core.PRIO_RANK.low, 1)
+  // pickDispatch 优先级排序验证（已在前面测过，这里确认 PRIO_RANK 可用）
+  const d = mkBoard([mkTask({ id: 'lo', priority: 'low' }), mkTask({ id: 'hi', priority: 'critical' })])
+  const r = core.pickDispatch(d, 5, 0, null)
+  assert.equal(r.pendings[0].id, 'hi') // critical 排前面
+})
+
+// ===== 回归：outputText 对各种 SubagentResult 形态 =====
+test('outputText: 各种 ContentBlock 形态', () => {
+  assert.equal(core.outputText({ output: [{ type: 'text', text: 'hello' }] }), 'hello')
+  assert.equal(core.outputText({ output: [] }), '')
+  assert.equal(core.outputText({ output: [{ type: 'tool_use' }] }), '') // 无 text block
+  assert.equal(core.outputText({ stopReason: 'completed' }), '') // 无 output 字段
+  assert.equal(core.outputText(undefined), '')
+  assert.equal(core.outputText(null), '')
+})
+
+// ===== 回归：isOrphan 边界 =====
+test('isOrphan: cancelled 状态不回收（不在 in-progress）', () => {
+  const t = mkTask({ status: 'cancelled', claimedBy: 'run-x', claimedAt: new Date(Date.now() - 999999).toISOString() })
+  assert.equal(core.isOrphan(mkBoard([t]), t, {}, Date.now()), false)
+})
+test('isOrphan: 刚 claim 的（<2min）不回收', () => {
+  const t = mkTask({ status: 'in-progress', claimedBy: 'run-x', claimedAt: new Date().toISOString() })
+  assert.equal(core.isOrphan(mkBoard([t]), t, {}, Date.now()), false)
+})