paseo-req-kit 1.14.0-beta.4 → 1.14.0

package/CHANGELOG.md

@@ -2,6 +2,45 @@
 
 每个版本分为"使用者会看到的变化"和"升级须知"。升级步骤见 [docs/guide/安装与升级.md](docs/guide/安装与升级.md)。
 
+## 1.14.0
+
+稳定版：需求从对齐开始就在插件里，新建工作区能接着做，插件里能做代码审查和验收，危险命令和密钥有程序把关，评审、验收、合并之后的结果有记录可查。内容包括 1.14.0-beta.1 至 beta.5（详见下面各条）。
+
+### 使用者会看到的变化
+
+- **修复：自动新建工作区后只有需求说明、没有代码。** 工作区一建好就记下来，再次启动在同一个工作区里接着做；最多等 15 分钟。术语表和设计决定随需求说明一起带过去；需求说明不会再被提交到主分支。
+- **需求从开始谈就出现在插件里**（"对齐中"）；确认了却没开始开发的进"等你处理"，点"开始开发"即可，谈需求的对话里也会提醒一次。已经开发完的需求不会误显示为"未开始"；同一个需求在两处只列一次。
+- **代码审查**（插件需求页面上的"代码审查"，`req code-review`）：改动按文件列出，AI 评审意见放在对应的行旁边；评审人在任意一行写意见、标"要改 / 不用改"；审核人默认取自 `CODEOWNERS`，提交前可改。退回修改后流水线自动按意见修改，评审通过后有新提交会提示重新评审。
+- **验收清单和一键试用**（"验收清单（可一键试用）"，`req checklist`、`req try`）：按验收标准逐条勾选，提交后写成 `acceptance.md` 并提交；不通过的转给需求的对话处理。
+- **拦截危险命令**（`dangerGuard`）：步骤 agent 推送、发布制品、改动集群、连接其他机器上的数据库或主机、删除仓库以外的目录、下载脚本直接执行，或命令里出现配置的生产环境地址时，打断并通知。
+- **密钥扫描**（`secretScan`）：每个改代码的步骤之后扫描本需求新增的内容，交回 agent 去掉；有疑似密钥的分支不推送。
+- **记录可查**：代码审查和验收的全文随需求分支提交；结论另记入使用记录。`req stats` 和插件统计新增"人工把关和合并后"：评审退回次数、验收通过率、合并进主干的需求、合并后发现的问题（`req outcome`）。
+
+### 升级须知
+
+- 新配置都可选：`dangerGuard`（默认开，建议团队配置里把生产环境的主机名、地址写进 `production`）、`secretScan`（默认开）。打开 `dangerGuard` 时流水线每 15 秒读一次步骤 agent 的命令记录，不占模型 token。
+- 合并请求还没有接入，等 shenbing 提供类似 `gh pr create / gh pr merge` 的命令。
+- 状态文件、使用记录、`req api` 和外部通知的新增字段见各 beta 的升级须知；新命令 `req code-review`、`req review-fix`、`req checklist`、`req try`、`req outcome`。
+- 更新后请在 Paseo 中重新加载插件（`req upgrade` 会自动做）。
+
+## 1.14.0-beta.5
+
+### 使用者会看到的变化
+
+- **拦截危险命令**（`dangerGuard`，默认开）：步骤 agent 推送代码、发布制品、改动集群或基础设施、连接其他机器上的数据库或主机、删除仓库以外的目录、下载脚本直接执行，或者命令里出现配置的生产环境地址时，流水线打断它（还在运行时）、告诉它把需要人做的写进产物，并通知需求的对话；每次都记下来，写进完成报告。按命令文字检查，不用模型；能拦住常见的情况，不是沙箱。
+- **密钥扫描**（`secretScan`，默认开）：每个改代码的步骤之后，检查本需求新增的内容（每次提交加的行、未提交的改动、新文件）有没有密钥、令牌、口令；发现了交回这一步的 agent 去掉（包括从还没推送的提交里去掉），仍去不掉的通知需求的对话、写进代码评审和完成报告；配置了推送的需求不会推送有疑似密钥的分支。
+- **记录合并之后的结果**：`req stats` 和插件的使用统计新增"人工把关和合并后"：人工代码评审几次、退回几次，验收几次、不通过几次，第一次就通过的需求数，合并进主干的需求和"完成到合并"的时间，合并后发现的问题。合并是从本机仓库已有的分支判断的（需求的流水线文件进了主干）；缺陷需求写了 `- 引入问题的需求：<目录名>` 的，算作那个需求合并后的问题；也可以 `req outcome <需求> --issue "<问题>"` 手动记一笔。
+- **代码审查和验收的结论进使用记录**：每次在代码审查页、验收页提交，结论、评审人和意见条数记入本机使用记录（全文仍在随分支提交的 `code-review.md`、`acceptance.md` 里）；`req stats --export` 一起导出。
+- **确认了却没开始开发的需求，在谈需求的对话里提醒一次**（插件的后台检查，确认 30 分钟后；只提醒 3 天内确认的）。
+- **修复：同一个需求在主目录和它自己的工作区里各有一份时，插件列出两次。** 现在只列一次，优先列在运行的、有运行状态的那一份。
+
+### 升级须知
+
+- 新配置都可选：`dangerGuard`（默认 `{ "enabled": true, "production": [], "allow": [] }`，建议团队配置里把生产环境的主机名、地址写进 `production`）、`secretScan`（默认 `{ "enabled": true, "allow": [] }`）。打开 `dangerGuard` 时流水线每 15 秒读一次步骤 agent 的命令记录，不占模型 token。
+- 使用记录 `usage/runs.jsonl` 新增 `review`、`acceptance`、`merge`、`issue` 几种记录（见 `contracts/usage-record.md`），旧版本读取时会跳过；`req stats --json` / `req api stats` 新增 `oversight`，每个需求新增 `afterRun`，CSV 新增 7 列。状态文件新增 `dangers`、`secretScans`；外部通知 `alert` 事件新增 `details.kind: "danger"`。
+- 新命令 `req outcome`；`req reply` 新增 `--notice`（后台检查用）。
+- 提示词里"不改写历史"加了一个例外：流水线要求从本需求还没推送的提交里去掉密钥时。
+
 ## 1.14.0-beta.4
 
 ### 使用者会看到的变化

package/bin/req.mjs

