paseo-req-kit 1.13.0-beta.2 → 1.13.0-beta.4

package/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 每个版本分为"使用者会看到的变化"和"升级须知"。升级步骤见 [docs/guide/安装与升级.md](docs/guide/安装与升级.md)。
 
+## 1.13.0-beta.4
+
+### 使用者会看到的变化
+
+- **token 花在哪**：`req stats` 和插件的"使用统计"页新增一节，按步骤、按模型列出 token（输入 + 输出）和占比，单独算出返工（方案修订、评审问题修复、缺陷修复、复验，以及第 2 轮起的审核和评审）占了多少、输入中多少来自提示缓存、每个完成需求的中位数。每一步用的模型从这个版本开始记录。
+- **token 预算**（可选，`budget.tokens`）：用到 `budget.warnPercent`（默认 80%）时在对话里告知一次；用完时已完成的步骤保留，在下一步开始前停下，问需求方是否继续，继续会再给一份预算。
+- **还要多久**：本机已完成 3 个以上同档位需求后，开始开发时给出这类需求通常的 agent 用时和 token；`req status` 和插件的需求页面显示"预计还要约多久"。
+- **后台进程意外退出时直接继续，不再叫醒对话**：装了插件时，插件每 5 分钟在 daemon 里检查一次，发现"运行中但后台进程已不在"的需求就直接继续（`req resume`），不经过模型；这时流水线不再预约对话每小时一次的定时检查，省下这部分 token。接单器也改为直接继续。
+- **等待批准权限进"等你处理"**：步骤 agent 在等你允许一项操作时，插件的"等你处理"列出要批准的操作，点"打开这个 agent"去处理。
+
+### 升级须知
+
+- 新配置 `budget`（默认不限）。用 `req stats` 看过"每个完成需求的中位数"后，可以按它的两三倍设置。
+- 停下原因新增 `budget`；状态文件新增 `budget`、`waitingPermission`；使用记录的步骤新增 `cachedInputTokens`、`agent`；`req api` 新增 `watchdog`，`status` 新增 `estimate`，`attention` 新增 `permission`。
+- 插件设为只读时不做自动继续。
+- CI 新增 Windows 任务（暂时只报告结果，不阻断发布）。
+
+## 1.13.0-beta.3
+
+### 使用者会看到的变化
+
+- **原型审查页在 Paseo 里打开**：网页端和桌面端不再跳到单独的浏览器窗口，审查页嵌在插件的"审查原型"页面中；手机上仍在浏览器中打开，页面右上角也可以"在新窗口打开"。
+- **按钮更醒目**："等你处理"和需求页面最上面，有原型的方案确认显示为主按钮"审查原型并确认方案"（"确认方案"变为次要按钮）；没在等确认时也有"审查原型"按钮。请你确认方案的对话消息也会告诉你去点这个按钮。
+
+### 升级须知
+
+- 审查页现在允许被本机地址上的页面嵌入（`frame-ancestors`）；从别的电脑访问时（设了 `REQ_KIT_REVIEW_HOST`）允许任何页面嵌入，地址中的令牌仍是访问的唯一凭证。可以用 `REQ_KIT_REVIEW_FRAME_ANCESTORS` 指定。
+
 ## 1.13.0-beta.2
 
 在 Paseo 网页端审查原型，界面验证不再依赖桌面端和模型的视觉能力。见 [ADR 0033](docs/adr/0033-prototype-review-and-ui-check.md)。

package/contracts/cli-json.md

@@ -31,6 +31,7 @@
 | `req api models` | 1.12 起。`{ current, choices, recommended }`：本机配置中现在的 `agents`；daemon 上能无人值守运行的选择（`{ id, label, provider, profile }`，Paseo profile 在前）；按推荐的 `agents`。连不上 daemon 时报错 |
 | `req api config [--repo <目录>] [--machine]` | 1.12 起。`{ sources, ignored, error, repo, groups }`：`sources` 是生效的配置文件（`layer` 为 `machine` / `team` / `project`，按叠加顺序）；`groups` 按主题分组，每项 `{ key, label, description, display, value, setBy, scope, changed }`：`display` 是用大白话写的值，`value` 中看起来像密钥的值和个人账号替换为 `••••`，`setBy` 是写了它的文件，`changed` 表示与默认值不同。配置有错误时 `error` 写明原因，值按各文件所写。`--machine` 不看项目配置 |
 | `req api set-agents --json <设置>` | 1.12 起。`{ ok, message }`。`<设置>` 是 `{ builder, reviewer, fallback }`（`fallback` 可以为 null），检查后写入本机配置的 `agents`，原文件备份 |
+| `req api watchdog [--by plugin\|factory] [--dry-run]` | 1.13 起。`{ checked, resumed, failed, skipped }`：把本机"运行中但后台进程已不在"的需求直接继续（`req resume`）。每个进程只继续一次，每个需求 24 小时内最多 3 次；`--by plugin` 同时记下插件在检查（流水线据此不再预约对话的定时检查） |
 | `req api review-url <需求> [--repo <目录>] [--read-only]` | 1.13 起。`{ url, readOnly }`：这个需求的原型审查页地址（需要时在后台启动审查页的服务）。`--read-only` 的地址只能看，不能提交意见或确认方案。需求不在本机的需求索引中或还没有 `prototype/` 时报 `not_found` |
 
 `<需求>` 的写法与 `req status` 相同：功能目录、目录名或名称中能唯一确定的一部分。需求在为它新建的工作区中开发时，`--repo` 写对话所在的目录或那个工作区都可以。
@@ -51,7 +52,7 @@
 | `status` | 状态文件的 `status`；还没运行过为 null |
 | `running` | 后台进程是否在运行 |
 | `phase` | `develop` / `verify` |
