dsh-card-dispatch 0.1.0 → 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,41 @@
+# 更新日志
+
+发布在 npm：<https://www.npmjs.com/package/dsh-card-dispatch>（0.1.0 之前还发布过旧名
+[`dsh-unattended-dev`](https://www.npmjs.com/package/dsh-unattended-dev)）。日期用 npm 记录的 UTC 时间。
+
+## 0.1.1 — 2026-10-25
+
+### 修复
+
+- **预算 / 并发闸真的会拦了**：运行态由页面从看板 `/state` 汇总后随 `/split` 传入；拿不到快照时回
+  `E_STATE_UNKNOWN` 拒绝开跑，不再用 `0` 冒充「今天还没跑过、也没人在跑」——以前闸门永远放行就是因为它。
+- **打回上限（R3）刷新不再归零**：打回次数按 `rootId` 落到 `<dataDir>/rework.json`；写盘失败返回 500
+  且**不给**重跑信封（失败关闭，不能假装限流生效）。
+- **父卡 prompt 不再自相矛盾**：父卡自己干活时不再说「父卡不产出报告」；没有验收卡时不再提「让它执行」。
+- **`/split` 不再接受请求体里的 `permission` / `agentPreset`**：权限只认配置；`permission: null` 表示
+  「不指定，沿用看板默认」。
+
+### 变更
+
+- **验收卡随父卡自动运行**：交付门槛开着就生成，它是父卡的子卡，运行父卡会一起带起来。父卡始终以 Lead
+  会话运行，验收卡是同一会话里的 teammate（智能体团队没勾也只算 1 条会话）。删除 `pending[]` 与页面上的
+  「运行验收卡」；返工后由页面单独重排验收卡。
+- **拆卡幂等**：卡 id 与 `requestId` 由输入 hash 决定，同一份输入 10 分钟内重试不会多建一棵树；换了提示词
+  或超过窗口才是一批新卡。
+- 判据条数、单条长度、重复编号在服务端收敛。
+- HTTP 栅栏：回环地址 + `sec-fetch-site` + `Origin`/`Host` 一致 + `content-type: application/json` + `nosniff`。
+- README / HANDOFF 校正到当前实现；新增本更新日志。
+
+### 测试
+
+- 196/196（`node test\run-all.mjs`，17 个文件）；新增 `http.test.js`（同源 / JSON / nosniff 栅栏）与
+  `model-call.test.js`（调用超时与重试边界）。
+
+## 0.1.0 — 2026-10-24
+
+首次公开发布（`dsh-card-dispatch`，旧名 `dsh-unattended-dev@0.1.0` 同日发布）：需求解析 / 按判据拆分 /
+看板 action 信封 + 人工通道。
+
+## 0.0.0-stage — 2026-10-24
+
+占位预发布，用于验证 npm 发布链路。

package/README.md

@@ -8,6 +8,8 @@ DSH Host 插件：**把需求拆成任务看板卡片**。就这一件事。
 npm i dsh-card-dispatch     # 装进 DSH profile 的 node_modules
 ```
 
+更新日志：[CHANGELOG.md](CHANGELOG.md)；当前发布版本见上面的 npm 徽章。
+
 - 拆分：`src/split.js`（纯函数，判据自动补 `C-01`，按判据拆父卡 + 并行子卡，prompt 自包含）
 - 填写：控制台页面直接调看板的 `POST /api/task-board/action`
 - 执行：**不归本插件**。开会话、钉工作区、预设/权限、跑、结算，全部是看板的事
@@ -84,7 +86,7 @@ npm i "dsh-card-dispatch@link:<仓库路径>/plugins/card-dispatch"
 5. 点「写入看板」（右下）建卡；勾了「写入后立即运行」才会真的开会话（**这一步才计费**）。
 6. 验收驳回后回来点「按结论处理」：读 `out/<根卡 id>/verdict.json`，按打回上限给出 pass / rework / escalate。
 
-## 3. 路由（十一条）
+## 3. 路由（十二条）
 
 都以 `/api/card-dispatch` 为前缀，`kind: prefix`，页面每次请求从磁盘读（改 HTML 不用重启，改路由要）。
 
@@ -93,12 +95,12 @@ npm i "dsh-card-dispatch@link:<仓库路径>/plugins/card-dispatch"
 | `GET /` | 控制台页面（`src/console.html`） |
 | `GET /view` | 页面要的状态快照：能力清单、看板基址、当前配置 |
 | `GET /models` | 宿主设置里已添加的模型（只读扫描 `cordis.patch.yml`），给下拉用 |
-| `POST /split` | 需求 → 卡片计划（`cards[]` + `envelopes[]` + `warnings[]`），**不写任何东西** |
+| `POST /split` | 需求 → 卡片计划（`cards[]` + `envelopes[]` + `warnings[]`），**不写任何东西**；同一份输入 10 分钟内幂等 |
 | `POST /plan` | 解析 + 算拆几张卡 + 给每张卡写提示词（两次模型调用）；回 `intros` 给页面，写卡时原样带回 `/split` |
 | `POST /parse` | 整段需求 → 标题 / 描述 / 判据（只整理字段，不拆分） |
 | `POST /criteria` | 判据草稿：模型优先，失败退回规则提炼 |
 | `POST /import` | 文档正文 → 标题 / 描述 / 判据（正文由浏览器读成文本发来，插件不碰磁盘路径） |
-| `POST /rework` | 读 `verdict.json`，按 `gates.maxReworkRounds` 给 pass / rework / escalate |
+| `POST /rework` | 读 `verdict.json`，按 `gates.maxReworkRounds` 给 pass / rework / escalate；打回次数由服务端落盘 |
 | `GET /config` | 声明表 + 当前值（页面据此回填控件） |
 | `POST /config` | 归一化后落盘成完整配置；不认识的键回 `rejected`，不会被悄悄丢掉 |
 | `GET /status` | 配置、开关、体检结论 |
@@ -106,6 +108,14 @@ npm i "dsh-card-dispatch@link:<仓库路径>/plugins/card-dispatch"
 `POST` 一律要求人标记：请求头 `x-card-dispatch-human: true` 或 body 里 `human: true`。
 没有这个标记就是 400——**这条路只能人走**，模型和脚本不该替人按「开跑」。
 
+除人标记外还有三道同源栅栏（人标记不是鉴权，别的页面照样能带）：
+来源必须是回环地址；`sec-fetch-site` 不能是 `cross-site` / `same-site`；带了 `Origin` 就必须与 `Host` 一致；
+`POST` 必须声明 `content-type: application/json`（`text/plain` 的简单请求不触发预检，正是跨站伪造最常用的形状）。
+命令行调用要同时带标记与 JSON 头。
+
+`/split` 的幂等窗口是 10 分钟：同一份输入（标题、描述、判据、跑法、提示词）重复提交会被当成重试，
+卡 id 与 requestId 都不变，看板不会建出第二批；要故意新建一批，改一下标题/判据，或等窗口过去。
+
 ## 4. 配置
 
 配置只有一份真源：`src/config.js` 的声明表。面板、`/config` 路由、`cordis.patch.yml` 都按它收敛；
@@ -114,10 +124,10 @@ npm i "dsh-card-dispatch@link:<仓库路径>/plugins/card-dispatch"
 | 键 | 缺省 | 作用 | 插件能真拦吗 |
 |---|---|---|---|
 | `enabled` | `false` | 总开关；关掉只拆卡、不返回运行信封 | 能 |
-| `permission` | `workspace-write` | 卡片权限预设（写进每个 create 信封） | 能 |
+| `permission` | `workspace-write` | 卡片权限预设（写进每个 create 信封；`null` = 不指定，沿用看板默认；请求体不能覆盖它） | 能 |
 | `dataDir` | `.card-dispatch` | 插件的数据目录（配置、结论文件） | — |
 | `gates.requirePlanApproval` | `true` | 没批准的拆分不给运行信封 | 能（「批准」= 人点「写入并运行」） |
-| `gates.requireEvidence` | `true` | 没有 commit / 报告不算完成（团队开着时验收卡也在同一条会话里） | 能 |
+| `gates.requireEvidence` | `true` | 没有 commit / 报告不算完成；验收卡随父卡自动运行（团队开着时在同一条会话里） | 能 |
 | `gates.budgetPerDay` | `200` | 每日运行次数上限 | 能，需调用方给 `runsToday` |
 | `gates.maxParallelRuns` | `3` | 同时在跑的会话上限 | 能，需调用方给 `runningSessions` |
 | `gates.maxReworkRounds` | `2` | 打回上限，第 3 次升级给人（基线 R3） | 能 |
@@ -125,7 +135,7 @@ npm i "dsh-card-dispatch@link:<仓库路径>/plugins/card-dispatch"
 | `models.draftRoute` | 空 | 全局模型：解析并拆分、判据草稿、写卡提示词都用它（右栏下拉写的就是这一项），留空 = 宿主默认 | 是 |
 | `org.departments` | `dev/verify/integrate` | 部门名（写进卡片描述，供人读） | 只记录 |
 | `execution.driver` | `task-board` | 执行层驱动（只有看板一条路） | 枚举校验 |
-| `execution.teamRun` | `true` | 智能体团队：开了才按判据拆子卡（父卡带 `teamRun: true`，看板只起一个 Lead 会话，子卡由它派 teammate）；关掉不拆子卡、每张卡各一条会话 | 能（决定拆不拆 + 写进 create 信封） |
+| `execution.teamRun` | `true` | 智能体团队：开了才按判据拆子卡（父卡带 `teamRun: true`，看板只起一个 Lead 会话，子卡由它派 teammate）；关掉不拆子卡；交付门槛开着时父卡仍以 Lead 会话运行（只带验收卡） | 能（决定拆不拆 + 写进 create 信封） |
 | `audit.orgChart` | `true` | 拓扑稽查：事后核对有没有人绕开主管 | 只检查，不拦 |
 | `org.depthRequired` | `2` | 主管带人所需的委派深度 | **不能**，只体检提示 |
 
@@ -153,17 +163,20 @@ npm i "dsh-card-dispatch@link:<仓库路径>/plugins/card-dispatch"
 |---|---|---|
 | 判据 0 条 | 1 张父卡 + 警告「执行者不知道做到什么算完」 | 1 |
 | 判据 1 条 | 1 张父卡（不拆——拆多了全是计费） | 1 |
-| **没开智能体团队**（`execution.teamRun: false`） | 不拆子卡，判据全写进一张卡 | 每张卡各 1 条 |
+| **没开智能体团队、也没开交付门槛** | 不拆子卡，判据全写进一张卡 | 1 |
 | 判据 ≥2 条 + 开了团队 + 勾了并行 | 父卡 + 每判据组 1 张子卡（子卡由父卡的 Lead 在**同一个**会话里派成 teammate） | **1** |
 | 判据 ≥2 条但没勾并行 | 1 张父卡，全部判据写进去 | 1 |
-| 交付门槛开着（`gates.requireEvidence`） | 上面任一种 + **1 张验收卡** | 团队开：仍是 1；团队关：+1 |
+| 交付门槛开着（`gates.requireEvidence`） | 上面任一种 + **1 张验收卡** | **1**（父卡以 Lead 会话运行，验收卡是同一会话里的 teammate；团队没勾也不额外开会话） |
 
-**卡数 ≠ 会话数**。团队开着时 5 张卡（父卡 + 3 子卡 + 验收卡）都在同一个 Lead 会话里跑，
-只算 1 条会话；关掉团队时每张卡各开一条，所以「1 张开发卡 + 1 张验收卡」是 2 条。
-预览里的警告会把这次到底是 1 条还是 N 条直接写出来。
+**卡数 ≠ 会话数**。只要走 Lead 模式（开了团队，或团队没开但开了交付门槛），父卡 + 子卡 + 验收卡
+都在同一个 Lead 会话里跑，只算 1 条会话；只有团队和门槛都关、只有一张父卡时，才是单卡单会话。
+验收卡可能比开发卡先启动，它会在会话里等开发报告，再给出 PASS/REJECT。
+预览里的警告会把这次到底开几条会话直接写出来。
 
 拆不拆子卡只看**跑法**：团队开着才拆。页面跟着联动——团队没勾时
 「按判据拆成并行子卡」直接禁用；勾一下就存盘并重算预览，不用先点「保存」才发现会话条数变了。
+其余开关（总开关、计划闸、交付门槛、拓扑稽查、预算 / 并发 / 打回）也一样：改完立刻存盘；
+已经出过预览的会就地重算，不必再点一次「保存」。
 
 **子卡是并行的**：看板没有「卡片间依赖」字段。所以每张子卡的 prompt 自带它那组判据
 和「怎么算完」，不靠顺序；要严格串行就别勾并行。
@@ -172,9 +185,17 @@ npm i "dsh-card-dispatch@link:<仓库路径>/plugins/card-dispatch"
 不算验收。所以门槛开着时，插件会把交付要求写进每张开发卡（报告路径写死成
 `out/<该卡 id>/report.md`，附 commit sha），再生成一张只读证据的验收卡：
 结论只能是 PASS 或 REJECT，REJECT 必须带 `{criteriaId, expected, actual, evidencePath}`。
-顺序（先开发、后验收、打回最多两次）写在父卡 prompt 里——teamRun 模式下父卡就是 Lead，
-由它守；平台排不出这个顺序，因为看板没有依赖字段。
-验收卡和团队开关无关：门槛开着就有；代价只是没开团队时它多占一条会话，预览会写明。
+打回上限按 `gates.maxReworkRounds` 写进验收 prompt；走 Lead 模式时父卡就是 Lead，负责收尾。
+平台排不出「先开发、后验收」的顺序（看板没有依赖字段），所以顺序靠验收卡自己等报告：
+父卡自己就是干活的那张时，prompt 不会再写「父卡不产出报告」，也不会提一张并不存在的验收卡。
+验收卡和团队开关无关：门槛开着就有，并且**随父卡一起运行**——它是父卡的子卡，运行父卡会把子卡
+一起带起来，所以不再需要手动点「运行验收卡」。代价是它可能比开发卡先启动，因此验收 prompt 里
+写死了等待规则：开始先等 30 秒；报告缺失或比该卡最近一次执行开始时间还旧时，每 60 秒再看一次；
+开发卡已结束但仍缺本轮报告 → 立即 REJECT；最多等 120 分钟。开发卡的 prompt 同时要求开工前
+删掉上一轮的 `report.md`，所以复验不会把旧报告当新证据。返工只重跑单张开发卡、不会带起验收卡，
+页面会在重跑信封之后再单独排一次验收卡。
+走 Lead 模式时它只是 Lead 会话里的一个 teammate，不额外开一条会话——所以团队没勾、门槛开着时，
+父卡 + 验收卡也只算 1 条会话。
 
 ## 7. 已验证 / 未验证
 
@@ -196,10 +217,12 @@ npm i "dsh-card-dispatch@link:<仓库路径>/plugins/card-dispatch"
 **未验证**：`run` 的会话侧效果（真的开出一个会话并跑完）——那会真开会话计费，
 没有替你跑。第一次点运行时请留意看板是否解析出工作区与预设。
 `teamRun` 写进 create 信封后看板是否真的只起一个 Lead、把子卡派成 teammate，同样没跑过；
+交付门槛开着、团队没勾时「父卡当 Lead + 验收卡做 teammate」这条路径也没跑过；
 看板自己的 `teamRunAvailable` 与「Agent Teams 服务缺失就拒绝运行」两道检查仍在它那边。
 
 **交付门槛现在到哪一步**：证据要求已写进每张开发卡的 prompt，验收卡独立存在、只给
 PASS/REJECT 并把结论落到 `out/<根卡 id>/verdict.json`——「证据从哪来、谁来验、结论放哪」都解决了。
+验收卡现在随父卡自动启动，不再需要人点「运行验收卡」；「等报告」是 prompt 级约束，未真机跑过。
 
 「打回之后谁重跑」现在有一个**人触发**的答案：`POST /rework` 读那个文件，按
 `gates.maxReworkRounds` 给出三种结局——`pass` 收尾、`rework` 返回重跑被拒卡片的 run 信封、
@@ -209,20 +232,23 @@ PASS/REJECT 并把结论落到 `out/<根卡 id>/verdict.json`——「证据从
 插件进程没有那张 cookie，**实测 403**；而且 `ExecutionRecord.result` 只记「执行成没成」，
 不记「验收判 PASS 还是 REJECT」。落盘的文件三方都能读，也才符合基线 P3。
 
-**还没做**：预算真正计数（需要调用方给 `runsToday` / `runningSessions`）、worktree 隔离、
-逐手台账、`skills/card-dispatch-org/SKILL.md` 的安装。
+**还没做**：worktree 隔离、模型调用缓存、`skills/card-dispatch-org/SKILL.md` 的安装。
+模型调用已加一次重试（只重试非超时失败）。预算与并发闸已经接上真实运行态：页面从看板 `/state` 的 executions 算「今天跑了几次、几个会话在跑」，
+随 `/split` 传给服务端；拿不到快照就回 `E_STATE_UNKNOWN` 拒绝放行，不再拿 0 冒充。
+注意：看板每张卡只保留最近 20 条 executions，单卡一天跑超过 20 次时预算数会少算。
 
 ## 8. 测试
 
 ```powershell
-node test\run-all.mjs        # 155 个用例，全绿
+node test\run-all.mjs        # 196 个用例，全绿
 ```
 
-十五个文件：`config`（收敛/兼容/合并）、`gates`（三个闸的判定顺序与理由）、
-`selfcheck`（体检判据）、`split`（拆分、信封、智能体团队、提示词覆盖）、`status`（所有路由）、
+十七个测试文件：`config`（收敛/兼容/合并）、`gates`（四个闸的判定顺序与理由）、
+`selfcheck`（体检判据）、`split`（拆分、信封、智能体团队、提示词覆盖、幂等）、`status`（所有路由 + 打回次数落盘）、
 `verdict`（结论文件契约）、`import`（文档解析）、`criteria`（规则提炼）、`models`（模型清单扫描）、
-`criteria-llm`（判据草稿的模型通道）、`parse-llm`（整段需求解析）、`prompts-llm`（按需求写每张卡的提示词）、
-`human-channel`（路由 + 两道门 + 依赖透传 + 闸门降级）、`console`（页面 id / 看板基址 / 旧机制痕迹清零）、
+`model-call`（调用超时 / 重试边界）、`criteria-llm`（判据草稿的模型通道）、`parse-llm`（整段需求解析）、
+`prompts-llm`（按需求写每张卡的提示词）、`human-channel`（路由 + 两道门 + 依赖透传 + 闸门降级）、
+`console`（页面 id / 看板基址 / 旧机制痕迹清零）、`http`（同源 / JSON / nosniff 栅栏）、
 `index`（导出形状 / 旧配置兼容 / apply 只挂路由 / 端到端打一次 /models）。
 
 模型相关的用例全部用假的 `llm` 服务：**不在测试里花真钱**。真模型的验证靠人点一次、
@@ -233,9 +259,10 @@ node test\run-all.mjs        # 155 个用例，全绿
 | 文件 | 行数 | 作用 |
 |---|---|---|
 | `index.js` | ~90 | cordis 入口：`apply` 只注册路由，注入 `models` 依赖 |
-| `src/human-channel.js` | ~800 | 十一条路由、两道门（人标记 + 配置闸）、依赖透传 |
-| `src/split.js` | ~390 | 需求 → 卡片计划（唯一有「业务判断」的地方，纯函数） |
-| `src/gates.js` | ~120 | 三个闸：计划、预算、并发、打回次数 |
+| `src/human-channel.js` | ~830 | 十二条路由、两道门（人标记 + 同源/JSON）、闸门与配置 |
+| `src/split.js` | ~470 | 需求 → 卡片计划（唯一有「业务判断」的地方，纯函数；同输入幂等） |
+| `src/gates.js` | ~110 | 四个闸：计划、运行态、预算、并发（+ 打回次数判定） |
+| `src/rework-store.js` | ~70 | 打回次数按 `rootId` 落盘（`<dataDir>/rework.json`） |
 | `src/config.js` | ~230 | 声明表 + 归一化 + 兼容旧键 |
 | `src/config-store.js` | ~90 | 配置读写（`<dataDir>/config.json` 优先） |
 | `src/selfcheck.js` | ~200 | 体检：看板在不在、模型清单、权限、委派深度 |
@@ -247,4 +274,4 @@ node test\run-all.mjs        # 155 个用例，全绿
 | `src/prompts-llm.js` | ~140 | 按需求给每张卡写提示词开头（结构不归它管） |
 | `src/import.js` | ~150 | `.md` / `.txt` / `.json` → 标题 / 描述 / 判据 |
 | `src/verdict.js` | ~120 | `verdict.json` 的读写与形状校验 |
-| `src/console.html` | ~950 | 控制台页面（单文件，无构建） |
+| `src/console.html` | ~1010 | 控制台页面（单文件，无构建） |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-card-dispatch",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "type": "module",
   "description": "派卡台开发的上游：把需求拆成任务看板卡片（执行交给 dsh-client-ui-task-board）",
   "keywords": [
@@ -37,7 +37,8 @@
     "cordis.patch.yml",
     "locale/*.json",
     "icon.svg",
-    "README.md"
+    "README.md",
+    "CHANGELOG.md"
   ],
   "scripts": {
     "test": "node test/run-all.mjs",

package/src/console.html

@@ -191,6 +191,7 @@
             <label class="sw"><input type="checkbox" id="cfg-enabled"> <span><b>总开关</b>　关掉只拆卡、不开会话</span></label>
             <label class="sw"><input type="checkbox" id="cfg-plan"> <span><b>计划闸</b>　没批准不许开跑</span></label>
             <label class="sw"><input type="checkbox" id="cfg-evidence"> <span><b>交付门槛</b>　没有证据不算完成</span></label>
+            <div class="hint" id="cfg-evidence-hint" style="padding-left:24px;margin:-4px 0 6px"></div>
             <label class="sw"><input type="checkbox" id="cfg-teamrun"> <span><b>智能体团队</b>　父卡起 Lead、子卡起 teammate（关掉则不拆子卡，每张卡各开一条会话）</span></label>
             <label class="sw"><input type="checkbox" id="cfg-audit"> <span><b>拓扑稽查</b>　事后核对有没有人绕开主管</span></label>
 
@@ -319,14 +320,14 @@ function boardPost(envelope) {
    故意不做成自动的：没有轮询、没有定时器，人点一次才判一次。 */
 
 var lastPlan = null;      /* 最近一次真正写进看板的拆分结果 */
-var rejectedCount = 0;    /* 这一批已经打回几次（服务端也记，这里只是喂给它） */
+var boardStats = null;    /* 看板运行态：{runsToday, runningSessions}；拿不到就是 null */
+var boardFacts = null;    /* 看板探测结果：{reachable, teamRun}；回传给 /status 体检 */
 var WORKSPACE_PATHS = {}; /* 工作区 id → 根目录，读 verdict.json 要用绝对路径 */
 var hostHasRework = false;/* 宿主有没有 /rework：旧宿主上这个按钮点了只会 404 */
 var hostHasPlan = true;/* 宿主有没有 /plan：没有就退回只整理字段 */
 
 function rememberPlan(plan) {
   lastPlan = plan;
-  rejectedCount = 0;
   el('btn-rework').disabled = !hostHasRework;
   el('rework-state').className = 'pill' + (hostHasRework ? '' : ' bad');
   el('rework-state').textContent = hostHasRework ? '等验收' : '宿主是旧代码';
@@ -385,26 +386,37 @@ function checkRework() {
   el('rework-state').className = 'pill';
   el('rework-state').textContent = '检查中…';
 
-  var base = { rootId: lastPlan.rootId, workspaceRoot: workspaceRoot, rejectedCount: rejectedCount };
+  var base = { rootId: lastPlan.rootId, workspaceRoot: workspaceRoot };
   request('rework', base)
     .then(function (first) {
       var decision = first.decision || {};
       if (decision.action !== 'rework') { showRework(first); return first; }
-      // 要返工：先找出被拒判据对应的卡，再要 run 信封（同一次请求里带 taskIds）
+      // 要返工：先找出被拒判据对应的卡，再要 run 信封（同一次请求里带 taskIds）。
+      // 打回次数由服务端落盘，页面不再传——刷新页面也不会把上限洗掉。
       var ids = failedCardIds(lastPlan, first.verdict && first.verdict.items);
       return request('rework', Object.assign({}, base, { taskIds: ids })).then(function (second) {
         var chain = Promise.resolve();
         (second.runs || []).forEach(function (run) {
           chain = chain.then(function () { return boardPost(run); });
         });
+        /* 验收卡也是父卡的子卡：重跑单张开发卡不会把它带起来，所以这里单独再排一次。
+           它会先等 30 秒、并且只认比「该卡最近一次执行开始时间」更新的报告，
+           不会把上一轮的旧报告当成本轮证据。 */
+        if (lastPlan && lastPlan.verifyId) {
+          chain = chain.then(function () {
+            return boardPost({
+              requestId: 'card-dispatch-verify-' + Date.now() + '-' + lastPlan.rootId,
+              action: { kind: 'run', taskId: lastPlan.verifyId },
+            });
+          });
+        }
         return chain.then(function () { showRework(second); return second; });
       });
     })
     .then(function (result) {
       var action = (result.decision || {}).action;
       if (action === 'rework') {
-        rejectedCount = result.decision.rejectedCount;
-        toast('已退回开发：' + (result.runs || []).length + ' 张卡重跑中', 'ok');
+        toast('已退回开发：' + (result.runs || []).length + ' 张卡重跑中（第 ' + result.attempt + ' 次打回）', 'ok');
       } else if (action === 'pass') {
         toast('验收通过', 'ok');
       } else {
@@ -454,21 +466,48 @@ function loadWorkspaces() {
     });
 }
 
+/* 从看板 state 里算运行态：预算闸要「今天跑了几次」，并发闸要「几个会话在跑」。
+   看板的 task.executions 带 startedAt / endedAt（ms epoch），正好够算；
+   拿不到就返回 null，让服务端拒绝放行，而不是补 0。 */
+function boardStatsOf(state) {
+  var tasks = (state && Array.isArray(state.tasks)) ? state.tasks : null;
+  if (!tasks) return null;
+  var midnight = new Date();
+  midnight.setHours(0, 0, 0, 0);
+  var since = midnight.getTime();
+  var running = 0;
+  var today = 0;
+  tasks.forEach(function (task) {
+    var executions = (task && Array.isArray(task.executions)) ? task.executions : [];
+    if (executions.some(function (execution) { return execution && execution.endedAt === undefined; })) running += 1;
+    executions.forEach(function (execution) {
+      if (execution && typeof execution.startedAt === 'number' && execution.startedAt >= since) today += 1;
+    });
+  });
+  return { runsToday: today, runningSessions: running };
+}
+
 function checkBoard() {
   return fetch(BOARD + '/state', { credentials: 'same-origin' })
     .then(function (response) {
       if (!response.ok) {
+        boardStats = null;
+        boardFacts = { reachable: false, teamRun: null };
         el('board-state').className = 'pill bad';
         el('board-state').textContent = '看板不可用（HTTP ' + response.status + '）';
         return null;
       }
       return response.json().then(function (state) {
+        boardStats = boardStatsOf(state);
+        boardFacts = { reachable: true, teamRun: typeof state.teamRunAvailable === 'boolean' ? state.teamRunAvailable : null };
         el('board-state').className = 'pill ok';
         el('board-state').textContent = '看板可用 · 默认权限 ' + (state.sessionDefaultPermission || '?');
         return state;
       });
     })
     .catch(function () {
+      boardStats = null;
+      boardFacts = { reachable: false, teamRun: null };
       el('board-state').className = 'pill bad';
       el('board-state').textContent = '看板未安装或未启动';
       return null;
@@ -491,7 +530,9 @@ function splitPayload() {
     intros: aiIntros,
     /* 人点「写入并运行」这一下，就是计划闸要的那次批准。只写卡不运行时不给批准，
        免得预演也把闸门算成已过。 */
-    planApproved: el('brd-run').checked
+    planApproved: el('brd-run').checked,
+    /* 运行态：预算/并发闸要真实数字。拿不到就是 null，服务端会拒绝放行。 */
+    state: boardStats
   };
 }
 
@@ -530,47 +571,52 @@ function clearPreview(hint) {
 }
 
 function previewSplit() {
-  var payload = splitPayload();
-  if (!payload.title) { toast('先写需求标题', 'err'); return; }
-  request('split', payload).then(renderPlan).catch(function (error) {
-    toast('拆分失败：' + error.message, 'err');
+  if (!el('brd-title').value.trim()) { toast('先写需求标题', 'err'); return; }
+  // 先刷一次看板运行态：预算/并发闸要用最新数字，不能拿页面打开那一刻的旧值。
+  checkBoard().then(function () {
+    request('split', splitPayload()).then(renderPlan).catch(function (error) {
+      toast('拆分失败：' + error.message, 'err');
+    });
   });
 }
 
 function pushToBoard() {
-  var payload = splitPayload();
-  if (!payload.title) { toast('先写需求标题', 'err'); return; }
-  var runNow = el('brd-run').checked;
+  if (!el('brd-title').value.trim()) { toast('先写需求标题', 'err'); return; }
   var button = el('btn-push');
   button.disabled = true;
-  request('split', payload).then(function (plan) {
-    // 闸门不允许时服务端不返回运行信封：这里必须同步降级，否则会把「没批准」当「已排队」。
-    if (runNow && !plan.run) {
-      runNow = false;
-      el('brd-run').checked = false;
-      toast('只写卡，不运行：' + (plan.gate ? plan.gate.message : '闸门未放行'), 'err');
-    }
-    el('brd-preview').className = 'preview-body';
-    el('brd-preview').textContent = '正在写入看板：' + plan.cards.length + ' 张卡…';
-    el('brd-preview-hint').textContent = '写入中…';
-    var chain = Promise.resolve();
-    plan.envelopes.forEach(function (envelope) {
-      chain = chain.then(function () { return boardPost(envelope); });
-    });
-    if (runNow) chain = chain.then(function () { return boardPost(plan.run); });
-    return chain.then(function () {
-      renderPlan(plan);
-      rememberPlan(plan);
-      el('brd-preview').textContent += '\n\n已写入 ' + plan.cards.length + ' 张卡'
-        + (runNow ? '，并已排队运行。' : '。去侧边栏「任务看板」点「运行」开始执行。');
-      el('brd-preview-hint').textContent = '已写入看板';
-      toast('已写入任务看板：' + plan.cards.length + ' 张卡' + (runNow ? '（已排队运行）' : ''), 'ok');
-      el('brd-title').value = ''; el('brd-desc').value = ''; el('brd-criteria').value = '';
-      saveDraft();
+  checkBoard().then(function () {
+    var payload = splitPayload();
+    var runNow = el('brd-run').checked;
+    return request('split', payload).then(function (plan) {
+      // 闸门不允许时服务端不返回运行信封：这里必须同步降级，否则会把「没批准」当「已排队」。
+      if (runNow && !plan.run) {
+        runNow = false;
+        el('brd-run').checked = false;
+        toast('只写卡，不运行：' + (plan.gate ? plan.gate.message : '闸门未放行'), 'err');
+      }
+      el('brd-preview').className = 'preview-body';
+      el('brd-preview').textContent = '正在写入看板：' + plan.cards.length + ' 张卡…';
+      el('brd-preview-hint').textContent = '写入中…';
+      var chain = Promise.resolve();
+      plan.envelopes.forEach(function (envelope) {
+        chain = chain.then(function () { return boardPost(envelope); });
+      });
+      if (runNow) chain = chain.then(function () { return boardPost(plan.run); });
+      return chain.then(function () {
+        renderPlan(plan);
+        rememberPlan(plan);
+        el('brd-preview').textContent += '\n\n已写入 ' + plan.cards.length + ' 张卡'
+          + (runNow ? '，并已排队运行。' : '。去侧边栏「任务看板」点「运行」开始执行。')
+          + (plan.verifyId ? '\n验收卡是父卡的子卡：运行父卡时它会一起启动，等报告齐全后自动验收。' : '');
+        el('brd-preview-hint').textContent = '已写入看板';
+        toast('已写入任务看板：' + plan.cards.length + ' 张卡' + (runNow ? '（已排队运行）' : ''), 'ok');
+        el('brd-title').value = ''; el('brd-desc').value = ''; el('brd-criteria').value = '';
+        saveDraft();
+      });
     });
   }).catch(function (error) {
     clearPreview('写入失败');
-    toast('写入看板失败：' + error.message, 'err');
+    toast('写入看板失败：' + error.message + '（已建的卡会保留；再点一次是同一批 id，看板会跳过）', 'err');
   }).then(function () {
     button.disabled = false;
   });
@@ -599,6 +645,25 @@ function applyConfig(snapshot) {
     ? '开关保存在 ' + snapshot.configFile + '（它优先于部署配置；删掉该文件即回到部署值）'
     : '';
   syncTeamRunUi();
+  syncEvidenceUi();
+}
+
+/* 交付门槛与团队开关是两件事，但经常一起被问：
+   - 门槛管「要不要独立验收」，关掉就退化成「执行者自己说完成」；
+   - 团队管「验收卡由谁跑」，没开团队时验收卡不自动排队，需要人点一下。
+   把关系写在开关下面，比把两个开关绑成一个更难误操作。 */
+function syncEvidenceUi() {
+  var hint = el('cfg-evidence-hint');
+  if (!hint) return;
+  var evidence = el('cfg-evidence').checked;
+  var team = el('cfg-teamrun').checked;
+  if (!evidence) {
+    hint.textContent = '关掉后不生成验收卡，也不要求报告与 commit；单卡自己说「做完了」就算完，不建议。';
+  } else if (team) {
+    hint.textContent = '验收卡是同一会话里的 teammate：和子卡一起启动，等报告齐全后自动验收，不额外开会话。';
+  } else {
+    hint.textContent = '会多一张验收卡：父卡以 Lead 会话运行，验收卡是同一会话里的 teammate，等报告出现后自动验收，只算 1 条会话。';
+  }
 }
 
 /* 拆不拆子卡由「智能体团队」决定：没开团队，每张子卡都是独立会话，所以「按判据拆」
@@ -665,8 +730,19 @@ function saveConfig() {
 }
 
 /* 体检结论按严重度直接摊开：fatal 会挡住开工，warn 是「能跑但难受」，info 是知道了就行。 */
+/* 插件进程看不见看板（看板有信任栅栏），页面看得见：把探测结果带给 /status，
+   体检才能给出「看板可达 / 支持 teamRun」而不是一片未知。 */
+function statusQuery() {
+  var parts = [];
+  if (boardFacts && boardFacts.reachable !== null) parts.push('boardReachable=' + boardFacts.reachable);
+  if (boardFacts && boardFacts.teamRun !== null && boardFacts.teamRun !== undefined) {
+    parts.push('boardTeamRun=' + boardFacts.teamRun);
+  }
+  return parts.length ? '?' + parts.join('&') : '';
+}
+
 function runStatus() {
-  return fetch(BASE + 'status', { credentials: 'same-origin' })
+  return fetch(BASE + 'status' + statusQuery(), { credentials: 'same-origin' })
     .then(function (response) { return response.json().catch(function () { return {}; }); })
     .then(function (snapshot) {
       var check = snapshot.selfCheck || { findings: [] };
@@ -898,10 +974,25 @@ el('brd-model').addEventListener('change', function () {
 });
 /* 团队开关立刻生效：它决定拆不拆子卡、也就是这次会开几条会话，
    让人勾完再点一次「保存」才知道预览变了，属于会让人算错账的那种设计。 */
+function saveAndRecompute() {
+  return saveConfig().then(function () {
+    if (el('brd-preview').textContent.trim() !== '') previewSplit();
+  });
+}
+
 el('cfg-teamrun').addEventListener('change', function () {
   syncTeamRunUi();
-  saveConfig().then(function () {
-    if (el('brd-preview').textContent.trim() !== '') previewSplit();
+  syncEvidenceUi();
+  saveAndRecompute();
+});
+
+/* 其余开关与数字也一样：改完立刻保存并重算预览。
+   以前只有「智能体团队」接了 change，于是勾「交付门槛」后预览不动，
+   人会以为这个开关没生效——其实要再点一次「保存」才重算。 */
+['cfg-enabled', 'cfg-plan', 'cfg-evidence', 'cfg-audit', 'cfg-budget', 'cfg-parallel', 'cfg-rework'].forEach(function (id) {
+  el(id).addEventListener('change', function () {
+    syncEvidenceUi();
+    saveAndRecompute();
   });
 });
 
@@ -949,7 +1040,8 @@ function syncHost() {
       if (!hostSynced) {
         hostSynced = true;
         loadConfig();
-        runStatus();
+        // 先探一次看板，再体检：否则第一次体检会把 boardReachable 报成未知
+        checkBoard().then(function () { runStatus(); });
       }
       // 宿主是新的，但这个 iframe 里的文档是旧的（改了 HTML 没刷新）→ 整页重载
       if (snapshot.pageVersion && snapshot.pageVersion !== PAGE_VERSION) location.reload();

package/src/criteria.js

@@ -1,11 +1,10 @@
 /**
- * criteria.js：从标题与描述里提炼**判据草稿**。
+ * criteria.js：从标题与描述里提炼**判据草稿**（无模型时的退路）。
  *
- * ## 为什么是规则，不是模型
+ * ## 为什么这里不调模型
  *
- * 宿主暴露给插件的服务里没有模型接口（只有 workspaces / sessions / tools /
- * taskBoard / settings 这些）。要真让模型写判据，只能开一个会话——那是花钱且
- * 要人看着的事，不该藏在「点一下自动生成」后面。
+ * 模型通道在 `criteria-llm.js`（`ctx.get('llm')`）。这一层刻意只用规则：
+ * 模型不可用、开关关着、或者一次点击不值得多花一次调用时，仍然要能给出可编辑的草稿。
  *
  * 所以这里只做**提炼**：把描述里本来就写成要求的话捞出来，变成一行一条。
  * 提炼不出来就说提炼不出来，并告诉人怎么写才好提炼——不编造判据。

package/src/gates.js

@@ -19,6 +19,7 @@
 export const GATE_CODES = Object.freeze({
   DISABLED: 'E_DISABLED',
   PLAN_NOT_APPROVED: 'E_PLAN_NOT_APPROVED',
+  STATE_UNKNOWN: 'E_STATE_UNKNOWN',
   BUDGET: 'E_BUDGET_EXCEEDED',
   PARALLEL: 'E_PARALLEL_LIMIT',
   EVIDENCE: 'E_EVIDENCE_MISSING',
@@ -27,17 +28,18 @@ export const GATE_CODES = Object.freeze({
 /**
  * 能不能开一轮（= 能不能花钱）。
  *
- * 顺序是刻意的：先看总开关，再看计划闸，最后才是预算和并发。
+ * 顺序是刻意的：先看总开关，再看计划闸，然后运行态、预算和并发。
  * 因为「没打开」和「没批准」是配置/流程问题，人应该先看到它们；
- * 预算和并发是运行态问题，排在后面。
+ * 运行态与预算是运行态问题，排在后面；运行态拿不到就直接拒绝，不拿 0 冒充。
  *
  * @param {object} input
  * @param {object} input.config 归一化后的配置
  * @param {object} [input.state] 运行态快照 `{runsToday, runningSessions}`
  * @param {object} [input.request] 本次请求 `{planApproved}`
+ * @param {boolean} [input.stateKnown] 调用方是否真的拿到了运行态；false = 不许拿 0 冒充
  * @returns {{allow:boolean, code:string|null, message:string, checks:Array}}
  */
-export function evaluateStart({ config, state = {}, request = {} } = {}) {
+export function evaluateStart({ config, state = {}, request = {}, stateKnown } = {}) {
   const checks = []
   const push = (id, ok, detail) => {
     checks.push({ id, ok, detail })
@@ -56,11 +58,20 @@ export function evaluateStart({ config, state = {}, request = {} } = {}) {
   }
 
   const runsToday = Number(state.runsToday ?? 0)
+  const running = Number(state.runningSessions ?? 0)
+  // 调用方没明说时：给了非空 state 就当知道，空对象/没给就是「不知道」。
+  const known = stateKnown ?? (state !== null && typeof state === 'object' && Object.keys(state).length > 0)
+
+  // 运行态缺失时**不许按 0 放行**：预算/并发闸的全部价值就是「拿真实数字做决定」。
+  // 以前调用方传 state:{}，这里永远是 0，两个闸形同虚设；现在缺数据就明说。
+  if (!push('state', known, known ? `运行态：今天 ${runsToday} 次 / 在跑 ${running} 个` : '没有运行态快照')) {
+    return deny(GATE_CODES.STATE_UNKNOWN, '预算/并发闸拿不到运行态（今天跑了几次、几个会话在跑）：先刷新看板状态再开跑，不要拿 0 冒充')
+  }
+
   if (!push('budget', runsToday < config.gates.budgetPerDay, `今天已跑 ${runsToday} / ${config.gates.budgetPerDay}`)) {
     return deny(GATE_CODES.BUDGET, `预算闸：今天已经跑了 ${runsToday} 次，达到上限 ${config.gates.budgetPerDay}；清零后才能继续`)
   }
 
-  const running = Number(state.runningSessions ?? 0)
   if (!push('parallel', running < config.gates.maxParallelRuns, `当前在跑 ${running} / ${config.gates.maxParallelRuns}`)) {
     return deny(GATE_CODES.PARALLEL, `并发闸：已有 ${running} 个会话在跑，上限 ${config.gates.maxParallelRuns}`)
   }