@@ -52,6 +52,9 @@ const HELP = `req-kit ${version}（${kitRoot}）
   req stats --report [--out 目录]
                                生成汇报用的汇总（.md）和每个需求一行的表格（.csv）
   req stats --export [文件]    导出本机的运行记录；汇总多台机器：req stats --merge <文件…> --report
+  req outcome                  查找已合并进主干的需求和合并后发现的问题，记入使用记录（req stats 也会自动查）
+  req outcome <需求> --merged | --issue "<问题>"
+                               手动记一笔：已合并，或合并后发现的问题
   req index [--rebuild [目录…]] [--prune]
                                本机记录的需求（Paseo 插件据此找到所有需求）；1.9 之前运行过的用 --rebuild 补登
   req api <命令> …             给程序用的 JSON 输出（见 contracts/cli-json.md）
@@ -237,6 +240,9 @@ switch (command) {
   case "checklist":
     code = needTsx() ? node([tsxCli, path.join(kitRoot, "engine", "src", "checklist-cmd.ts"), ...rest]) : 1;
     break;
+  case "outcome":
+    code = needTsx() ? node([tsxCli, path.join(kitRoot, "engine", "src", "outcomes.ts"), ...rest]) : 1;
+    break;
   case "ui-check":
     code = needTsx() ? node([tsxCli, path.join(kitRoot, "engine", "src", "ui-check.ts"), ...rest]) : 1;
     break;

package/contracts/notifier-event.md

@@ -79,7 +79,7 @@ export default async function notify(event, options) { /* 发送 */ }
 | `completed` | 流水线结束，报告已生成 | `outcome`（`completed`、`completed_with_issues`、`not_completed`）、`summary`、`reportPath`。"只做研发"时另有 `mode`（`develop-only`）和 `handoffPath`，报告是研发报告，需要人工测试 |
 | `approval` | 1.8.0 起。方案确认点（`designApproval`）：方案已通过审核，等待需求方确认"做完后会看到什么"，还没有开始写代码 | `previewPath`（要确认的内容）、`approveCommand`（确认后继续的命令）、`resumeCommand`（修改需求后继续的命令），都在发起的对话中执行 |
 | `phase_done` | 1.7.0 起。分阶段执行时研发阶段已完成（代码已通过评审、提测说明已写好），流水线停在闸口等待测试验证。测试退回后再次修完也会发 | `handoffPath`（提测说明）、`mode`（`gated`）、`verifyCommand`（开始测试验证的命令，在发起的对话中执行）、`verifyAt`（预约的开始时间，ISO 格式，没有为 null）、`handbacks`（已退回的次数） |
-| `alert` | 1.12 起。接单器（`req factory`）自检没有通过（Paseo 连不上、agent 没有登录、额度用完、需求管理系统的命令不可用），暂停接新卡片；或者恢复正常。同样的问题只发一次。`feature.title` 为"接单器"，`feature.dir`、`repo` 为空 | `source`（`factory`）、`machine`、`problems`（字符串数组，恢复时为空）、`recovered` |
+| `alert` | 1.12 起。接单器（`req factory`）自检没有通过（Paseo 连不上、agent 没有登录、额度用完、需求管理系统的命令不可用），暂停接新卡片；或者恢复正常。同样的问题只发一次。`feature.title` 为"接单器"，`feature.dir`、`repo` 为空 | `source`（`factory`）、`machine`、`problems`（字符串数组，恢复时为空）、`recovered`。1.14 起，步骤 agent 运行或开始运行危险命令（`dangerGuard`）时也发：`details.kind` 为 `danger`，另有 `stepTitle`、`command`、`label`、`ran`；这时 `feature`、`repo` 是那个需求的 |
 | `digest` | `req digest --notify`（或由 `req digest --schedule` 创建的 Paseo 定时任务）发送项目的需求总览，1.6.0 起。`feature.title` 为"<项目> 需求总览"，`text` 是完整的多行总览 | `features`：每个需求的 `name`、`title`、`stage`、`branch`、`updatedAt`、`usage`；`recurringLessons`（1.8.0 起）：在两个以上需求的 `lessons.tsv` 中出现的问题类别，每项 `category`、`features`、`rules` |
 
 ## 兼容性

package/contracts/spec.md

@@ -22,6 +22,7 @@
 | `- 执行方式：` | 引擎 | "连续"、"分阶段"或"只做研发"（也接受 `continuous` / `gated` / `develop-only`）。可以没有；没有时用配置中的 `phases.mode`，启动参数 `--phases` 优先（1.7 起） |
 | `- 类型：` | 引擎（1.8 起）、`/req` | 新需求 / 小改动 / 缺陷 / 重构 / 评估（也接受 `defect`、`bug`、`refactor`、`assessment`；"技术改进"同重构，"调研"同评估）。缺陷、重构、评估按各自的做法运行（`engine/prompts/types/`），配置 `requirementTypes` 可以关掉某个类型；其他写法按新需求处理 |
 | `- 联合开发：` | 引擎（1.8 起） | 这个需求还要改的其他仓库，写项目配置 `relatedRepos` 中的名称，最多两个，用顿号分开。可以没有。见 ADR 0025 |
+| `- 引入问题的需求：` | `req stats`、`req outcome`（1.14 起） | 缺陷需求才写：引入这个问题的需求的目录名（或功能目录、标题）。记为那个需求"合并后发现的问题"。可以没有 |
 | `- 版本：` | `/req` | 从 1 开始，每次修改需求加 1 |
 | `- 格式：` | `/req`、引擎（将来） | `req-kit/spec@<n>`。没有这一行的旧 spec 按 `req-kit/spec@1` 处理 |
 

package/contracts/state.md

@@ -22,6 +22,8 @@
 | `budget` | object | 可选，1.13 起，配置了 `budget.tokens` 时。`{ allowance, warnedAt }`：停下前允许用到的 tokens（预算，每次用完后继续再加一份）；已经提醒过的那一档 |
 | `waitingPermission` | object \| null | 可选，1.13 起。步骤 agent 在等权限批准时：`{ agentId, stepTitle, requests, since }`；没有在等时为 null |
 | `recoveries` | array | 可选，1.12 起。流水线自己处理掉的问题（最多保留 200 条）：`at`、`key`（步骤键）、`kind`（`retry` 重试 / `reattach` 接着等上一次的 agent / `reuse_result` 沿用上一次 agent 的结果 / `extend_timeout` 超时后多等一轮 / `redo` 新开 agent 重做 / `fallback` 换备用模型 / `auto_resume` 预约自动继续 / `quota_wait` 预约在额度恢复后继续 / `self_answer` 方案审核的问题由 builder 自答 / `stop_scan` 打断了搜索大目录的命令，1.13 起）、`detail` |
+| `dangers` | array | 可选，1.14 起。步骤 agent 运行（或开始运行）的危险命令（`dangerGuard`，最多保留 50 条）：`at`、`key`（步骤键）、`stepTitle`、`command`、`label`（如"推送到远程仓库"）、`ran`（发现时已经运行完为 true，正在运行、已打断为 false）、`agentId`、`callId`（同一个调用只处理一次） |
+| `secretScans` | array | 可选，1.14 起。改代码的步骤之后的密钥扫描（`secretScan`），每个步骤、每次尝试保留最新一次：`key`、`attempt`、`at`、`findings`（`{ file, line, commit, kind, preview }`，`preview` 里的值已遮住）、`fixRounds`、`passed` |
 | `profile` | `quick` \| `standard` | 档位 |
 | `branch` | string \| null | 工作分支，启动时确定 |
 | `milestones` | string[] | 已发送的进展通知，续跑时不重复发送 |
@@ -39,7 +41,7 @@
 | `joint` | array \| null | 可选，1.8.0 起。联合需求（spec 的 `- 联合开发：`）中其他仓库的工作区：`name`（`relatedRepos` 中的名称）、`slug`（步骤键的后缀，如 `implement@backend`）、`sourceRepo`（切出工作区的那份检出）、`repo`（工作区目录）、`workspaceId`、`branch`、`specHash`（最近一次同步过去的 spec），以及这个仓库自己的 `codeBase` 和 `gate`（格式同顶层）。见 ADR 0025 |
 | `approval` | object \| null | 可选，1.8.0 起。方案确认点：`attempt`（哪一次尝试的方案）、`status`（`waiting` / `approved`）、`at`。需求变更后的新尝试需要重新确认 |
 | `external` | object \| null | 可选，1.9.0 起。外部系统中的卡片，按集成名称：`id`（卡片编号）、`url`、`status`（最近设置的状态）、`syncedAt`、`pending`（没有成功、等待补发的调用：`action` 为 `create` / `status`、`event`、`status`、`at`、`attempts`、`error`）。见 ADR 0028 |
-| `pushed` | array \| null | 可选，1.10 起。从卡片开始、配置了 `push` 的需求推送过的分支，每个仓库一条（主仓库在前）：`repo`、`remote`、`branch`、`at`、`error`（成功时为 null）。见 ADR 0029 |
+| `pushed` | array \| null | 可选，1.10 起。从卡片开始、配置了 `push` 的需求推送过的分支，每个仓库一条（主仓库在前）：`repo`、`remote`、`branch`、`at`、`error`（成功时为 null；1.14 起，发现疑似密钥时不推送，`error` 写明原因）。见 ADR 0029 |
 | `gate` | object \| null | 可选，1.8.0 起。质量门：`baseline`（`attempt`、`commit`、`at`、`results`：每项检查改动前 `pass` / `fail`），`runs`（每次运行：`key` 步骤键、`attempt`、`at`、`checks`（`name`、`result`：`pass` / `fail` / `skipped`、`failedBefore`）、`newFailures`、`fixRounds`、`passed`）。各次运行的完整输出在 `.pipeline/checks/<步骤键>/` |
 
 `schedules[].kind` 在 1.7.0 起还可能是 `verify-start`（`--verify-at` 预约的测试验证开始），1.8.0 起还可能是 `approval-continue`（方案确认超时后按方案继续，`designApproval.autoContinueHours`）。`history` 中每条步骤记录在 1.7.0 起有可选的 `phase`（`develop` / `verify`），用于按阶段统计用时与用量；没有时按研发阶段统计。

package/contracts/usage-record.md

@@ -42,6 +42,19 @@
 
 不记录需求内容、代码和对话。
 
+### 运行之后的事（1.14 起）
+
+同一个文件里还有几种记录，都有 `schema`（1）、`kind`、`machine`、`kitVersion`、`at` 和 `requirement`（`{ key, project, name, title }`，`key` 与运行记录相同）。读运行记录的旧版本会跳过它们。
+
+| `kind` | 何时写 | 字段 |
+| --- | --- | --- |
+| `review` | 插件代码审查页提交"退回修改"或"评审通过" | `review: { verdict: "approved" \| "changes_requested", reviewer, items, head }`：评审人、意见条数、评审的提交 |
+| `acceptance` | 验收清单页提交 | `acceptance: { verdict: "通过" \| "不通过", reviewer, total, passed, failed, unchecked }` |
+| `merge` | `req stats`、`req api stats`、`req outcome` 发现需求的流水线文件（`implementation.md`、`report.md` 等）已经在主干（`origin/HEAD`，没有时 `origin/main`、`main` 等）里；或者 `req outcome <需求> --merged` | `merge: { into, commit, mergedAt, how: "files" \| "manual" }`：`commit`、`mergedAt` 是把它带进主干的那次提交（合并提交或压缩合并的提交）；只看本机已有的分支，不 fetch |
+| `issue` | 缺陷需求的 spec 写了 `- 引入问题的需求：<目录名>`（扫描时发现），或者 `req outcome <需求> --issue "<问题>"` | `issue: { text, by, id }`：`by` 是那个缺陷需求的目录名，手动记的为 null；同一个 `id` 只算一次 |
+
+每个需求的 `merge` 只记一次。评审和验收的全文在需求目录的 `code-review.md`、`acceptance.md` 里，随需求分支提交；这里只记结论和数量，用于统计。
+
 ## 统计口径（`req stats`）
 
 - 一段时间的用量、步骤用时：结束时间在这段时间内的运行。
@@ -52,6 +65,7 @@
 - 停下等人的原因（1.12 起）：这段时间结束的运行按 `stopKind` 计数；更早的记录按结束时的状态推断。确认方案、研发完成等待测试是必要的决定。
 - 无人工到提测的比例（1.12 起）：这段时间有进展、已经研发完成或完成的需求中，所有运行都只停在必要决定处的比例。
 - 自动处理的比例（1.12 起）：自动处理的次数 ÷（自动处理的次数 + 以中断结束的运行数）；需求方决定、缺陷复现不了不算中断。
-- 合并多台机器的导出时，同一机器、同一需求、同一开始时间的运行只算一次。
+- 人工把关和合并后（1.14 起，`oversight`）：这段时间里的人工代码评审次数、退回修改次数、意见条数，验收次数和不通过次数；"第一次就通过"看每个需求最早的那次评审（验收），它在这段时间里并且是通过；合并进主干的需求数和"完成到合并"的小时数中位数；合并后发现的问题数和涉及的需求数。每个需求一项里的 `afterRun` 汇总它全部的这类记录（`humanReviews`、`sentBack`、`lastReview`、`acceptance`、`acceptanceFailed`、`mergedAt`、`issues`）。
+- 合并多台机器的导出时，同一机器、同一需求、同一开始时间的运行只算一次；同一个需求、同一种、同一时间的事件（问题按 `id`）只算一次。`req stats --export` 同时导出这些需求的事件。
 
-`req stats --json` 和 `req api stats` 输出同样的对象（`schema: 1`）：`period`、`machines`、`active`、`completed`、`byType`、`cycleHours`、`steps`、`rework`、`waits`、`usage`、`byBuilder`、`requirements`（每个需求一项，字段与 `req stats --csv` 的列对应）。
+`req stats --json` 和 `req api stats` 输出同样的对象（`schema: 1`）：`period`、`machines`、`active`、`completed`、`byType`、`cycleHours`、`steps`、`rework`、`waits`、`usage`、`tokens`、`oversight`、`byBuilder`、`requirements`（每个需求一项，字段与 `req stats --csv` 的列对应）。

package/docs/guide//344/275/277/347/224/250/350/200/205/346/214/207/345/215/227.md

@@ -117,9 +117,11 @@ req-kit 帮你把一个需求从"我想要……"做到"可以验收"：你在 P
 
 测试同事可以把验收标准直接转成测试用例：每条都写成了"前置条件 / 操作 / 预期结果"。
 
+**记录会留下来（1.14 起）。** 代码审查和验收的结论、评审人、每条意见都写在需求目录的 `code-review.md`、`acceptance.md`（退回修改的原因在 `changes.md`）里，随需求分支提交，合并后在主干上也能查。结论和数量另外记在本机的使用记录里，`req stats` 能看到人工评审退回了几次、验收通过率、合并进主干的需求和合并后发现的问题。
+
 ## 上线后发现问题
 
-说"线上发现……不对"。AI 会先问这个问题是否正在影响真实用户：是的话，请马上联系开发同事或值班人员处理线上情况（req-kit 不碰生产环境）。然后它会问清现象、复现步骤、影响范围，关联到原来的需求，生成一份缺陷说明，按快速流程修复，修复后照常验收。
+说"线上发现……不对"。AI 会先问这个问题是否正在影响真实用户：是的话，请马上联系开发同事或值班人员处理线上情况（req-kit 不碰生产环境）。然后它会问清现象、复现步骤、影响范围，关联到原来的需求，生成一份缺陷说明，按快速流程修复，修复后照常验收。缺陷说明里写明是哪个需求引入的问题，`req stats` 会把它算作那个需求"合并后发现的问题"；也可以在终端里手动记一笔：`req outcome <需求> --issue "<问题>"`。
 
 ## 注意
 

package/docs/guide//351/241/271/347/233/256/345/256/232/345/210/266/344/270/216/350/277/220/350/241/214/350/247/204/345/210/231.md

@@ -533,7 +533,7 @@ Paseo 自带的 `/paseo-advisor`、`/paseo-committee` 等编排 skill 也可以
 
 **结果文件**：每步必须写一个 JSON 结果文件，流水线只看它，不看 agent 的回复文字。文件缺失或格式不对时，会在同一个会话里提醒 agent 补写，最多 2 次，仍不对则判定该步骤失败。
 
-**等待与超时**：每步有总时限（`stepTimeoutMinutes`）。到时 agent 还在做时，先再给它同样长的时间（`selfHeal`，见下）；仍未完成才判定失败，但不停止 agent。继续（`--resume`、自动重试）时先看这一步上一次的 agent：已经做完、结果文件有效就直接用它的结果；还在做就接着等它一轮（这一轮不再额外延长）；第二次仍超时才停止它、另起一个 agent。需求改过、开始了新一次尝试时，上一次留下的 agent 直接停掉，不接手（1.12.1）。同一步不会有两个 agent 同时在做（它们会改同样的文件、在同一个工作区提交、写同一个结果文件）。连续读不到 agent 状态时同样处理。等待被拆成每段 10 分钟（打开 `scanGuard` 时每段 1 分钟，以便查看正在运行的命令），连接断开时自动重试。agent 等待权限批准时，同一个请求只通知一次，然后继续等待。
+**等待与超时**：每步有总时限（`stepTimeoutMinutes`）。到时 agent 还在做时，先再给它同样长的时间（`selfHeal`，见下）；仍未完成才判定失败，但不停止 agent。继续（`--resume`、自动重试）时先看这一步上一次的 agent：已经做完、结果文件有效就直接用它的结果；还在做就接着等它一轮（这一轮不再额外延长）；第二次仍超时才停止它、另起一个 agent。需求改过、开始了新一次尝试时，上一次留下的 agent 直接停掉，不接手（1.12.1）。同一步不会有两个 agent 同时在做（它们会改同样的文件、在同一个工作区提交、写同一个结果文件）。连续读不到 agent 状态时同样处理。等待被拆成每段 10 分钟（打开 `scanGuard` 时每段 1 分钟、打开 `dangerGuard` 时每段 15 秒，以便查看正在运行的命令；只是读取状态，不占模型 token），连接断开时自动重试。agent 等待权限批准时，同一个请求只通知一次，然后继续等待。
 
 **临时错误自动重试**：步骤因限流（429）、服务暂时不可用（502/503/504/529、overloaded）、网络中断等临时错误失败时，等待后用新的 agent 重做这一步，并告诉它工作区里可能留有上一次没做完的改动。默认最多重试 2 次，分别等 1 分钟和 5 分钟：
 
@@ -569,6 +569,22 @@ Paseo 自带的 `/paseo-advisor`、`/paseo-committee` 等编排 skill 也可以
 
 `paths`：另外不允许整个搜索的目录（例如共享盘）；`enabled: false` 关闭。
 
+**拦截危险命令**（1.14，`dangerGuard`，默认开）：步骤 agent 通常以免确认模式运行命令，"只做本地提交、不碰生产"以前只写在提示词里。现在步骤运行时，流水线每 15 秒看一次 agent 运行过和正在运行的命令（读 Paseo 的记录，不用模型）。下面这些会被处理：推送（`git push`，强推、删除远程分支单独标出）、改远程地址；发布制品（`npm publish`、`mvn deploy`、`gradle publish`、`docker push` 等）；改动集群和基础设施（`kubectl apply/delete/exec…`、`helm install/upgrade…`、`terraform apply/destroy`、`ansible-playbook`）；连接其他机器上的数据库（`mysql -h <带点的主机名或地址>` 等，`localhost` 和 docker compose 里的服务名如 `db` 不算）；登录或复制到其他机器（`ssh`、`scp`、`rsync`，`git@` 不算）；删除仓库以外的目录（`rm -rf ~`、`/`、`..`、仓库外的绝对路径，临时目录除外）；下载脚本直接执行（`curl … | sh`）；关机、格式化等系统级操作；以及命令里出现 `production` 中任何一项（生产环境的主机名、地址、库名）。还在运行的命令立即打断，告诉 agent 不要再做、把需要人做的写进产物；已经运行完的也会告诉它。每次都通知需求的对话（和外部通知的 `alert` 事件，`details.kind` 为 `danger`），记在状态文件的 `dangers` 里，并写进完成报告。这是按命令文字的检查，能拦住常见的情况，不是沙箱。
+
+```json
+"dangerGuard": { "enabled": true, "production": ["prod.example.com", "10.8.0."], "allow": ["^ssh test-box"] }
+```
+
+`production`：生产环境的标记（出现在命令或访问的地址里就拦），建议团队配置里写上；`allow`：放行的命令（正则表达式），例如测试机的登录；`enabled: false` 关闭。
+
+**密钥扫描**（1.14，`secretScan`，默认开）：每个改代码的步骤之后（和质量门一起），流水线检查本需求新增的内容：从这次尝试开始时的提交以来，每次提交加进来的行、还没提交的改动和新文件。常见格式的密钥（私钥、AWS、GitHub、GitLab、Slack、模型服务的 API 密钥、JWT、地址里带的口令）在任何文件里都算；`password = "…"`、`token: …` 这样的赋值只在代码和配置里算，测试和文档不算，值是占位符（`${…}`、`<your-token>`、`changeme`）或从环境变量读取的也不算。发现了就交回这一步的 agent：改成从配置或环境变量读取；已经写进本需求提交的，用 `git commit --fixup` 和非交互的 `git rebase --autosquash` 从这些还没推送的提交里去掉；确实不是密钥的，在那一行加注释 `req-kit:allow-secret`。最多要求 `qualityGate.fixAttempts` 次，仍有的通知需求的对话、写进代码评审和完成报告；配置了 `push` 的需求**不会推送**有疑似密钥的分支。
+
+```json
+"secretScan": { "enabled": true, "allow": ["test/fixtures/**"] }
+```
+
+`allow`：不扫描的文件（路径或通配符）；`enabled: false` 关闭。
+
 **同一个目录一次只运行一条流水线**，因为各步骤都在这个目录中修改和提交。需要并行时，为每个需求使用单独的 worktree 工作区。
 
 ## 注意事项

package/engine/prompts/00-shared-context.md

@@ -78,12 +78,13 @@ time	step	ref	decision	alternatives	reason	kind	needs_human
 - 所有改动都提交到这个分支。不要切换分支，也不要新建分支；发现当前分支不是工作分支时，不要提交，直接结束本步骤并在最后的回复中说明。
 - 工作分支写着"不是 git 仓库"时，跳过所有 git 操作。
 - 你的工作结束时提交一次（实现类步骤可以按任务多次提交）。只暂存你这一步改动或新建的文件，不要用 `git add -A` 把别人的未提交改动带进来。`.pipeline/` 目录不提交。
-- 只做本地提交。不 push，不合并，不改写历史，不动其他分支。合并上线由人来决定。
+- 只做本地提交。不 push，不合并，不改写历史（流水线要求你从本需求还没推送的提交里去掉密钥时除外），不动其他分支。合并上线由人来决定。
 
 **这是一台真实的机器，没有人在旁边。**
 - 不操作仓库以外的文件，不做全局安装，不修改系统配置。
 - 不连接生产环境，不使用生产凭据，不触发真实的对外动作（发邮件、发短信、扣款、调用会产生费用或影响真实用户的外部接口）。需要时使用项目自带的测试替身或本地环境。
-- 不把密钥、口令、个人信息写进任何文件或提交。
+- 不把密钥、口令、个人信息写进任何文件或提交。流水线会扫描本需求新增的内容，发现了会要求你去掉。
+- 不发布制品（npm publish、mvn deploy、docker push），不改动集群和基础设施（kubectl、helm、terraform），不登录其他机器，不删除仓库以外的目录，不下载脚本直接执行。流水线会打断这类命令并通知用户；需要做的写进产物的"需要人处理"。
 - 启动的进程在本步骤结束前关掉。
 
 **如实报告。** 最终读者没有能力核对你的结论，他们会直接相信你写的内容。

package/engine/src/activity.ts

@@ -108,3 +108,24 @@ export function runningToolOf(entries: TimelineEntry[]): import("./scan-guard.js
   const text = Array.isArray(raw) ? raw.join(" ") : String(raw ?? "");
   return { kind, text, startedAt: call.first, callId };
 }
+
+/**
+ * 1.14: the tool calls at the end of the timeline (for the danger guard), oldest first: each
+ * call's latest status, its command (shell), pattern (search) or address (fetch), and when it started.
+ */
+export function toolCallsOf(entries: TimelineEntry[]): import("./danger-guard.js").ToolCall[] {
+  const calls = new Map<string, { first: string; last: Record<string, unknown> }>();
+  for (const entry of entries) {
+    const it = entry.item as Record<string, unknown> | null;
+    if (!it || typeof it !== "object" || it.type !== "tool_call" || typeof it.callId !== "string") continue;
+    const seen = calls.get(it.callId);
+    if (seen) seen.last = it;
+    else calls.set(it.callId, { first: entry.timestamp, last: it });
+  }
+  return [...calls.entries()].map(([callId, call]) => {
+    const detail = (call.last.detail ?? {}) as Record<string, unknown>;
+    const kind = String(detail.type ?? "unknown");
+    const raw = kind === "shell" ? detail.command : kind === "search" ? detail.query : kind === "fetch" ? detail.url : (detail.command ?? "");
+    return { callId, kind, text: Array.isArray(raw) ? raw.join(" ") : String(raw ?? ""), status: String(call.last.status ?? ""), startedAt: call.first };
+  });
+}

package/engine/src/api.ts

@@ -29,8 +29,10 @@ import { pruneIndex, readIndex, registerRequirement, requirementKey } from "./re
 import { listWorktreeRecords } from "./worktree.js";
 import { readHumanReview } from "./code-review.js";
 import { isAlive, type PipelineState, readState, statePath, type StepRecord } from "./state.js";
+import { notStartedNotice } from "./messages.js";
+import { scanOutcomes } from "./outcomes.js";
 import { parsePeriod, summarizeRuns } from "./stats.js";
-import { readRuns, runsFile } from "./records.js";
+import { readEvents, readRuns, runsFile } from "./records.js";
 import { totals } from "./usage.js";
 
 export const API_SCHEMA = 1;
@@ -242,13 +244,14 @@ function waitingOf(repo: string, featureDir: string, state: PipelineState | null
 export function apiList(input: { repo: string; all: boolean }): ListItem[] {
   if (!input.all) {
     const repo = fs.realpathSync(input.repo);
-    return listFeatures(repo)
+    const items = listFeatures(repo)
       .map((f) => {
         const state = readStateSafe(f.worktree, f.featureDir);
         const source = state?.worktree?.sourceRepo ?? null;
         return item(f.worktree, f.branch, f.featureDir, { sourceRepo: source, workspaceId: state?.worktree?.workspaceId ?? null, project: path.basename(source ?? repo) });
       })
       .filter((x): x is ListItem => x !== null);
+    return onePerRequirement(items);
   }
   const out: ListItem[] = [];
   const index = readIndex();
@@ -301,7 +304,21 @@ export function apiList(input: { repo: string; all: boolean }): ListItem[] {
       }
     }
   }
-  return out.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+  return onePerRequirement(out).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}
+
+/**
+ * 1.14: a requirement found in two places (the main checkout still has its spec, its own worktree
+ * has the run) is listed once: the copy that runs, else the one with a run state, else the latest.
+ */
+export function onePerRequirement(items: ListItem[]): ListItem[] {
+  const rank = (x: ListItem) => (x.running ? 3 : 0) + (x.status ? 2 : 0) + (x.present === false ? -4 : 0);
+  const best = new Map<string, ListItem>();
+  for (const x of items) {
+    const b = best.get(x.key);
+    if (!b || rank(x) > rank(b) || (rank(x) === rank(b) && x.updatedAt > b.updatedAt)) best.set(x.key, x);
+  }
+  return items.filter((x) => best.get(x.key) === x);
 }
 
 function samePathSafe(a: string, b: string): boolean {
@@ -547,7 +564,9 @@ export function apiMain(argvIn: string[], cwd = process.cwd()): unknown {
     case "stats": {
       const since = option(argv, "--since");
       const month = option(argv, "--month");
-      return summarizeRuns(readRuns(runsFile()), parsePeriod({ since, month }));
+      // 1.14: merges and post-merge problems this machine can see, then runs and events.
+      scanOutcomes();
+      return summarizeRuns(readRuns(runsFile()), parsePeriod({ since, month }), readEvents(runsFile()));
     }
     case "index": {
       const prune = flag(argv, "--prune");
@@ -582,7 +601,13 @@ export function apiMain(argvIn: string[], cwd = process.cwd()): unknown {
       const by = (option(argv, "--by") ?? "manual") as "plugin" | "factory" | "manual";
       const dryRun = flag(argv, "--dry-run");
       return import("./watchdog.js").then(({ watchdogPass }) =>
-        watchdogPass({ by: ["plugin", "factory"].includes(by) ? by : "manual", dryRun, resume: (r, f) => apiRun("resume", r, f, []) }),
+        watchdogPass({
+          by: ["plugin", "factory"].includes(by) ? by : "manual",
+          dryRun,
+          resume: (r, f) => apiRun("resume", r, f, []),
+          // 1.14: a confirmed requirement nobody started: one reminder in its chat.
+          remind: (r, f) => apiRun("reply", r, f, ["--notice", notStartedNotice(f)]),
+        }),
       );
     }
     case "review-url": {

package/engine/src/code-review.ts

@@ -9,6 +9,7 @@ import path from "node:path";
 import { section } from "./checklist.js";
 import { ownersFor, readCodeowners } from "./codeowners.js";
 import { KIT_ROOT } from "./locations.js";
+import { appendEvent, requirementRef } from "./records.js";
 import { isAlive, readState, statePath } from "./state.js";
 import { readWorktreeRecord } from "./worktree.js";
 
@@ -398,6 +399,8 @@ export function recordHumanReview(repo: string, featureDir: string, sub: Submiss
   const committed = commitDocs(repo, touched, `docs(${path.basename(featureDir)}): 人工代码评审${sub.verdict === "approve" ? "通过" : "意见"}`);
   // A new review replaces the draft.
   fs.rmSync(path.join(humanDir(featureAbs), "draft.json"), { force: true });
+  // 1.14: the review also goes into the usage records, for req stats.
+  appendEvent({ kind: "review", at: review.at, requirement: requirementRef(repo, featureDir), review: { verdict: review.status, reviewer, items: items.length, head: review.head } });
   return { review, committed };
 }
 

package/engine/src/config-view.ts

@@ -127,6 +127,16 @@ const CATALOG: Array<{ id: string; title: string; description: string; keys: Rec
         description: "步骤 agent 搜索整个磁盘、用户目录、Maven 仓库（.m2）、全局 node_modules 等很大的目录时，一分钟后打断它并告诉它该怎么查；任何搜索运行太久也打断。",
         display: (v) => { const g = v as PipelineConfig["scanGuard"]; return g.enabled ? `开，搜索超过 ${g.minutes} 分钟也打断${g.paths.length ? `；另外不许整个搜索：${g.paths.join("、")}` : ""}` : "关"; },
       },
+      dangerGuard: {
+        label: "拦截危险命令",
+        description: "步骤 agent 推送代码、发布制品、改动集群、连接其他机器上的数据库或主机、删除仓库以外的目录、下载脚本直接执行，或命令里出现生产环境的地址时，打断它并通知你。",
+        display: (v) => { const g = v as PipelineConfig["dangerGuard"]; return g.enabled ? `开${g.production.length ? `；生产环境标记 ${g.production.length} 个` : ""}${g.allow.length ? `；放行 ${g.allow.length} 条` : ""}` : "关"; },
+      },
+      secretScan: {
+        label: "密钥扫描",
+        description: "每次改代码的步骤之后、推送分支之前，检查本需求新增的内容里有没有密钥、令牌、口令；发现了让 agent 去掉，去不掉就不推送。",
+        display: (v) => { const g = v as PipelineConfig["secretScan"]; return g.enabled ? `开${g.allow.length ? `；不扫描：${g.allow.join("、")}` : ""}` : "关"; },
+      },
     },
   },
   {

package/engine/src/config.ts

@@ -251,6 +251,15 @@ export interface PipelineConfig {
    * and tell it how to find what it needs instead. `paths`: more directories never to search whole.
    */
   scanGuard: import("./scan-guard.js").ScanGuardSettings;
+  /**
+   * 1.14: stop a step agent's dangerous commands (push, publish, cluster changes, remote databases
+   * and hosts, deleting outside the repository, downloaded scripts) and tell the person.
+   * `production`: text that marks production systems (host names, addresses); `allow`: regular
+   * expressions of commands that are allowed after all.
+   */
+  dangerGuard: import("./danger-guard.js").DangerGuardSettings;
+  /** 1.14: look for keys, tokens and passwords in what the requirement added (quality gate, before push). `allow`: files never scanned. */
+  secretScan: import("./secret-scan.js").SecretScanSettings;
   /** Automatic retries of a step after a transient error (rate limit, dropped connection). */
   retry: { attempts: number; backoffSeconds: number[] };
   /**
@@ -362,6 +371,8 @@ export const DEFAULT_CONFIG: PipelineConfig = {
   autoConfirm: { hours: 0 },
   budget: { tokens: null, warnPercent: 80 },
   scanGuard: { enabled: true, minutes: 5, paths: [] },
+  dangerGuard: { enabled: true, production: [], allow: [] },
+  secretScan: { enabled: true, allow: [] },
   retry: { attempts: 2, backoffSeconds: [60, 300] },
   paseoServices: "auto",
   serviceReadySeconds: 120,
@@ -432,6 +443,8 @@ function merge(base: PipelineConfig, raw: Record<string, unknown>): PipelineConf
   merged.autoConfirm = { ...base.autoConfirm, ...(isRecord(raw.autoConfirm) ? raw.autoConfirm : {}) } as PipelineConfig["autoConfirm"];
   merged.budget = { ...base.budget, ...(isRecord(raw.budget) ? raw.budget : {}) } as PipelineConfig["budget"];
   merged.scanGuard = { ...base.scanGuard, ...(isRecord(raw.scanGuard) ? raw.scanGuard : {}) } as PipelineConfig["scanGuard"];
+  merged.dangerGuard = { ...base.dangerGuard, ...(isRecord(raw.dangerGuard) ? raw.dangerGuard : {}) } as PipelineConfig["dangerGuard"];
+  merged.secretScan = { ...base.secretScan, ...(isRecord(raw.secretScan) ? raw.secretScan : {}) } as PipelineConfig["secretScan"];
   if (isRecord(raw.cardSource)) {
     const c = raw.cardSource;
     merged.cardSource = {
@@ -657,6 +670,20 @@ function validate(config: PipelineConfig): void {
   if (typeof sg.enabled !== "boolean") throw new ConfigError("scanGuard.enabled 必须是 true 或 false");
   if (typeof sg.minutes !== "number" || !(sg.minutes >= 1)) throw new ConfigError("scanGuard.minutes 必须是至少 1 的分钟数（搜索运行多久后打断）");
   if (!Array.isArray(sg.paths) || !sg.paths.every((p) => typeof p === "string" && p.trim())) throw new ConfigError('scanGuard.paths 必须是目录路径的数组，例如 ["D:/share"]');
+  const dg = config.dangerGuard;
+  if (typeof dg.enabled !== "boolean") throw new ConfigError("dangerGuard.enabled 必须是 true 或 false");
+  if (!Array.isArray(dg.production) || !dg.production.every((p) => typeof p === "string" && p.trim())) throw new ConfigError('dangerGuard.production 必须是字符串数组（生产环境的主机名、地址等），例如 ["prod.example.com"]');
+  if (!Array.isArray(dg.allow) || !dg.allow.every((p) => typeof p === "string" && p.trim())) throw new ConfigError('dangerGuard.allow 必须是正则表达式字符串的数组，例如 ["^ssh test-box"]');
+  for (const a of dg.allow) {
+    try {
+      new RegExp(a);
+    } catch (error) {
+      throw new ConfigError(`dangerGuard.allow 里的「${a}」不是合法的正则表达式：${(error as Error).message}`);
+    }
+  }
+  const ss = config.secretScan;
+  if (typeof ss.enabled !== "boolean") throw new ConfigError("secretScan.enabled 必须是 true 或 false");
+  if (!Array.isArray(ss.allow) || !ss.allow.every((p) => typeof p === "string" && p.trim())) throw new ConfigError('secretScan.allow 必须是文件路径或通配符的数组，例如 ["test/fixtures/**"]');
   const f = config.factory;
   if (typeof f.pollMinutes !== "number" || !(f.pollMinutes >= 1)) throw new ConfigError("factory.pollMinutes 必须是至少 1 的分钟数");
   if (!Number.isInteger(f.maxNewPerPoll) || f.maxNewPerPoll < 1) throw new ConfigError("factory.maxNewPerPoll 必须是正整数");

package/engine/src/danger-guard.ts

@@ -0,0 +1,180 @@
+// Stopping dangerous commands (1.14): step agents usually run commands without asking (the
+// provider's "no confirmation" mode), so the rules "only local commits, never touch production"
+// were only words in the prompt. While a step runs, the pipeline looks at the commands the agent
+// has run or is running (its Paseo timeline, every few seconds to a minute); a command that
+// pushes, publishes, changes a cluster, connects to a remote database or host, deletes outside
+// the repository, runs a downloaded script, or mentions a configured production address is
+// interrupted (if still running) and reported to the person. A plain check of the command
+// text, no model; it catches the common cases, it is not a sandbox.
+import os from "node:os";
+import path from "node:path";
+
+export interface DangerGuardSettings {
+  enabled: boolean;
+  /** Text that marks a production system (host names, addresses, database names); any command containing it is stopped. */
+  production: string[];
+  /** Regular expressions of commands that are allowed after all (e.g. "^ssh test-box"). */
+  allow: string[];
+}
+
+export interface ToolCall {
+  callId: string;
+  kind: string;
+  text: string;
+  status: string;
+  startedAt: string;
+}
+
+export interface Danger {
+  /** What kind of operation it is, for the person (e.g. "推送到远程仓库"). */
+  label: string;
+  /** Why it is not allowed in a pipeline step. */
+  why: string;
+}
+
+const LOCAL_HOSTS = /^(localhost|127(\.\d+){3}|0\.0\.0\.0|::1|\[::1\]|host\.docker\.internal)$/i;
+
+/** Splits a command line into simple commands (on ; && || | and newlines), each a list of words without quotes. */
+export function segments(command: string): string[][] {
+  const out: string[][] = [];
+  for (const part of command.split(/\|\||&&|[;|\n]|\r/)) {
+    const words = (part.match(/"[^"]*"|'[^']*'|\S+/g) ?? []).map((w) => w.replace(/^["']|["']$/g, ""));
+    // Wrappers that run the rest as a command.
+    while (words.length && /^(sudo|env|nohup|time|exec|command|xargs|npx|cmd(\.exe)?|\/c|powershell(\.exe)?|pwsh|-Command|-c|bash|sh|zsh|-lc|-l)$/i.test(words[0])) words.shift();
+    while (words.length && /^\w+=/.test(words[0])) words.shift();
+    // A command given as one quoted argument (bash -lc "git push"): look inside it.
+    if (words.length && /\s/.test(words[0])) out.push(...segments(words.join(" ")));
+    else if (words.length) out.push(words);
+  }
+  return out;
+}
+
+const base = (w: string) => w.replace(/\\/g, "/").split("/").pop()!.replace(/\.(exe|cmd|bat)$/i, "").toLowerCase();
+
+function hostOf(value: string): string {
+  const v = value.replace(/^\w+:\/\//, "").replace(/^[^@/]*@/, "");
+  return v.replace(/[:/].*$/, "");
+}
+
+/** A host that is clearly another machine: an address or a dotted name that is not this machine. Service names of docker compose ("db") count as local. */
+function remoteHost(host: string): boolean {
+  if (!host || LOCAL_HOSTS.test(host)) return false;
+  return /\./.test(host) || /^\d+(\.\d+){3}$/.test(host);
+}
+
+function deletesOutside(words: string[], repo: string | null, home: string): string | null {
+  const targets = words.slice(1).filter((w) => !w.startsWith("-") && !/^\/[a-z]$/i.test(w));
+  const h = home.replace(/\\/g, "/").replace(/\/+$/, "");
+  for (const raw of targets) {
+    const t = raw.replace(/\\/g, "/").replace(/\/+$/, "") || "/";
+    if (/^(\/|\/\*|~|~\/\*|\$HOME|\$\{HOME\}|%USERPROFILE%|\$env:USERPROFILE|[a-z]:|[a-z]:\/\*|\.\.(\/\.\.)*(\/\*)?|\*|\/\*\.\*)$/i.test(t)) return raw;
+    if (t === h) return raw;
+    if (/^(\/|[a-z]:\/)/i.test(t)) {
+      const abs = path.resolve(t);
+      const inside = (dir: string | null) => !!dir && (abs === path.resolve(dir) || abs.startsWith(path.resolve(dir) + path.sep));
+      if (!inside(repo) && !inside(os.tmpdir()) && !/^\/(tmp|var\/tmp)(\/|$)/.test(t)) return raw;
+    }
+  }
+  return null;
+}
+
+function judgeSegment(words: string[], repo: string | null, home: string): Danger | null {
+  const cmd = base(words[0]);
+  const rest = words.slice(1);
+  const sub = rest.find((w) => !w.startsWith("-"))?.toLowerCase() ?? "";
+  const has = (re: RegExp) => rest.some((w) => re.test(w));
+
+  if (cmd === "git") {
+    // Skip global options (-C dir, -c k=v) to find the git command.
+    let i = 0;
+    while (i < rest.length && rest[i].startsWith("-")) i += /^-[Cc]$/.test(rest[i]) ? 2 : 1;
+    const g = rest[i]?.toLowerCase();
+    const args = rest.slice(i + 1);
+    if (g === "push") {
+      const force = args.some((w) => /^(--force|--force-with-lease|-f|--mirror|--delete|-d)$/.test(w) || /^\+/.test(w) || /^--force-with-lease=/.test(w) || /^:/.test(w));
+      return force
+        ? { label: "强制推送或删除远程分支", why: "会改写或删除远程仓库的历史，别人的提交可能丢失" }
+        : { label: "推送到远程仓库", why: "流水线只做本地提交，推送和合并由人决定（接单器模式由流水线自己推送需求分支）" };
+    }
+    if (g === "remote" && /^(add|set-url|remove|rm)$/.test(args[0] ?? "")) return { label: "修改远程仓库地址", why: "会改变代码推送到哪里" };
+    return null;
+  }
+  if (cmd === "rm" && rest.some((w) => /^-[a-z]*r/i.test(w) || w === "--recursive")) {
+    const t = deletesOutside(words, repo, home);
+    if (t) return { label: `删除仓库以外的目录（${t}）`, why: "会删除仓库以外的文件，无法恢复" };
+  }
+  if (/^(remove-item|ri|rd|rmdir|del|erase)$/.test(cmd) && has(/^(-recurse|-r|\/s)$/i)) {
+    const t = deletesOutside(words.filter((w) => !/^-(recurse|force|r)$/i.test(w) && !/^\/[sq]$/i.test(w)), repo, home);
+    if (t) return { label: `删除仓库以外的目录（${t}）`, why: "会删除仓库以外的文件，无法恢复" };
+  }
+  if (/^(npm|pnpm|yarn|cargo|gem|twine|poetry|flit)$/.test(cmd) && (sub === "publish" || (sub === "npm" && rest[1] === "publish") || (cmd === "gem" && sub === "push") || (cmd === "twine" && sub === "upload")))
+    return { label: "发布包到制品仓库", why: "发布出去的版本别人马上能用到，撤不回来" };
+  if (/^(mvn|mvnw)$/.test(cmd) && has(/^(deploy|release:perform|deploy:deploy(-file)?)$/)) return { label: "发布制品（mvn deploy）", why: "发布出去的版本别人马上能用到，撤不回来" };
+  if (/^(gradle|gradlew)$/.test(cmd) && has(/^(publish\w*|uploadArchives)$/)) return { label: "发布制品（gradle publish）", why: "发布出去的版本别人马上能用到，撤不回来" };
+  if (cmd === "docker" && sub === "push") return { label: "推送镜像到镜像仓库", why: "镜像仓库是共享的，部署可能直接用到" };
+  if (cmd === "docker" && sub === "login") return { label: "登录镜像仓库", why: "会在这台机器上保存镜像仓库的凭据" };
+  if (cmd === "dotnet" && sub === "nuget" && rest[1] === "push") return { label: "发布包到制品仓库", why: "发布出去的版本别人马上能用到，撤不回来" };
+  if (/^(kubectl|oc)$/.test(cmd) && /^(apply|create|delete|replace|patch|scale|rollout|edit|drain|cordon|exec|cp|set|label|annotate|run)$/.test(sub))
+    return { label: "修改集群（kubectl）", why: "会改动共享的环境，流水线只在本地或测试环境验证" };
+  if (cmd === "helm" && /^(install|upgrade|uninstall|delete|rollback)$/.test(sub)) return { label: "修改集群（helm）", why: "会改动共享的环境，流水线只在本地或测试环境验证" };
+  if (cmd === "terraform" && /^(apply|destroy|import|taint)$/.test(sub)) return { label: "修改基础设施（terraform）", why: "会改动共享的环境，流水线只在本地或测试环境验证" };
+  if (cmd === "ansible-playbook" || (cmd === "ansible" && !has(/^(--check|-C)$/))) return { label: "在服务器上执行（ansible）", why: "会改动其他机器" };
+  if (/^(mysql|mysqldump|psql|pg_dump|mongo|mongosh|redis-cli|sqlcmd|sqlplus|clickhouse-client|clickhouse)$/.test(cmd)) {
+    for (let i = 0; i < rest.length; i++) {
+      const w = rest[i];
+      let host: string | null = null;
+      const m = /^(-h|--host|-H|-S|--server)(=?)(.*)$/.exec(w);
+      if (m) host = m[3] || rest[i + 1] || "";
+      else if (/^\w+:\/\//.test(w)) host = hostOf(w);
+      else if (cmd === "sqlplus" && /@/.test(w)) host = hostOf(w.split("@").pop() ?? "");
+      if (host !== null && remoteHost(host.replace(/,\d+$/, ""))) return { label: `连接其他机器上的数据库（${host}）`, why: "可能是共享或生产的数据库；流水线只用本机或测试用的数据库" };
+    }
+  }
+  if (/^(ssh|scp|sftp|rsync)$/.test(cmd)) {
+    const target = rest.find((w) => !w.startsWith("-") && (cmd === "ssh" || cmd === "sftp" || /:/.test(w)));
+    if (target && !/^git@/.test(target)) {
+      const host = cmd === "ssh" || cmd === "sftp" ? hostOf(target) : hostOf(target.split(":")[0]);
+      if (host && !LOCAL_HOSTS.test(host)) return { label: `登录或复制文件到其他机器（${host}）`, why: "会改动其他机器；流水线只在本地或测试环境验证" };
+    }
+  }
+  if (/^(shutdown|reboot|halt|poweroff|mkfs|diskpart|format|stop-computer|restart-computer)$/.test(cmd) || /^mkfs\./.test(cmd)) return { label: "系统级操作", why: "会影响整台机器" };
+  if (cmd === "dd" && has(/^of=\/dev\//)) return { label: "直接写磁盘", why: "会破坏磁盘上的数据" };
+  if (/^(chmod|chown)$/.test(cmd) && has(/^-R$/) && rest.some((w) => /^(\/|~|\$HOME)\/?$/.test(w))) return { label: "修改整个系统的权限", why: "会影响整台机器" };
+  return null;
+}
+
+/** Whether a command (or a fetched address) is one a pipeline step must not run, and why. */
+export function dangerOf(text: string, settings: Pick<DangerGuardSettings, "production" | "allow">, options: { repo?: string | null; home?: string } = {}): Danger | null {
+  if (!text.trim()) return null;
+  for (const a of settings.allow) {
+    try {
+      if (new RegExp(a, "i").test(text)) return null;
+    } catch {
+      /* validated with the configuration */
+    }
+  }
+  const lower = text.toLowerCase();
+  for (const p of settings.production) {
+    if (p.trim() && lower.includes(p.trim().toLowerCase())) return { label: `访问生产环境（${p.trim()}）`, why: "流水线不连接生产环境、不使用生产凭据" };
+  }
+  if (/\b(curl|wget)\b[^|]*\|\s*(sudo\s+)?(ba|z|da)?sh\b/i.test(text) || /\b(iwr|irm|invoke-webrequest|invoke-restmethod)\b[^|]*\|\s*(iex|invoke-expression)\b/i.test(text))
+    return { label: "下载脚本直接执行", why: "执行的内容没有经过检查" };
+  const home = options.home ?? os.homedir();
+  for (const words of segments(text)) {
+    const d = judgeSegment(words, options.repo ?? null, home);
+    if (d) return d;
+  }
+  return null;
+}
+
+/** What the agent is told when the command is stopped (or was found after it ran). */
+export function dangerMessage(command: string, danger: Danger, ran: boolean): string {
+  const one = command.replace(/\s+/g, " ").trim();
+  const clip = one.length > 160 ? `${one.slice(0, 159)}…` : one;
+  return [
+    `【流水线提示】${ran ? "你刚才运行了" : "已停止你正在运行的"}命令「${clip}」：这是${danger.label}，${danger.why}。需求开发流水线里不允许这类操作，用户已收到通知。`,
+    "- 不要再运行这条命令，也不要换一种写法做同样的事。",
+    `- ${ran ? "如果它已经改动了仓库以外或远程的东西，不要自己试图撤销；" : ""}在本步骤产物里写一节\"风险操作\"：运行了什么、为什么、${ran ? "造成了什么影响" : "是否已经产生影响"}。`,
+    "- 然后继续完成本步骤的任务：需要推送、发布、部署或连接其他环境的，写进产物的\"需要人处理\"，由人来做。",
+  ].join("\n");
+}

package/engine/src/features.ts

@@ -83,7 +83,7 @@ interface RawState {
  * Files only the pipeline writes: their presence means it ran, even where its state is not (a
  * copy merged into the main branch: the state file under .pipeline/ is never committed).
  */
-const PIPELINE_OUTPUTS = ["design.md", "assessment.md", "diagnosis.md", "implementation.md", "handoff.md", "verification.md", "report.md"];
+export const PIPELINE_OUTPUTS = ["design.md", "assessment.md", "diagnosis.md", "implementation.md", "handoff.md", "verification.md", "report.md"];
 
 export function developedIn(dir: string): boolean {
   return PIPELINE_OUTPUTS.some((f) => fs.existsSync(path.join(dir, f)));