-| `attention` | 需要人处理的事：`approval`（确认方案）、`business`（需求方决定）、`interrupted`（中断，可以继续）、`not_completed`（结束但未完成）；没有为 null |
+| `attention` | 需要人处理的事：`approval`（确认方案）、`business`（需求方决定）、`permission`（1.13，步骤在等权限批准；`waiting.questions` 是要批准的操作，`waiting.agentId` 是那个 agent）、`interrupted`（中断，可以继续）、`not_completed`（结束但未完成）；没有为 null |
 | `waiting` | 1.12 起。`attention` 不为 null 时：`since`（从什么时候开始等）、`questions`（需求方要回答的问题）、`reason`（停止原因）、`card`（`{ system, id, url, requester }`，从卡片开始的需求）、`canReply`（能否用 `req api run reply <需求> <回复>` 把回复转给需求的对话）；否则为 null |
 | `current` | 正在运行的步骤 `[{ key, title, agentId }]` |
 | `updatedAt` | 最近一次变化的时间 |
@@ -69,5 +70,6 @@
 | `run` | `{ attempt, startedAt, updatedAt, pid, phaseMode, stopReason, outcome, queuedSince, verifyAt, approval, originAgentId }`；没运行过为 null |
 | `steps` | 每个步骤一项：`{ key, stepId, title, phase, attempt, round, agentId, startedAt, endedAt, minutes, outcome, result, error, usage }`；`title` 是给人看的名称（如"代码评审（第 2 轮）"），`result` 是结论的文字（如"需要修改"） |
 | `gate` | 质量门：状态文件中的 `gate` |
+| `estimate` | 1.13 起。`{ basis, profile, typicalAgentMinutes, typicalTokens, usedAgentMinutes, usedTokens, leftMinutes, over }`：按本机已完成的同档位需求（至少 3 个）的中位数估算；数据不够或已完成时为 null |
 | `joint` | 联合需求的其他仓库：`[{ name, slug, repo, sourceRepo, branch, workspaceId, gate }]` |
 | `external` | 外部系统中的卡片（1.9.0 起）：`[{ name, id, url, status, syncedAt, pending, lastError }]`；`pending` 是等待补发的调用数 |

package/contracts/state.md

@@ -18,7 +18,9 @@
 | `results` | object | 已完成步骤的结果，键为步骤键（如 `code_review-r2`） |
 | `history` | array | 每次步骤执行的记录：agent、起止时间、结果、错误；`usage`（可选，1.3.0 起）为 agent 报告的用量：`inputTokens`、`cachedInputTokens`、`outputTokens`、`totalCostUsd`，agent 没有报告时为 null 或缺少；`leftRunning`（可选，1.11 起）为 true 表示失败时 agent 可能还在运行，下一次运行这一步时先看它；`reattached`（可选，1.11 起）为接着等上一次 agent 的次数 |
 | `stopReason` / `outcome` | string \| null | 停止原因；最终结论 |
-| `stopKind` | string \| null | 可选，1.12 起。停下等人的原因代码：必要的决定 `approval`（确认方案）、`phase_gate`（研发完成，等待测试）、`business`（需求方决定）、`reproduce`（缺陷复现不了）；中断 `timeout`、`agent_error`、`invalid_result`、`transient`、`stopped`、`process_exit`、`other`。运行中或完成时为 null |
+| `stopKind` | string \| null | 可选，1.12 起。停下等人的原因代码：必要的决定 `approval`（确认方案）、`phase_gate`（研发完成，等待测试）、`business`（需求方决定）、`reproduce`（缺陷复现不了）；中断 `timeout`、`agent_error`、`invalid_result`、`transient`、`stopped`、`process_exit`、`budget`（1.13，用完 token 预算）、`other`。运行中或完成时为 null |
+| `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 自答）、`detail` |
 | `profile` | `quick` \| `standard` | 档位 |
 | `branch` | string \| null | 工作分支，启动时确定 |

package/contracts/usage-record.md

@@ -30,6 +30,7 @@
 | `schema` / `kind` | `1` / `"run"` |
 | `machine` / `kitVersion` | 主机名、req-kit 版本 |
 | `requirement` | `{ key, project, name, title, type, profile }`；从卡片开始的需求（1.10 起）另有 `requester`（卡片的提出人）和 `source`（`{ system, id }`） |
+| `steps[].cachedInputTokens` / `steps[].agent` | 1.13 起。输入中来自提示缓存的 tokens（agent 报告时）；这一步用的 agent（Paseo profile 名，或 "provider/model"）。更早的记录没有 |
 | `run` | `{ startedAt, endedAt, attempt, phase, phaseMode, status, outcome, stopReason, stopKind, recoveries }`；`status` 是运行结束时的状态，`outcome` 是完成时报告的结论；`stopKind`（1.12 起）是停下等人的原因代码（见 [state.md](state.md)），`recoveries`（1.12 起）是这次运行中自动处理的次数，按种类，如 `{ "retry": 2 }`。更早的记录没有这两项 |
 | `agents` | `{ builder, reviewer }`：当时配置的 agent（如 `claude/opus（bypassPermissions）`） |
 | `steps` | 这次运行中开始的步骤：`{ key, stepId, phase, attempt, round, startedAt, endedAt, minutes, outcome, inputTokens, outputTokens, costUsd }`；agent 没有报告的用量为 null |
@@ -43,6 +44,7 @@
 - 交付周期：需求第一次开始到完成（最后一次运行以"已完成"结束）的小时数，用这个需求的全部运行，算在完成的那段时间。
 - 代码评审轮数、缺陷修复轮数：不同的（尝试、轮次、仓库）个数；评审分方向或评审小组的几个成员算一轮。
 - 等待：相邻两次运行之间的间隔，按前一次结束时的状态归类：等待确认方案、等待需求方决定、研发完成到开始测试验证、中断到继续。
+- token 花在哪（1.13 起，`tokens`）：这段时间的步骤按 `stepId`、按 `agent` 合计 token（输入 + 输出）和占比；返工（`design_revise`、`review_fix`、`defect_fix`、`reverify`，以及 `design_review`、`code_review` 第 2 轮起）的合计和占比；报告了 `cachedInputTokens` 的，算出输入中来自提示缓存的比例；已完成需求的 token 中位数（按档位）。
 - 停下等人的原因（1.12 起）：这段时间结束的运行按 `stopKind` 计数；更早的记录按结束时的状态推断。确认方案、研发完成等待测试是必要的决定。
 - 无人工到提测的比例（1.12 起）：这段时间有进展、已经研发完成或完成的需求中，所有运行都只停在必要决定处的比例。
 - 自动处理的比例（1.12 起）：自动处理的次数 ÷（自动处理的次数 + 以中断结束的运行数）；需求方决定、缺陷复现不了不算中断。

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

@@ -64,7 +64,7 @@ req-kit 帮你把一个需求从"我想要……"做到"可以验收"：你在 P
 
 1.12 起，首页最上面是"等你处理"：所有等你确认方案、回答问题、中断了的需求，等得最久的在前，每条写明要做什么、等了多久。方案可以直接确认，也可以写修改意见；方案审核的问题可以直接写回答，插件会转给这个需求的对话，效果和在对话里回答一样。首页的"配置"列出 req-kit 的全部设置：每一项是什么、现在的值、来自本机、团队还是项目的配置文件，可以按项目查看、搜索、只看改过的。
 
-**在原型上提意见（1.13 起）。** 界面改动的需求，在请你确认方案时会有一份界面原型。在插件的需求页面或"等你处理"里点"打开原型审查页"（或在终端运行 `req review <需求>`），会在浏览器里打开它：
+**在原型上提意见（1.13 起）。** 界面改动的需求，在请你确认方案时会有一份界面原型。在插件首页的"等你处理"或需求页面最上面，点**"审查原型并确认方案"**按钮（终端里是 `req review <需求>`），原型审查页就在 Paseo 里打开（手机上会在浏览器中打开；嫌窗口小时点右上角"在新窗口打开"）：
 
 - 标着 ①②③ 的是这次要改的地方，右边写着各自对应的验收标准，顺着看就不会漏。
 - 想改哪里就**点哪里**，选一种改法（文字改成…、大一点、换颜色、换位置、删掉、这里加东西……），再用自己的话补一句。不用想专业词汇，你点的是哪个按钮、原来是什么颜色和大小，页面会自动记下来交给 AI。
@@ -72,13 +72,16 @@ req-kit 帮你把一个需求从"我想要……"做到"可以验收"：你在 P
 - 正常、出错、空数据这些状态，以及电脑、手机宽度，在页面上方切换。
 - 写的意见会自动保存。看完后点"提交修改意见"，需求会话会据此改需求说明，改好后请你再确认；改过的原型再打开时，会用绿色框标出这一版改了哪里。没有要改的，点"同意开始写代码"。
 
+**还要多久（1.13 起）。** 本机做完过 3 个以上同档位的需求后，开始开发时会告诉你这类需求通常要多久、用多少 token；问"做到哪了"或在插件的需求页面里，会看到"预计还要约多久"（不含等人确认的时间）。
+
 每个步骤都会出现在这个对话的子 agent 列表里（名字形如"[20261012-sms-login] 6-代码评审 第2轮"），点开可以看到它在做什么。功能目录下的 `progress.md` 按时间记录了每一步的结果。
 
 可能收到的通知（团队接入了企业 IM 的话，这些通知也会发到 IM）：
 
 - **需要你决定**：方案审核发现只有你能回答的问题。AI 会逐个问你，然后继续。一天没有回答的话，会在对话里提醒一次。
 - **研发完成，可以提测**（分阶段执行时）：代码已写完并通过评审，提测说明在 `handoff.md`。一天没有开始测试验证的话，会在对话里提醒一次。
-- **等待批准**：某一步在等权限批准，按提示打开对应的 agent 处理，或请开发同事处理。
+- **等待批准**：某一步在等权限批准，按提示打开对应的 agent 处理，或请开发同事处理。1.13 起插件的"等你处理"里也会显示，列出要批准的操作，点"打开这个 agent"直接去处理。
+- **token 用量提醒**（团队设了 token 预算时）：用到预算的一定比例时告知一次，开发照常进行；用完时做完当前步骤就停下，AI 会告诉你用了多少、问你是否继续。继续会再给一份预算。
 - **中断**：限流、网络中断这类临时问题会先自动等待重试，仍然不行才中断，并预约半小时后自动继续（说"先停一下"可以取消）。AI 会说明原因和日志位置。环境类问题（例如测试服务没启动）你可以自己处理；涉及配置或代码的请开发同事处理。处理后说"继续开发"。
 
 ## 验收

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

@@ -43,11 +43,11 @@ spec 头部的 `- 类型：` 决定流水线走哪种做法（1.8 起）。缺
 
 等待确认时进度显示"等待需求方确认方案"，需求总览归入"需要处理"，外部通知收到 `approval` 事件。评估类需求不写代码，不经过确认点。
 
-**原型审查页（1.13 起）。** 有 `prototype/` 的需求，插件的需求页面和"等你处理"里有"打开原型审查页"，终端里是 `req review <需求>`。需求方在原型上点选要改的地方（页面记下元素、文字、颜色、大小和位置）、双击直接改文字，切换状态和电脑、手机宽度，然后提交：意见整理成带位置信息的清单转给需求会话（与插件中写修改意见的效果相同），或者直接确认方案。草稿和提交记录在功能目录的 `.pipeline/review/` 中，每一版原型也存在那里，原型改过后页面会标出这一版改了哪里。
+**原型审查页（1.13 起）。** 有 `prototype/` 的需求，插件的需求页面和"等你处理"里有"审查原型"按钮（等待确认方案时是最醒目的"审查原型并确认方案"），审查页嵌在 Paseo 的网页端和桌面端里打开，手机上在浏览器中打开；终端里是 `req review <需求>`。需求方在原型上点选要改的地方（页面记下元素、文字、颜色、大小和位置）、双击直接改文字，切换状态和电脑、手机宽度，然后提交：意见整理成带位置信息的清单转给需求会话（与插件中写修改意见的效果相同），或者直接确认方案。草稿和提交记录在功能目录的 `.pipeline/review/` 中，每一版原型也存在那里，原型改过后页面会标出这一版改了哪里。
 
 为了让审查页能用，方案设计按约定写原型：每个改动区域标 `data-ac`（对应的 AC）和 `data-label`（用需求方的话说是什么），各种状态包在 `<section data-state="状态名">` 中，按钮、标题、字段名写最终的文字。原型里的脚本不会运行。
 
-审查页由一个本机服务提供：用到时在后台启动，空闲 4 小时后自己退出，只监听 `127.0.0.1`，地址中带随机令牌（插件设为只读时给只读的地址）。需求方在别的电脑上用浏览器访问 Paseo 网页端时，在运行 Paseo daemon 的机器上设置环境变量 `REQ_KIT_REVIEW_HOST`（例如 `0.0.0.0`）、`REQ_KIT_REVIEW_PUBLIC_URL`（别人访问这台机器用的地址，例如 `http://10.1.2.3:6781`），需要时用 `REQ_KIT_REVIEW_PORT` 换端口（默认 6781），然后重启 Paseo daemon 让插件拿到新的环境变量。
+审查页由一个本机服务提供：用到时在后台启动，空闲 4 小时后自己退出，只监听 `127.0.0.1`，地址中带随机令牌（插件设为只读时给只读的地址）。审查页允许被本机地址上的页面（Paseo 网页端）嵌入；要限定或放开，设 `REQ_KIT_REVIEW_FRAME_ANCESTORS`（CSP `frame-ancestors` 的值）。需求方在别的电脑上用浏览器访问 Paseo 网页端时，在运行 Paseo daemon 的机器上设置环境变量 `REQ_KIT_REVIEW_HOST`（例如 `0.0.0.0`）、`REQ_KIT_REVIEW_PUBLIC_URL`（别人访问这台机器用的地址，例如 `http://10.1.2.3:6781`），需要时用 `REQ_KIT_REVIEW_PORT` 换端口（默认 6781），然后重启 Paseo daemon 让插件拿到新的环境变量。
 
 ## 代码评审分两个方向
 
@@ -256,6 +256,19 @@ spec 头部的 `- 类型：` 决定流水线走哪种做法（1.8 起）。缺
 
 开始前，流水线读取 Paseo 的用量信息（需要 Paseo 能读到对应 agent 的订阅用量）。所用 agent 的某个额度窗口用到 `quotaWarnPercent`（默认 85）以上时，在对话里提醒一次，流水线照常进行；用完时遇到限流会自动等待重试。设为 0 关闭提醒。
 
+## token 预算和用时估算（1.13 起）
+
+内网模型通常不报金额，所以按 token（输入 + 输出）计：
+
+| 配置 | 默认 | 说明 |
+| --- | --- | --- |
+| `budget.tokens` | `null`（不限） | 一个需求所有步骤、所有尝试合计最多用多少 tokens，例如 `3000000`。每个新步骤开始前检查：用完时，已完成的步骤都保留，流水线在下一步开始前停下（状态"已中断"，停下原因 `budget`），请对话问需求方是否继续；继续（`req resume` 或在对话里说"继续开发"）会再给一份同样多的预算 |
+| `budget.warnPercent` | 80 | 用到预算的这个比例时在对话里告知一次（不停），同时发 `milestone` 外部通知 |
+
+写在本机、团队或项目配置中都可以，例如 `"budget": { "tokens": 3000000 }`。还没有数据时，先不设预算跑几个需求，用 `req stats` 的"token 花在哪"看每个需求的中位数，再按它的两三倍设。
+
+用时估算不用配置：本机已完成的同档位需求有 3 个以上时，开始开发的回复里写出"agent 合计用时和 token 的中位数"作为参考；`req status` 和插件的需求页面显示"预计还要约多久"（按中位数减去已用的 agent 时间，不含等人的时间），超过中位数时如实说"已超过通常的用时"。
+
 ## 并行编排：确认前审阅、方案提案、浏览器验证
 
 | 配置 | 默认 | 作用 |
@@ -280,7 +293,7 @@ Paseo 自带的 `/paseo-advisor`、`/paseo-committee` 等编排 skill 也可以
 | `waitingReminderHours` | 24 | 等待需求方回答、或研发完成后等待测试验证超过这么久，在对话里提醒一次；0 关闭 |
 | （启动参数 `--verify-at`） | — | 分阶段时，研发完成后在这个时间自动开始测试验证（写法同 `--at`；隐含分阶段）。研发完成时时间已过就直接继续 |
 | `autoResumeMinutes` / `autoResumeMax` | 30 / 2 | 临时错误（重试用完）中断后，这么久之后在对话里自动继续；每次尝试最多几次；0 关闭 |
-| `watchdogMinutes` | 60（1.12 起默认打开） | 运行期间对话定时检查，后台进程意外退出时自动继续。每次检查对话 agent 会运行一个回合；0 关闭。接单器（`req factory`）每次检查时也会发现这样的流水线并请它的对话继续 |
+| `watchdogMinutes` | 60（1.12 起默认打开） | 运行期间对话定时检查，后台进程意外退出时自动继续。每次检查对话 agent 会运行一个回合；0 关闭。1.13 起：装了 req-kit 插件时，插件每 5 分钟在 daemon 里直接检查本机所有需求，发现"运行中但后台进程已不在"的就执行 `req resume`（不经过模型，每个进程只继续一次，每个需求 24 小时内最多 3 次），这时不再预约对话的定时检查；插件设为只读时不做。接单器（`req factory`）每次检查也同样直接继续 |
 | `maxConcurrentPipelines` | 0（不限） | 本机同时运行的流水线上限，满了排队。只能写在本机配置中才有意义 |
 
 ## 需求总览
@@ -291,7 +304,7 @@ Paseo 自带的 `/paseo-advisor`、`/paseo-committee` 等编排 skill 也可以
 
 1.9.0 起，每次流水线运行结束时，引擎在本机的 `~/.req-kit/usage/runs.jsonl` 追加一条记录：各步骤的用时和用量、质量门、评审和缺陷轮数、结束时的状态（格式见 [使用记录](../../contracts/usage-record.md)）。只记在本机，不记需求内容和代码，也不会自动发往任何地方。
 
-- `req stats`：最近 30 天的统计（`--since 2w`、`--since 2026-10-01`、`--month 2026-10`）：有进展和完成的需求数、交付周期、返工（评审轮数、需要缺陷修复的占比、质量门失败）、各种等待的时长、各步骤用时、用量，以及不同 builder 的比较。`--json`、`--csv` 输出机器可读的格式。
+- `req stats`：最近 30 天的统计（`--since 2w`、`--since 2026-10-01`、`--month 2026-10`）：有进展和完成的需求数、交付周期、返工（评审轮数、需要缺陷修复的占比、质量门失败）、各种等待的时长、各步骤用时、用量，以及不同 builder 的比较。1.13 起有"token 花在哪"一节：按步骤和按模型的 token 及占比、返工（方案修订、评审问题修复、缺陷修复、复验，以及第 2 轮起的审核和评审）的占比、输入中来自提示缓存的比例、每个完成需求的中位数；插件的"使用统计"页用条形图显示同样的内容。`--json`、`--csv` 输出机器可读的格式。
 - `req stats --report --month 2026-10 [--out 目录]`：生成给管理方汇报用的两份文件：`req-kit-usage-2026-10.md`（汇总）和 `.csv`（每个需求一行，可以用表格软件打开）。
 - 几台机器一起汇报：每台机器运行 `req stats --month 2026-10 --export`，得到 `req-kit-usage-<主机名>-<日期>.jsonl`；把这些文件放到一起，运行 `req stats --merge <文件…> --month 2026-10 --report`。
 

package/engine/src/api.ts

@@ -17,6 +17,7 @@
 // Reading never changes anything. `run` performs the same command as `req <command>` in that
 // directory, so the engine stays the only one that changes a requirement's state.
 
+import { progressOf, typical } from "./estimate.js";
 import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
@@ -67,11 +68,12 @@ export const READABLE_FILES = [
 
 const MAX_FILE_BYTES = 512 * 1024;
 
-export type Attention = "approval" | "business" | "interrupted" | "not_completed" | null;
+export type Attention = "approval" | "business" | "permission" | "interrupted" | "not_completed" | null;
 
 /** What a person needs to do about a requirement, if anything. */
-export function attentionOf(state: Pick<PipelineState, "status" | "pid" | "outcome"> | null): Attention {
+export function attentionOf(state: Pick<PipelineState, "status" | "pid" | "outcome" | "waitingPermission"> | null): Attention {
   if (!state) return null;
+  if (state.status === "running" && state.waitingPermission && isAlive(state.pid)) return "permission";
   if (state.status === "waiting_for_approval") return "approval";
   if (state.status === "waiting_for_business") return "business";
   if (state.status === "failed" || (state.status === "running" && !isAlive(state.pid))) return "interrupted";
@@ -135,6 +137,8 @@ export interface ListItem {
     card: { system: string; id: string; url: string | null; requester: string | null } | null;
     /** Whether a reply can be sent to the requirement's chat (req reply). */
     canReply: boolean;
+    /** 1.13, attention "permission": the step agent that waits for an approval. */
+    agentId?: string;
   } | null;
 }
 
@@ -178,10 +182,12 @@ function waitingOf(repo: string, featureDir: string, state: PipelineState | null
   } catch {
     card = null;
   }
+  const permission = attentionOf(state) === "permission" ? state.waitingPermission : null;
   return {
-    since: state.updatedAt,
-    questions: state.pendingQuestions ?? [],
-    reason: state.stopReason,
+    since: permission?.since ?? state.updatedAt,
+    questions: permission ? permission.requests : (state.pendingQuestions ?? []),
+    reason: permission ? `「${permission.stepTitle}」步骤在等待权限批准，批准前会一直停在这里` : state.stopReason,
+    ...(permission ? { agentId: permission.agentId } : {}),
     card,
     canReply: Boolean(state.originAgentId) && (state.status === "waiting_for_business" || state.status === "waiting_for_approval"),
   };
@@ -294,12 +300,22 @@ export function apiStatus(repoArg: string, feature: string) {
         }
       : null,
     steps: state ? state.history.map((h) => stepJson(h, state)) : [],
+    // 1.13: what to expect, from this machine's completed requirements of the same profile.
+    estimate: estimateOf(state),
     gate: state?.gate ?? null,
     external: Object.entries(state?.external ?? {}).map(([name, r]) => ({ name, id: r.id, url: r.url, status: r.status, syncedAt: r.syncedAt, pending: r.pending.length, lastError: r.pending.at(-1)?.error ?? null })),
     joint: (state?.joint ?? []).map((j) => ({ name: j.name, slug: j.slug, repo: j.repo, sourceRepo: j.sourceRepo, branch: j.branch, workspaceId: j.workspaceId, gate: j.gate ?? null })),
   };
 }
 
+function estimateOf(state: PipelineState | null) {
+  if (!state || state.status === "completed") return null;
+  const t = typical(state.profile ?? "standard");
+  if (!t) return null;
+  const p = progressOf(state, t);
+  return { basis: t.basis, profile: t.profile, typicalAgentMinutes: t.agentMinutes, typicalTokens: t.tokens, ...p };
+}
+
 export function apiFile(repoArg: string, feature: string, file: string) {
   if (!(READABLE_FILES as readonly string[]).includes(file)) {
     throw new ApiError("not_allowed", `只能读取这些文件：${READABLE_FILES.join("、")}`);
@@ -450,6 +466,14 @@ export function apiMain(argvIn: string[], cwd = process.cwd()): unknown {
       const { message } = configureJson(["--set", value]);
       return { ok: true, message };
     }
+    case "watchdog": {
+      // 1.13: continue pipelines whose process died (the plugin runs this every few minutes).
+      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, []) }),
+      );
+    }
     case "review-url": {
       // 1.13: the prototype review page of a requirement (starts the page's server when needed).
       const feature = need("需求");

package/engine/src/card-cmd.ts

@@ -147,6 +147,8 @@ export interface CardCmdOptions {
   skipHealthCheck?: boolean;
   /** The time, for tests (1.12). */
   now?: Date;
+  /** Continues a requirement (`req resume`); tests replace it (1.13, factory watchdog). */
+  resume?: (repo: string, featureDir: string) => { ok: boolean; message: string };
 }
 
 export interface BeginResult {

package/engine/src/config-view.ts

@@ -117,6 +117,11 @@ const CATALOG: Array<{ id: string; title: string; description: string; keys: Rec
       browserVerify: { label: "检查网页界面", description: "功能验证时用界面检查命令（不靠看图）检查网页；Paseo 有内置浏览器时也用它操作。", display: (v) => ({ auto: "自动", off: "关" })[String(v)] ?? String(v) },
       paseoServices: { label: "由 Paseo 启动服务", description: "用 paseo.json 中的服务脚本启动和重启服务。", display: (v) => ({ auto: "自动", off: "关" })[String(v)] ?? String(v) },
       serviceReadySeconds: { label: "等服务就绪", description: "启动服务后最多等多久。", display: (v) => `${v} 秒` },
+      budget: {
+        label: "每个需求的 token 预算",
+        description: "一个需求所有步骤合计（输入 + 输出）最多用多少 tokens；用到一定比例时提醒，用完后做完当前步骤就停下，继续开发会再给一份预算。",
+        display: (v) => { const b = v as PipelineConfig["budget"]; return b.tokens === null ? "不限" : `${b.tokens >= 10_000 ? `${Math.round(b.tokens / 1000) / 10} 万` : b.tokens}，用到 ${b.warnPercent}% 时提醒`; },
+      },
     },
   },
   {

package/engine/src/config.ts

@@ -240,6 +240,11 @@ export interface PipelineConfig {
    * starts this many hours after its summary is on the card, unless the requester objects; 0: off.
    */
   autoConfirm: { hours: number };
+  /**
+   * 1.13: tokens (input + output, all steps and attempts) one requirement may use before the
+   * pipeline stops to ask; null: no limit. A notice at warnPercent; continuing gives one more budget.
+   */
+  budget: { tokens: number | null; warnPercent: number };
   /** Automatic retries of a step after a transient error (rate limit, dropped connection). */
   retry: { attempts: number; backoffSeconds: number[] };
   /**
@@ -349,6 +354,7 @@ export const DEFAULT_CONFIG: PipelineConfig = {
   cardSource: null,
   factory: { pollMinutes: 5, titleTags: ["[AI]", "【AI】"], maxNewPerPoll: 3 },
   autoConfirm: { hours: 0 },
+  budget: { tokens: null, warnPercent: 80 },
   retry: { attempts: 2, backoffSeconds: [60, 300] },
   paseoServices: "auto",
   serviceReadySeconds: 120,
@@ -417,6 +423,7 @@ function merge(base: PipelineConfig, raw: Record<string, unknown>): PipelineConf
   merged.push = { ...base.push, ...(isRecord(raw.push) ? raw.push : {}) } as PipelineConfig["push"];
   merged.factory = { ...base.factory, ...(isRecord(raw.factory) ? raw.factory : {}) } as PipelineConfig["factory"];
   merged.autoConfirm = { ...base.autoConfirm, ...(isRecord(raw.autoConfirm) ? raw.autoConfirm : {}) } as PipelineConfig["autoConfirm"];
+  merged.budget = { ...base.budget, ...(isRecord(raw.budget) ? raw.budget : {}) } as PipelineConfig["budget"];
   if (isRecord(raw.cardSource)) {
     const c = raw.cardSource;
     merged.cardSource = {
@@ -632,6 +639,12 @@ function validate(config: PipelineConfig): void {
     throw new ConfigError('people 必须写成 { "<姓名>": { "<账号类型>": "<账号>" } }，例如 { "张广祥": { "um": "ZHANGGX001" } }');
   }
   if (typeof config.autoConfirm.hours !== "number" || config.autoConfirm.hours < 0) throw new ConfigError("autoConfirm.hours 必须是不小于 0 的小时数（0 表示关闭）");
+  if (config.budget.tokens !== null && (typeof config.budget.tokens !== "number" || !Number.isFinite(config.budget.tokens) || config.budget.tokens <= 0)) {
+    throw new ConfigError("budget.tokens 必须是正数（每个需求最多用多少 tokens，例如 3000000），或 null 表示不限");
+  }
+  if (typeof config.budget.warnPercent !== "number" || config.budget.warnPercent <= 0 || config.budget.warnPercent >= 100) {
+    throw new ConfigError("budget.warnPercent 必须在 1 到 99 之间（用到预算的百分之几时提醒）");
+  }
   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/estimate.ts

@@ -0,0 +1,95 @@
+// How long a requirement usually takes and how many tokens it uses (1.13), from this machine's
+// run records (~/.req-kit/usage/runs.jsonl): the medians of completed requirements of the same
+// profile. Shown when a run starts and in the status, so people know roughly what to expect.
+import type { RunRecord } from "./records.js";
+import { readRuns, runsFile } from "./records.js";
+import type { PipelineState } from "./state.js";
+import { byRequirement, dedupe } from "./stats.js";
+
+/** Fewer completed requirements than this, and the numbers say little: no estimate. */
+export const MIN_BASIS = 3;
+
+export interface Typical {
+  profile: string;
+  /** How many completed requirements the medians are from. */
+  basis: number;
+  /** Median of the agents' working time per requirement (sum of step durations). */
+  agentMinutes: number;
+  /** Median tokens (input + output) per requirement; null when agents did not report usage. */
+  tokens: number | null;
+}
+
+function median(values: number[]): number | null {
+  if (values.length === 0) return null;
+  const s = [...values].sort((a, b) => a - b);
+  const m = Math.floor(s.length / 2);
+  return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2;
+}
+
+export function typical(profile: string, runs: RunRecord[] | null = null, env: NodeJS.ProcessEnv = process.env): Typical | null {
+  let records = runs;
+  if (records === null) {
+    try {
+      records = readRuns(runsFile(env));
+    } catch {
+      return null;
+    }
+  }
+  const done = byRequirement(dedupe(records)).filter((q) => q.status === "completed" && q.profile === profile);
+  if (done.length < MIN_BASIS) return null;
+  const tokens = done.flatMap((q) => (q.inputTokens === null && q.outputTokens === null ? [] : [(q.inputTokens ?? 0) + (q.outputTokens ?? 0)]));
+  return {
+    profile,
+    basis: done.length,
+    agentMinutes: median(done.map((q) => q.agentMinutes)) ?? 0,
+    tokens: tokens.length >= MIN_BASIS ? median(tokens) : null,
+  };
+}
+
+export function minutesText(m: number): string {
+  const total = Math.max(0, Math.round(m));
+  if (total < 60) return `${total} 分钟`;
+  const h = Math.floor(total / 60);
+  const rest = total % 60;
+  return rest ? `${h} 小时 ${rest} 分` : `${h} 小时`;
+}
+
+export function tokenText(n: number): string {
+  return n >= 10_000 ? `${Math.round(n / 1000) / 10} 万` : String(Math.round(n));
+}
+
+const PROFILE_NAMES: Record<string, string> = { quick: "快速档", standard: "标准档" };
+
+/** One line for a run that is starting. */
+export function typicalLine(t: Typical | null): string | null {
+  if (!t) return null;
+  return `参考：本机最近 ${t.basis} 个${PROFILE_NAMES[t.profile] ?? t.profile}需求，agent 合计用时中位数约 ${minutesText(t.agentMinutes)}${t.tokens !== null ? `，约 ${tokenText(t.tokens)} tokens` : ""}（不含等人确认的时间）。`;
+}
+
+export interface Progress {
+  usedAgentMinutes: number;
+  usedTokens: number | null;
+  /** Minutes left by the median; 0 when already past it. */
+  leftMinutes: number;
+  over: boolean;
+}
+
+export function progressOf(state: Pick<PipelineState, "history">, t: Typical, now = new Date()): Progress {
+  let minutes = 0;
+  let tokens: number | null = null;
+  for (const h of state.history) {
+    const end = h.endedAt ? new Date(h.endedAt) : now;
+    minutes += Math.max(0, (end.getTime() - new Date(h.startedAt).getTime()) / 60_000);
+    if (h.usage && (h.usage.inputTokens !== undefined || h.usage.outputTokens !== undefined)) tokens = (tokens ?? 0) + (h.usage.inputTokens ?? 0) + (h.usage.outputTokens ?? 0);
+  }
+  return { usedAgentMinutes: minutes, usedTokens: tokens, leftMinutes: Math.max(0, t.agentMinutes - minutes), over: minutes > t.agentMinutes };
+}
+
+/** "预计还要…" for a requirement that is not finished; null without enough history. */
+export function remainingLine(state: Pick<PipelineState, "history" | "status" | "profile">, t: Typical | null, now = new Date()): string | null {
+  if (!t || state.status === "completed") return null;
+  const p = progressOf(state, t, now);
+  const used = `已用 ${minutesText(p.usedAgentMinutes)}${p.usedTokens !== null ? `、${tokenText(p.usedTokens)} tokens` : ""}`;
+  const basis = `本机最近 ${t.basis} 个${PROFILE_NAMES[t.profile] ?? t.profile}需求的中位数 ${minutesText(t.agentMinutes)}${t.tokens !== null ? `、${tokenText(t.tokens)} tokens` : ""}`;
+  return p.over ? `预计：已超过通常的用时（${used}；${basis}），复杂的需求会更久。` : `预计还要：约 ${minutesText(Math.max(5, p.leftMinutes))}（${used}；${basis}；不含等人的时间）`;
+}

package/engine/src/factory.ts

@@ -18,14 +18,11 @@ import path from "node:path";
 import { parseArgs } from "node:util";
 import { cardRoutes, findCardEntry, hashText, parseJsonOutput } from "./card.js";
 import { beginFromCard, type CardCmdOptions, cardIntegrations, checkCards, withRuntime } from "./card-cmd.js";
-import { resumeCommand, statusCommand } from "./cli-args.js";
 import { loadConfig, type PipelineConfig } from "./config.js";
-import { watchdogPrompt } from "./messages.js";
 import { dispatchNotifiers } from "./notifiers.js";
-import { readIndex } from "./records.js";
 import { type IntegrationConfig, renderArgs, runCommand, type Runner } from "./integrations.js";
 import { defaultConfigPath, ENGINE_DIR, KIT_ROOT, kitHome, kitVersion } from "./locations.js";
-import { isAlive, readState, statePath } from "./state.js";
+import { isAlive } from "./state.js";
 
 const USAGE = `用法：
   req factory once      检查一次：为新卡片开始需求，把需求方的新回复转给需求会话
@@ -231,7 +228,7 @@ export async function pollOnce(configPath: string, opts: CardCmdOptions = {}, no
     }
 
     try {
-      await nudgeInterrupted(config, env, dir, result);
+      await continueInterrupted(env, opts, result, now);
     } catch (error) {
       result.errors.push(`续跑中断的需求：${(error as Error).message}`);
     }
@@ -351,31 +348,17 @@ function appendLog(dir: string, text: string, now: Date): void {
  * restarted, the process was killed): its chat gets the same message as the watchdog's, so
  * the chat checks and continues it. Once per process; a chat that cannot be reached is noted.
  */
-async function nudgeInterrupted(config: PipelineConfig, env: NodeJS.ProcessEnv, dir: string, result: PollResult): Promise<void> {
-  const file = path.join(dir, "nudged.json");
-  const nudged = readJson<Record<string, number>>(file, {});
-  const due: Array<{ key: string; pid: number; origin: string; featureDir: string; repo: string }> = [];
-  for (const entry of readIndex(env)) {
-    if (!entry.present) continue;
-    const state = readState(statePath(entry.repo, entry.featureDir));
-    if (!state || state.status !== "running" || isAlive(state.pid) || !state.originAgentId) continue;
-    if (nudged[entry.key] === state.pid) continue;
-    due.push({ key: entry.key, pid: state.pid, origin: state.originAgentId, featureDir: entry.featureDir, repo: entry.sourceRepo ?? entry.repo });
-  }
-  if (due.length === 0) return;
-  await withRuntime(config, async (runtime) => {
-    for (const d of due) {
-      const commands = { repo: d.repo, featureDir: d.featureDir, configPath: null };
-      try {
-        await runtime.notifyAgent(d.origin, watchdogPrompt({ featureDir: d.featureDir, statusCommand: statusCommand(commands), resumeCommand: resumeCommand(commands) }));
-        nudged[d.key] = d.pid;
-        result.resumed.push(`${path.join(d.repo, d.featureDir)}：后台进程已退出，已请它的对话检查并继续`);
-      } catch (error) {
-        result.errors.push(`${path.join(d.repo, d.featureDir)} 的后台进程已退出，但没能通知它的对话：${(error as Error).message}`);
-      }
-    }
-  });
-  writeJson(file, nudged);
+/**
+ * 1.13: pipelines whose background process died are continued directly (`req resume`), not by
+ * asking their chat: no model turn, and it works when the chat is archived or rate-limited.
+ */
+async function continueInterrupted(env: NodeJS.ProcessEnv, opts: CardCmdOptions, result: PollResult, now: Date): Promise<void> {
+  const { watchdogPass } = await import("./watchdog.js");
+  const { apiRun } = await import("./api.js");
+  const pass = watchdogPass({ env, by: "factory", now, resume: opts.resume ?? ((repo, featureDir) => apiRun("resume", repo, featureDir, [])) });
+  for (const r of pass.resumed) result.resumed.push(`${path.join(r.repo, r.featureDir)}：后台进程已退出，已自动继续`);
+  for (const r of pass.failed) result.errors.push(`${path.join(r.repo, r.featureDir)} 的后台进程已退出，自动继续失败：${r.message}`);
+  for (const r of pass.skipped) result.problems.push(`${r.featureDir}：${r.reason}`);
 }
 
 function describe(result: PollResult, now = new Date()): string[] {

package/engine/src/launch.ts

@@ -20,6 +20,7 @@ import { describeFeatures, featuresWithRuns, findWorktreeRun, listFeatures, reso
 import { checkChatCwd, normalizeFeatureDir, preflight, type PreflightResult, specProfile, verifyPhaseProblem } from "./preflight.js";
 import { loadRuntimeFactory } from "./runtime-loader.js";
 import type { AgentRuntime } from "./runtime.js";
+import { remainingLine, typical, typicalLine } from "./estimate.js";
 import { ensurePipelineDir, hashFile, isAlive, pipelineDir, readState, statePath } from "./state.js";
 
 function fail(message: string): never {
@@ -159,6 +160,9 @@ if (args.status || args.stop) {
       process.exit(0);
     }
     console.log(describeStatus(state, featureDir));
+    // 1.13: what to expect, from this machine's completed requirements of the same profile.
+    const estimate = state ? remainingLine(state, typical(state.profile ?? "standard")) : null;
+    if (estimate) console.log(estimate);
     if (state && reservation) console.log(`已预约：${describeTime(new Date(reservation.at))} 开始（Paseo 定时任务，到时由对话执行；执行暂停命令可以取消）`);
     if (args.sourceRepo) console.log(`位置：为这个需求新建的工作区 ${repo}（需求文件在 ${path.join(repo, featureDir)}）`);
     // Live detail from Paseo, best effort: the plain status above never depends on the daemon.
@@ -405,6 +409,7 @@ console.log(
         ? `这个需求在为它新建的工作区中开发：${checked.repo}`
         : null,
     `功能目录：${checked.featureDir}`,
+    checked.mode.kind === "fresh" && !checked.entersVerify ? typicalLine(typical(profile)) : null,
     checked.branch ? `工作分支：${checked.branch}` : "不是 git 仓库：步骤不会提交代码。",
     loaded.sources.length > 1 ? `使用了项目配置：${loaded.sources[1]}` : null,
     `运行日志：${logPath}`,

package/engine/src/main.ts

@@ -308,7 +308,11 @@ async function main(): Promise<number> {
 
   // Optional watchdog: the chat checks on the run now and then and continues it if the process died.
   let watchdog: string | null = null;
-  if (config.watchdogMinutes > 0 && originAgentId) {
+  // 1.13: when the req-kit plugin is checking (it continues dead runs itself, no model needed),
+  // the chat is not woken up for it.
+  const pluginWatching = (await import("./watchdog.js")).watchdogActive();
+  if (pluginWatching && config.watchdogMinutes > 0) log("req-kit 插件在检查后台进程，不再预约对话的定时检查");
+  if (config.watchdogMinutes > 0 && originAgentId && !pluginWatching) {
     watchdog = await runtime
       .scheduleMessage({
         agentId: originAgentId,

package/engine/src/messages.ts

@@ -352,10 +352,15 @@ export function approvalMessage(input: {
     `功能目录：${input.featureDir}`,
     "情况：方案已经通过审核，还没有开始写代码。开发前请需求方确认\"做完之后会看到什么\"，这时调整的成本最低。",
     `- 做完后你会看到什么：${input.previewPath}`,
-    ...(input.prototypePath ? [`- 界面原型：${input.prototypePath}（静态页面，可以在浏览器中打开）`] : []),
+    ...(input.prototypePath
+      ? [
+          `- 界面原型：${input.prototypePath}`,
+          `- 原型审查页：在 Paseo 侧边栏的"需求"中打开这个需求，点"审查原型"（"等你处理"里也有），可以直接在原型上点选要改的地方、双击改文字，提交意见或确认方案；终端里是 req review ${input.featureDir.split("/").pop()}`,
+        ]
+      : []),
     "",
     "请这样处理：",
-    "1. 读 preview.md，用几句话把要点讲给用户：会看到的变化、主要的假设（尤其是影响界面、数据、权限的），有原型就告诉用户在哪里看。",
+    "1. 读 preview.md，用几句话把要点讲给用户：会看到的变化、主要的假设（尤其是影响界面、数据、权限的）。有原型时，请用户点 Paseo 侧边栏\"需求\"里这个需求的\"审查原型\"按钮去看：在原型上点选提意见比用文字描述准确，提交的意见会转回这个对话。",
     "2. 问用户：按这个做，还是有要改的地方？",
     `3. 用户确认后，执行下面的命令继续开发：\n\n${input.approveCommand}`,
     "4. 用户要改的：按需求对齐时的方式问清楚，把结论记入 alignment.md，更新 spec.md（顶部\"版本\"加 1，在 changes.md 中记一节，原因写\"方案确认时的修改\"），请用户再次确认需求说明，然后执行下面的命令，流水线会从方案设计开始按修改后的需求调整方案，再请用户确认一次：",