@michaelxwb/code-flow 0.6.4 → 0.6.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@michaelxwb/code-flow",
-  "version": "0.6.4",
+  "version": "0.6.5",
   "license": "UNLICENSED",
   "bin": {
     "code-flow": "src/cli.js"

package/src/adapters/claude/commands/cf-task/archive.md

@@ -36,6 +36,8 @@
 
 - 需求目录必须存在 `spec-context.yml`；执行 `python3 .code-flow/scripts/cf_spec_context.py refresh --task-dir <需求目录> --root "$PWD" --json`
 - 执行 `python3 .code-flow/scripts/cf_spec_gate.py --task-dir <需求目录> --stage code --json`；required Rule 的 stale/pending/conflict/unverified 任一存在即 FAIL
+- 执行 review 终验：`python3 .code-flow/scripts/cf_task_workflow.py verify-e2e --task-dir <需求目录> --root "$PWD" --json`（聚合需求目录全部 task context 的 `stage: review` verifier + acceptance E2E，按 spec/rule 去重执行一次并写回证据）；`decision=pass` 才继续，失败保持阻断
+- 执行 `python3 .code-flow/scripts/cf_spec_gate.py --task-dir <需求目录> --stage review --json`；required Rule 存在 unverified review 证据即 FAIL（先完成 review 终验）
 - 若 `.code-flow/.active-task.json` 仍指向本需求，先执行 `python3 .code-flow/scripts/cf_task_workflow.py finish --root "$PWD" --task-dir "<需求目录>" --task TASK-001 --json`，通过后再 verify-e2e；不得自报 gate_passed 或通过归档绕过 active 状态
 - Context 与 Evidence 随需求目录一并归档，`_session` 仅是可重建投影，不是事实源
 

package/src/adapters/claude/commands/cf-task/start.md

@@ -209,6 +209,23 @@ python3 .code-flow/scripts/cf_task_parallel.py prepare --root "$PWD" \
 4. 完成时在 worktree 内提交全部改动（含任务文件 Checklist/Evidence/Status 更新），提交信息 `cf-task(<TASK-ID>): <标题>`。
 5. 返回摘要：TASK-ID、Status、验收命令及结果、提交 SHA、遗留问题。
 
+标准 worker prompt 模板（替换占位符后派发）：
+
+```
+你在隔离 worktree 中执行 <TASK-ID>：<worktree 绝对路径>。
+1) cd 到 worktree；先读 Spec Session（.code-flow/specs/_session/task-<name>.md）、任务文件的当前 TASK 段落与 design 来源章节；
+2) cf_spec_context.py start → 写验收测试记录 RED → 实现 → GREEN；
+3) 运行 cf_task_workflow.py finish --root "$PWD" --task <TASK-ID> --json；decision=pass 后【再】提交全部改动（含 finish 回写的 Evidence/状态）：git add -A && git commit -m "cf-task(<TASK-ID>): <标题>"；
+4) 返回摘要：TASK-ID、Status、验收命令与结果、commit SHA、遗留问题。
+```
+
+> 提交必须在 finish 之后：finish 通过后会回写 Evidence/状态；collect 默认会自动提交这些回写，但显式提交更清晰。
+
+子 agent 中断（取消/超时）时不要重新 prepare：检查该 worktree 的 `git status`、`git log <base>..HEAD` 与 marker——
+- 无改动且无 marker：直接接管，按单任务模式继续；
+- 有未提交改动或已有提交但未 done：在 worktree 内接管收尾（补实现/测试并 finish），再走 4.3 collect；
+- 已 done 且 marker 已清理：直接进入 4.3。
+
 平台不支持子 agent 时，不建 worktree，直接走 4.6 串行回退。
 
 #### 4.3 收集与校验
@@ -218,6 +235,7 @@ python3 .code-flow/scripts/cf_task_parallel.py collect --root "$PWD" --run-id <r
 ```
 
 - 每个任务必须 `ok: true`（改动已提交、Status 为 done/verified、marker 已清理、有提交）。
+- `collect` 在任务 done/verified 且 marker 已清理后，会自动提交 finish 回写的 Evidence/状态（`--no-commit` 关闭并回到严格模式）；finish 之外的未提交改动仍应人工确认。
 - 任一任务失败：停止本批次，不合并；保留 worktree 并列出失败原因。修复后重跑 collect；确认放弃时执行 4.5 cleanup。
 
 #### 4.4 回并主分支
@@ -240,6 +258,7 @@ git merge --no-ff -m "merge cf-task <TASK-ID>" <branch>
 ```
 
 - 仍出现冲突（主区期间有新合并）：按双方意图解决并重跑双方 functional 验收；通过后提交 merge。
+- 状态文件冲突（`spec-context.yml` / 任务 md 的覆盖状态列 / `.acceptance-manifest.json`）按确定性优先级解决：覆盖状态列取并集（两边各自 verified 的行保留 verified）；`spec-context.yml` 取已包含全量规则证据的一侧；manifest 多数情况按行自动合并，冲突时以任务文件为准重建后重跑 functional 场景。解决后必须 `cf_spec_context.py refresh` 收敛 hash，并重跑合并双方的 functional 验收与 `cf_spec_gate --stage code --json`，通过后提交 merge。
 - 合并后验收失败：记录合并前 HEAD 并 `git reset --hard <合并前HEAD>`（分支与 worktree 原样保留），回到 4.2 让对应子 agent 修复后重新 collect / rebase / 合并。
 
 3. 全部任务合并完成后进入 4.5 清理。

package/src/adapters/claude/commands/cf-task/verify-e2e.md

@@ -9,7 +9,12 @@ globs: []
 
 ## 使用场景
 
-E2E 测试依赖外部环境（数据库、API、浏览器等），在编码阶段默认跳过（状态 `e2e_deferred`）。当所有子任务的 functional 测试通过后，使用此命令统一执行 E2E 验收。
+本命令是**需求级终验**入口，在所有子任务的 functional 测试通过后统一执行：
+
+1. **review 层 verifier**：绑定规范中 `stage: review` 的 required verifier（e2e/acceptance/构建等重型验证）。遍历需求目录全部 task context，按 spec/rule 去重执行一次，证据写回全部相关 context；输出 `executed` / `reused` / `failed` 计数。
+2. **E2E 验收场景**：依赖外部环境（数据库、API、浏览器等）、编码阶段标记 `e2e_deferred` 的场景。
+
+失败不写 verified、不反转已 done 的任务状态；归档前必须 `decision=pass`。未声明 review verifier 且无 E2E 场景时为空操作（`reason=nothing_to_verify`）。
 
 ## 调用方式
 

package/src/adapters/codex/skills/cf-task-archive/SKILL.md

@@ -37,6 +37,8 @@ description: Archive a completed task file after completeness, correctness, trac
 
 - 需求目录必须存在 `spec-context.yml`；执行 `python3 .code-flow/scripts/cf_spec_context.py refresh --task-dir <需求目录> --root "$PWD" --json`
 - 执行 `python3 .code-flow/scripts/cf_spec_gate.py --task-dir <需求目录> --stage code --json`；required Rule 的 stale/pending/conflict/unverified 任一存在即 FAIL
+- 执行 review 终验：`python3 .code-flow/scripts/cf_task_workflow.py verify-e2e --task-dir <需求目录> --root "$PWD" --json`（聚合需求目录全部 task context 的 `stage: review` verifier + acceptance E2E，按 spec/rule 去重执行一次并写回证据）；`decision=pass` 才继续，失败保持阻断
+- 执行 `python3 .code-flow/scripts/cf_spec_gate.py --task-dir <需求目录> --stage review --json`；required Rule 存在 unverified review 证据即 FAIL（先完成 review 终验）
 - 若 `.code-flow/.active-task.json` 仍指向本需求，先执行 `python3 .code-flow/scripts/cf_task_workflow.py finish --root "$PWD" --task-dir "<需求目录>" --task TASK-001 --json`，通过后再 verify-e2e；不得自报 gate_passed 或通过归档绕过 active 状态
 - Context 与 Evidence 随需求目录一并归档，`_session` 仅是可重建投影，不是事实源
 

package/src/adapters/codex/skills/cf-task-start/SKILL.md

@@ -210,6 +210,23 @@ python3 .code-flow/scripts/cf_task_parallel.py prepare --root "$PWD" \
 4. 完成时在 worktree 内提交全部改动（含任务文件 Checklist/Evidence/Status 更新），提交信息 `cf-task(<TASK-ID>): <标题>`。
 5. 返回摘要：TASK-ID、Status、验收命令及结果、提交 SHA、遗留问题。
 
+标准 worker prompt 模板（替换占位符后派发）：
+
+```
+你在隔离 worktree 中执行 <TASK-ID>：<worktree 绝对路径>。
+1) cd 到 worktree；先读 Spec Session（.code-flow/specs/_session/task-<name>.md）、任务文件的当前 TASK 段落与 design 来源章节；
+2) cf_spec_context.py start → 写验收测试记录 RED → 实现 → GREEN；
+3) 运行 cf_task_workflow.py finish --root "$PWD" --task <TASK-ID> --json；decision=pass 后【再】提交全部改动（含 finish 回写的 Evidence/状态）：git add -A && git commit -m "cf-task(<TASK-ID>): <标题>"；
+4) 返回摘要：TASK-ID、Status、验收命令与结果、commit SHA、遗留问题。
+```
+
+> 提交必须在 finish 之后：finish 通过后会回写 Evidence/状态；collect 默认会自动提交这些回写，但显式提交更清晰。
+
+子 agent 中断（取消/超时）时不要重新 prepare：检查该 worktree 的 `git status`、`git log <base>..HEAD` 与 marker——
+- 无改动且无 marker：直接接管，按单任务模式继续；
+- 有未提交改动或已有提交但未 done：在 worktree 内接管收尾（补实现/测试并 finish），再走 4.3 collect；
+- 已 done 且 marker 已清理：直接进入 4.3。
+
 平台不支持子 agent 时，不建 worktree，直接走 4.6 串行回退。
 
 #### 4.3 收集与校验
@@ -219,6 +236,7 @@ python3 .code-flow/scripts/cf_task_parallel.py collect --root "$PWD" --run-id <r
 ```
 
 - 每个任务必须 `ok: true`（改动已提交、Status 为 done/verified、marker 已清理、有提交）。
+- `collect` 在任务 done/verified 且 marker 已清理后，会自动提交 finish 回写的 Evidence/状态（`--no-commit` 关闭并回到严格模式）；finish 之外的未提交改动仍应人工确认。
 - 任一任务失败：停止本批次，不合并；保留 worktree 并列出失败原因。修复后重跑 collect；确认放弃时执行 4.5 cleanup。
 
 #### 4.4 回并主分支
@@ -241,6 +259,7 @@ git merge --no-ff -m "merge cf-task <TASK-ID>" <branch>
 ```
 
 - 仍出现冲突（主区期间有新合并）：按双方意图解决并重跑双方 functional 验收；通过后提交 merge。
+- 状态文件冲突（`spec-context.yml` / 任务 md 的覆盖状态列 / `.acceptance-manifest.json`）按确定性优先级解决：覆盖状态列取并集（两边各自 verified 的行保留 verified）；`spec-context.yml` 取已包含全量规则证据的一侧；manifest 多数情况按行自动合并，冲突时以任务文件为准重建后重跑 functional 场景。解决后必须 `cf_spec_context.py refresh` 收敛 hash，并重跑合并双方的 functional 验收与 `cf_spec_gate --stage code --json`，通过后提交 merge。
 - 合并后验收失败：记录合并前 HEAD 并 `git reset --hard <合并前HEAD>`（分支与 worktree 原样保留），回到 4.2 让对应子 agent 修复后重新 collect / rebase / 合并。
 
 3. 全部任务合并完成后进入 4.5 清理。

package/src/adapters/codex/skills/cf-task-verify-e2e/SKILL.md

@@ -5,7 +5,12 @@ description: Execute deferred E2E scenarios after all functional tests pass
 
 ## 使用场景
 
-E2E 测试依赖外部环境（数据库、API、浏览器等），在编码阶段默认跳过（状态 `e2e_deferred`）。当所有子任务的 functional 测试通过后，使用此命令统一执行 E2E 验收。
+本命令是**需求级终验**入口，在所有子任务的 functional 测试通过后统一执行：
+
+1. **review 层 verifier**：绑定规范中 `stage: review` 的 required verifier（e2e/acceptance/构建等重型验证）。遍历需求目录全部 task context，按 spec/rule 去重执行一次，证据写回全部相关 context；输出 `executed` / `reused` / `failed` 计数。
+2. **E2E 验收场景**：依赖外部环境（数据库、API、浏览器等）、编码阶段标记 `e2e_deferred` 的场景。
+
+失败不写 verified、不反转已 done 的任务状态；归档前必须 `decision=pass`。未声明 review verifier 且无 E2E 场景时为空操作（`reason=nothing_to_verify`）。
 
 ## 调用方式
 

package/src/adapters/costrict/commands/cf-task/archive.md

@@ -36,6 +36,8 @@
 
 - 需求目录必须存在 `spec-context.yml`；执行 `python3 .code-flow/scripts/cf_spec_context.py refresh --task-dir <需求目录> --root "$PWD" --json`
 - 执行 `python3 .code-flow/scripts/cf_spec_gate.py --task-dir <需求目录> --stage code --json`；required Rule 的 stale/pending/conflict/unverified 任一存在即 FAIL
+- 执行 review 终验：`python3 .code-flow/scripts/cf_task_workflow.py verify-e2e --task-dir <需求目录> --root "$PWD" --json`（聚合需求目录全部 task context 的 `stage: review` verifier + acceptance E2E，按 spec/rule 去重执行一次并写回证据）；`decision=pass` 才继续，失败保持阻断
+- 执行 `python3 .code-flow/scripts/cf_spec_gate.py --task-dir <需求目录> --stage review --json`；required Rule 存在 unverified review 证据即 FAIL（先完成 review 终验）
 - 若 `.code-flow/.active-task.json` 仍指向本需求，先执行 `python3 .code-flow/scripts/cf_task_workflow.py finish --root "$PWD" --task-dir "<需求目录>" --task TASK-001 --json`，通过后再 verify-e2e；不得自报 gate_passed 或通过归档绕过 active 状态
 - Context 与 Evidence 随需求目录一并归档，`_session` 仅是可重建投影，不是事实源
 

package/src/adapters/costrict/commands/cf-task/start.md

@@ -209,6 +209,23 @@ python3 .code-flow/scripts/cf_task_parallel.py prepare --root "$PWD" \
 4. 完成时在 worktree 内提交全部改动（含任务文件 Checklist/Evidence/Status 更新），提交信息 `cf-task(<TASK-ID>): <标题>`。
 5. 返回摘要：TASK-ID、Status、验收命令及结果、提交 SHA、遗留问题。
 
+标准 worker prompt 模板（替换占位符后派发）：
+
+```
+你在隔离 worktree 中执行 <TASK-ID>：<worktree 绝对路径>。
+1) cd 到 worktree；先读 Spec Session（.code-flow/specs/_session/task-<name>.md）、任务文件的当前 TASK 段落与 design 来源章节；
+2) cf_spec_context.py start → 写验收测试记录 RED → 实现 → GREEN；
+3) 运行 cf_task_workflow.py finish --root "$PWD" --task <TASK-ID> --json；decision=pass 后【再】提交全部改动（含 finish 回写的 Evidence/状态）：git add -A && git commit -m "cf-task(<TASK-ID>): <标题>"；
+4) 返回摘要：TASK-ID、Status、验收命令与结果、commit SHA、遗留问题。
+```
+
+> 提交必须在 finish 之后：finish 通过后会回写 Evidence/状态；collect 默认会自动提交这些回写，但显式提交更清晰。
+
+子 agent 中断（取消/超时）时不要重新 prepare：检查该 worktree 的 `git status`、`git log <base>..HEAD` 与 marker——
+- 无改动且无 marker：直接接管，按单任务模式继续；
+- 有未提交改动或已有提交但未 done：在 worktree 内接管收尾（补实现/测试并 finish），再走 4.3 collect；
+- 已 done 且 marker 已清理：直接进入 4.3。
+
 平台不支持子 agent 时，不建 worktree，直接走 4.6 串行回退。
 
 #### 4.3 收集与校验
@@ -218,6 +235,7 @@ python3 .code-flow/scripts/cf_task_parallel.py collect --root "$PWD" --run-id <r
 ```
 
 - 每个任务必须 `ok: true`（改动已提交、Status 为 done/verified、marker 已清理、有提交）。
+- `collect` 在任务 done/verified 且 marker 已清理后，会自动提交 finish 回写的 Evidence/状态（`--no-commit` 关闭并回到严格模式）；finish 之外的未提交改动仍应人工确认。
 - 任一任务失败：停止本批次，不合并；保留 worktree 并列出失败原因。修复后重跑 collect；确认放弃时执行 4.5 cleanup。
 
 #### 4.4 回并主分支
@@ -240,6 +258,7 @@ git merge --no-ff -m "merge cf-task <TASK-ID>" <branch>
 ```
 
 - 仍出现冲突（主区期间有新合并）：按双方意图解决并重跑双方 functional 验收；通过后提交 merge。
+- 状态文件冲突（`spec-context.yml` / 任务 md 的覆盖状态列 / `.acceptance-manifest.json`）按确定性优先级解决：覆盖状态列取并集（两边各自 verified 的行保留 verified）；`spec-context.yml` 取已包含全量规则证据的一侧；manifest 多数情况按行自动合并，冲突时以任务文件为准重建后重跑 functional 场景。解决后必须 `cf_spec_context.py refresh` 收敛 hash，并重跑合并双方的 functional 验收与 `cf_spec_gate --stage code --json`，通过后提交 merge。
 - 合并后验收失败：记录合并前 HEAD 并 `git reset --hard <合并前HEAD>`（分支与 worktree 原样保留），回到 4.2 让对应子 agent 修复后重新 collect / rebase / 合并。
 
 3. 全部任务合并完成后进入 4.5 清理。

package/src/adapters/costrict/commands/cf-task/verify-e2e.md

@@ -9,7 +9,12 @@ globs: []
 
 ## 使用场景
 
-E2E 测试依赖外部环境（数据库、API、浏览器等），在编码阶段默认跳过（状态 `e2e_deferred`）。当所有子任务的 functional 测试通过后，使用此命令统一执行 E2E 验收。
+本命令是**需求级终验**入口，在所有子任务的 functional 测试通过后统一执行：
+
+1. **review 层 verifier**：绑定规范中 `stage: review` 的 required verifier（e2e/acceptance/构建等重型验证）。遍历需求目录全部 task context，按 spec/rule 去重执行一次，证据写回全部相关 context；输出 `executed` / `reused` / `failed` 计数。
+2. **E2E 验收场景**：依赖外部环境（数据库、API、浏览器等）、编码阶段标记 `e2e_deferred` 的场景。
+
+失败不写 verified、不反转已 done 的任务状态；归档前必须 `decision=pass`。未声明 review verifier 且无 E2E 场景时为空操作（`reason=nothing_to_verify`）。
 
 ## 调用方式
 

package/src/adapters/opencode/commands/cf-task/archive.md

@@ -41,6 +41,8 @@ description: 归档已完成的 task 文件
 
 - 需求目录必须存在 `spec-context.yml`；执行 `python3 .code-flow/scripts/cf_spec_context.py refresh --task-dir <需求目录> --root "$PWD" --json`
 - 执行 `python3 .code-flow/scripts/cf_spec_gate.py --task-dir <需求目录> --stage code --json`；required Rule 的 stale/pending/conflict/unverified 任一存在即 FAIL
+- 执行 review 终验：`python3 .code-flow/scripts/cf_task_workflow.py verify-e2e --task-dir <需求目录> --root "$PWD" --json`（聚合需求目录全部 task context 的 `stage: review` verifier + acceptance E2E，按 spec/rule 去重执行一次并写回证据）；`decision=pass` 才继续，失败保持阻断
+- 执行 `python3 .code-flow/scripts/cf_spec_gate.py --task-dir <需求目录> --stage review --json`；required Rule 存在 unverified review 证据即 FAIL（先完成 review 终验）
 - 若 `.code-flow/.active-task.json` 仍指向本需求，先执行 `python3 .code-flow/scripts/cf_task_workflow.py finish --root "$PWD" --task-dir "<需求目录>" --task TASK-001 --json`，通过后再 verify-e2e；不得自报 gate_passed 或通过归档绕过 active 状态
 - Context 与 Evidence 随需求目录一并归档，`_session` 仅是可重建投影，不是事实源
 

package/src/adapters/opencode/commands/cf-task/start.md

@@ -214,6 +214,23 @@ python3 .code-flow/scripts/cf_task_parallel.py prepare --root "$PWD" \
 4. 完成时在 worktree 内提交全部改动（含任务文件 Checklist/Evidence/Status 更新），提交信息 `cf-task(<TASK-ID>): <标题>`。
 5. 返回摘要：TASK-ID、Status、验收命令及结果、提交 SHA、遗留问题。
 
+标准 worker prompt 模板（替换占位符后派发）：
+
+```
+你在隔离 worktree 中执行 <TASK-ID>：<worktree 绝对路径>。
+1) cd 到 worktree；先读 Spec Session（.code-flow/specs/_session/task-<name>.md）、任务文件的当前 TASK 段落与 design 来源章节；
+2) cf_spec_context.py start → 写验收测试记录 RED → 实现 → GREEN；
+3) 运行 cf_task_workflow.py finish --root "$PWD" --task <TASK-ID> --json；decision=pass 后【再】提交全部改动（含 finish 回写的 Evidence/状态）：git add -A && git commit -m "cf-task(<TASK-ID>): <标题>"；
+4) 返回摘要：TASK-ID、Status、验收命令与结果、commit SHA、遗留问题。
+```
+
+> 提交必须在 finish 之后：finish 通过后会回写 Evidence/状态；collect 默认会自动提交这些回写，但显式提交更清晰。
+
+子 agent 中断（取消/超时）时不要重新 prepare：检查该 worktree 的 `git status`、`git log <base>..HEAD` 与 marker——
+- 无改动且无 marker：直接接管，按单任务模式继续；
+- 有未提交改动或已有提交但未 done：在 worktree 内接管收尾（补实现/测试并 finish），再走 4.3 collect；
+- 已 done 且 marker 已清理：直接进入 4.3。
+
 平台不支持子 agent 时，不建 worktree，直接走 4.6 串行回退。
 
 #### 4.3 收集与校验
@@ -223,6 +240,7 @@ python3 .code-flow/scripts/cf_task_parallel.py collect --root "$PWD" --run-id <r
 ```
 
 - 每个任务必须 `ok: true`（改动已提交、Status 为 done/verified、marker 已清理、有提交）。
+- `collect` 在任务 done/verified 且 marker 已清理后，会自动提交 finish 回写的 Evidence/状态（`--no-commit` 关闭并回到严格模式）；finish 之外的未提交改动仍应人工确认。
 - 任一任务失败：停止本批次，不合并；保留 worktree 并列出失败原因。修复后重跑 collect；确认放弃时执行 4.5 cleanup。
 
 #### 4.4 回并主分支
@@ -245,6 +263,7 @@ git merge --no-ff -m "merge cf-task <TASK-ID>" <branch>
 ```
 
 - 仍出现冲突（主区期间有新合并）：按双方意图解决并重跑双方 functional 验收；通过后提交 merge。
+- 状态文件冲突（`spec-context.yml` / 任务 md 的覆盖状态列 / `.acceptance-manifest.json`）按确定性优先级解决：覆盖状态列取并集（两边各自 verified 的行保留 verified）；`spec-context.yml` 取已包含全量规则证据的一侧；manifest 多数情况按行自动合并，冲突时以任务文件为准重建后重跑 functional 场景。解决后必须 `cf_spec_context.py refresh` 收敛 hash，并重跑合并双方的 functional 验收与 `cf_spec_gate --stage code --json`，通过后提交 merge。
 - 合并后验收失败：记录合并前 HEAD 并 `git reset --hard <合并前HEAD>`（分支与 worktree 原样保留），回到 4.2 让对应子 agent 修复后重新 collect / rebase / 合并。
 
 3. 全部任务合并完成后进入 4.5 清理。

package/src/adapters/opencode/commands/cf-task/verify-e2e.md

@@ -9,7 +9,12 @@ globs: []
 
 ## 使用场景
 
-E2E 测试依赖外部环境（数据库、API、浏览器等），在编码阶段默认跳过（状态 `e2e_deferred`）。当所有子任务的 functional 测试通过后，使用此命令统一执行 E2E 验收。
+本命令是**需求级终验**入口，在所有子任务的 functional 测试通过后统一执行：
+
+1. **review 层 verifier**：绑定规范中 `stage: review` 的 required verifier（e2e/acceptance/构建等重型验证）。遍历需求目录全部 task context，按 spec/rule 去重执行一次，证据写回全部相关 context；输出 `executed` / `reused` / `failed` 计数。
+2. **E2E 验收场景**：依赖外部环境（数据库、API、浏览器等）、编码阶段标记 `e2e_deferred` 的场景。
+
+失败不写 verified、不反转已 done 的任务状态；归档前必须 `decision=pass`。未声明 review verifier 且无 E2E 场景时为空操作（`reason=nothing_to_verify`）。
 
 ## 调用方式
 

package/src/core/code-flow/scripts/cf_spec_context.py

@@ -101,6 +101,7 @@ class RuleBinding:
     enforcement: str
     verifier_ref: str
     stage_status: Mapping[str, RuleStageStatus]
+    verifier_stage: str = "code"
 
 
 @dataclass(frozen=True)
@@ -806,6 +807,7 @@ def _rule_from_data(value: object, path: str) -> RuleBinding:
         _string(data.get("enforcement"), "rules[].enforcement", path),
         _string(data.get("verifier_ref"), "rules[].verifier_ref", path),
         parsed,
+        _string(data.get("verifier_stage", "code"), "rules[].verifier_stage", path),
     )
 
 
@@ -816,6 +818,7 @@ def _rule_data(rule: RuleBinding) -> dict[str, object]:
         "text_sha256": rule.text_sha256,
         "enforcement": rule.enforcement,
         "verifier_ref": rule.verifier_ref,
+        "verifier_stage": rule.verifier_stage,
         "stage_status": {stage: _stage_data(status) for stage, status in rule.stage_status.items()},
     }
 
@@ -990,7 +993,12 @@ def _binding_from_input(selection: BindingInput) -> SpecBinding:
         }
         verifier = verifier_by_rule.get(rule.ref)
         verifier_ref = f"{candidate.spec_id}#{rule.ref}" if verifier is not None else "advisory:none"
-        rules.append(RuleBinding(rule.ref, rule.text, rule.text_sha256, enforcement, verifier_ref, statuses))
+        rules.append(
+            RuleBinding(
+                rule.ref, rule.text, rule.text_sha256, enforcement, verifier_ref, statuses,
+                verifier.stage if verifier is not None else "code",
+            )
+        )
     return SpecBinding(
         candidate.spec_id,
         candidate.path,
@@ -1003,12 +1011,26 @@ def _binding_from_input(selection: BindingInput) -> SpecBinding:
     )
 
 
+def _with_declared_stages(rule: RuleBinding, stages: Sequence[str]) -> RuleBinding:
+    """兼容补齐：绑定旧版本时声明的 stages 缺状态，按声明补 pending。"""
+    missing = [stage for stage in stages if stage not in rule.stage_status]
+    if not missing:
+        return rule
+    statuses = dict(rule.stage_status)
+    for stage in missing:
+        statuses[stage] = RuleStageStatus("pending", (), None, ())
+    return replace(rule, stage_status=statuses)
+
+
 def _rule_from_metadata(spec_id: str, metadata: SpecMetadata, rule: SpecRule) -> RuleBinding:
     enforcement = "advisory" if metadata.enforcement == "advisory" else rule.enforcement
     statuses = {stage: RuleStageStatus("pending", (), None, ()) for stage in metadata.stages}
-    has_verifier = any(item.rule == rule.ref for item in metadata.verifiers)
-    verifier_ref = f"{spec_id}#{rule.ref}" if has_verifier else "advisory:none"
-    return RuleBinding(rule.ref, rule.text, rule.text_sha256, enforcement, verifier_ref, statuses)
+    verifier = next((item for item in metadata.verifiers if item.rule == rule.ref), None)
+    verifier_ref = f"{spec_id}#{rule.ref}" if verifier is not None else "advisory:none"
+    return RuleBinding(
+        rule.ref, rule.text, rule.text_sha256, enforcement, verifier_ref, statuses,
+        verifier.stage if verifier is not None else "code",
+    )
 
 
 def bind_specs(context: SpecContext, selections: Sequence[BindingInput]) -> SpecContext:
@@ -1156,14 +1178,15 @@ def _refresh_existing_rule(
     binding: SpecBinding, existing: RuleBinding, current: SpecRule, metadata: SpecMetadata
 ) -> tuple[RuleBinding, Optional[DriftChange]]:
     enforcement = "advisory" if metadata.enforcement == "advisory" else current.enforcement
-    has_verifier = any(item.rule == current.ref for item in metadata.verifiers)
-    verifier_ref = f"{binding.spec_id}#{current.ref}" if has_verifier else "advisory:none"
+    verifier = next((item for item in metadata.verifiers if item.rule == current.ref), None)
+    verifier_ref = f"{binding.spec_id}#{current.ref}" if verifier is not None else "advisory:none"
     updated = replace(
         existing,
         summary=current.text,
         text_sha256=current.text_sha256,
         enforcement=enforcement,
         verifier_ref=verifier_ref,
+        verifier_stage=verifier.stage if verifier is not None else "code",
     )
     if existing.text_sha256 == current.text_sha256:
         return updated, None
@@ -1200,6 +1223,7 @@ def _refresh_binding(
             rule, change = _refresh_existing_rule(binding, prior, current, metadata)
             if change is not None:
                 changes.append(change)
+        rule = _with_declared_stages(rule, metadata.stages)
         rule, artifact_changes = _refresh_artifacts(binding.spec_id, rule, artifact_root)
         rules.append(rule)
         changes.extend(artifact_changes)
@@ -1571,11 +1595,13 @@ def _status_command(args: argparse.Namespace) -> dict[str, object]:
         rules = []
         for rule in binding.rules:
             status = rule.stage_status.get("code")
+            stages = {stage: item.status for stage, item in sorted(rule.stage_status.items())}
             rules.append(
                 {
                     "ref": f"{binding.spec_id}#{rule.ref}",
                     "enforcement": rule.enforcement,
                     "status": status.status if status else "missing",
+                    "stages": stages,
                     "verifier": rule.verifier_ref,
                 }
             )
@@ -1609,7 +1635,8 @@ def _status_text(data: dict[str, object]) -> str:
     for binding in data["bindings"]:
         lines.append(f"- {binding['spec_id']}（{binding['path']}）— {binding['status']}")
         for rule in binding["rules"]:
-            lines.append(f"  {rule['status']:<12} {rule['ref']}（{rule['verifier']}）")
+            stage_text = " ".join(f"{stage}={value}" for stage, value in rule.get("stages", {}).items())
+            lines.append(f"  {stage_text:<24} {rule['ref']}（{rule['verifier']}）")
     return "\n".join(lines)
 
 

package/src/core/code-flow/scripts/cf_spec_gate.py

@@ -116,6 +116,8 @@ def _binding_issues(
         status = rule.stage_status.get(stage)
         if status is None:
             continue
+        if stage in ("code", "review") and getattr(rule, "verifier_stage", "code") != stage:
+            continue
         if rule.enforcement == "advisory" and status.status == "pending":
             continue
         code = "missing_spec" if binding.status == "missing" else _status_issue(rule, status, now, diff_sha256, allow_cheap_skips)

package/src/core/code-flow/scripts/cf_spec_metadata.py

@@ -15,6 +15,7 @@ from typing import Mapping, Optional
 ALLOWED_STAGES = frozenset(("prd", "design", "plan", "code", "review"))
 ALLOWED_ENFORCEMENT = frozenset(("required", "advisory"))
 ALLOWED_VERIFIERS = frozenset(("document", "regex", "ast", "command", "test", "manual"))
+ALLOWED_VERIFIER_STAGES = frozenset(("code", "review"))
 _ID_RE = re.compile(r"^[a-z0-9]+(?:-[a-z0-9]+)*$")
 _RULE_ID_RE = re.compile(r"^RULE-[a-z0-9]+(?:-[a-z0-9]+)*-\d{3}$")
 _EXPLICIT_RULE_RE = re.compile(r"^\[(RULE-[a-z0-9-]+-\d{3})\]\s+(.+)$")
@@ -52,6 +53,8 @@ class SpecVerifier:
     rule: str
     type: str
     config: Mapping[str, object]
+    stage: str = "code"
+    files: tuple[str, ...] = ()
 
 
 @dataclass(frozen=True)
@@ -209,7 +212,26 @@ def _validate_checks(meta: Mapping[str, object], path: str, raw: str) -> tuple[M
     return tuple(value)
 
 
-def _parse_verifiers(meta: Mapping[str, object], path: str, raw: str) -> tuple[SpecVerifier, ...]:
+def _parse_verifier_files(value: object, path: str, raw: str, index: int) -> tuple[str, ...]:
+    line = _verifier_field_line(raw, index, "files")
+    if not isinstance(value, list) or not value:
+        raise SpecMetadataError(path, f"verifiers[{index}].files", line, "必须是非空 glob 字符串数组")
+    files: list[str] = []
+    for item in value:
+        if not isinstance(item, str) or not item.strip():
+            raise SpecMetadataError(path, f"verifiers[{index}].files", line, "glob 必须是非空字符串")
+        text = item.strip().replace("\\", "/")
+        if text.startswith("/") or re.match(r"^[A-Za-z]:/", text):
+            raise SpecMetadataError(path, f"verifiers[{index}].files", line, f"禁止绝对路径: {item!r}")
+        if ".." in text.split("/"):
+            raise SpecMetadataError(path, f"verifiers[{index}].files", line, f"禁止 .. 跳出仓库: {item!r}")
+        files.append(text)
+    return tuple(files)
+
+
+def _parse_verifiers(
+    meta: Mapping[str, object], path: str, raw: str, stages: tuple[str, ...]
+) -> tuple[SpecVerifier, ...]:
     value = meta.get("verifiers", [])
     if not isinstance(value, list) or not all(isinstance(item, dict) for item in value):
         raise SpecMetadataError(path, "verifiers", _field_line(raw, "verifiers"), "必须是 mapping 列表")
@@ -219,6 +241,8 @@ def _parse_verifiers(meta: Mapping[str, object], path: str, raw: str) -> tuple[S
         rule = item.get("rule")
         kind = item.get("type")
         config = item.get("config")
+        explicit_stage = "stage" in item
+        stage = item.get("stage", "code")
         if not isinstance(rule, str) or not _RULE_ID_RE.fullmatch(rule):
             line = _verifier_field_line(raw, index, "rule")
             raise SpecMetadataError(path, f"verifiers[{index}].rule", line, "必须是稳定 RULE ID")
@@ -228,10 +252,17 @@ def _parse_verifiers(meta: Mapping[str, object], path: str, raw: str) -> tuple[S
         if not isinstance(config, dict):
             line = _verifier_field_line(raw, index, "config")
             raise SpecMetadataError(path, f"verifiers[{index}].config", line, "必须是 mapping")
+        if explicit_stage and (not isinstance(stage, str) or stage not in ALLOWED_VERIFIER_STAGES):
+            line = _verifier_field_line(raw, index, "stage")
+            raise SpecMetadataError(path, f"verifiers[{index}].stage", line, f"必须是 {sorted(ALLOWED_VERIFIER_STAGES)} 之一")
+        if explicit_stage and stage not in stages:
+            line = _verifier_field_line(raw, index, "stage")
+            raise SpecMetadataError(path, f"verifiers[{index}].stage", line, f"stage {stage!r} 未在 stages 声明: {', '.join(stages)}")
+        files = _parse_verifier_files(item["files"], path, raw, index) if "files" in item else ()
         if rule in seen:
             raise SpecMetadataError(path, "verifiers", _field_line(raw, "verifiers"), f"重复 verifier: {rule}")
         seen.add(rule)
-        result.append(SpecVerifier(rule=rule, type=kind, config=config))
+        result.append(SpecVerifier(rule=rule, type=kind, config=config, stage=stage, files=files))
     return tuple(result)
 
 
@@ -324,7 +355,7 @@ def parse_spec_metadata(content: str, path: str = "<memory>", raw_bytes: Optiona
     if owner is not None and (not isinstance(owner, str) or not owner.strip()):
         raise SpecMetadataError(path, "owner", _field_line(raw_frontmatter, "owner"), "必须是非空字符串")
     checks = _validate_checks(meta, path, raw_frontmatter)
-    verifiers = _parse_verifiers(meta, path, raw_frontmatter)
+    verifiers = _parse_verifiers(meta, path, raw_frontmatter, header.stages)
     body_line_offset = raw_frontmatter.count("\n") + 3
     rules = _parse_rules(body, path, body_line_offset)
     _validate_links(rules, verifiers, path, raw_frontmatter)

package/src/core/code-flow/scripts/cf_spec_verify.py

@@ -4,7 +4,7 @@
 from __future__ import annotations
 
 import ast
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
 from datetime import datetime, timezone
 import fnmatch
 import hashlib
@@ -59,19 +59,94 @@ def _cache_file(root: str) -> Path:
     return Path(root) / ".code-flow" / ".verifier-cache.json"
 
 
-def _cache_key(metadata: SpecMetadata, rule: SpecRule, verifier: SpecVerifier, scope: VerificationScope, confirmation: Optional[Mapping[str, object]]) -> str:
+def _cache_key(metadata: SpecMetadata, rule: SpecRule, verifier: SpecVerifier, scope: VerificationScope, confirmation: Optional[Mapping[str, object]], stage: str = "code") -> str:
     payload = {
         "spec": metadata.hashes.file_sha256,
         "rule": rule.text_sha256,
         "verifier": {"type": verifier.type, "config": verifier.config},
         "files": scope.files,
         "diff": scope.diff_sha256,
+        "stage": stage,
         "confirmation": confirmation or {},
         "artifact_content": _artifact_fingerprint(verifier, scope),
     }
     return hashlib.sha256(json.dumps(payload, ensure_ascii=False, sort_keys=True, default=str).encode()).hexdigest()
 
 
+def _normalize_scope_path(value: str) -> str:
+    return value.replace("\\", "/").strip()
+
+
+def _matches_scope(path: str, patterns: Sequence[str]) -> bool:
+    for pattern in patterns:
+        if fnmatch.fnmatchcase(path, pattern):
+            return True
+        bare = pattern.rstrip("/")
+        if not any(char in pattern for char in "*?[") and path.startswith(bare + "/"):
+            return True
+    return False
+
+
+def _git_tracked_files(root: str) -> tuple[str, ...]:
+    try:
+        outcome = subprocess.run(
+            ("git", "ls-files"), cwd=root, text=True, encoding="utf-8", capture_output=True, check=False
+        )
+    except OSError:
+        return ()
+    if outcome.returncode != 0:
+        return ()
+    return tuple(_normalize_scope_path(line) for line in outcome.stdout.splitlines() if line.strip())
+
+
+def scoped_files(verifier: SpecVerifier, scope: VerificationScope) -> tuple[str, ...]:
+    """作用域命中的文件集合：git tracked ∪ 任务持有文件，按 verifier.files 过滤。
+
+    决议仓库级集合（而非仅当前任务 diff）才能让未触及作用域的其他任务命中缓存。
+    """
+    if not verifier.files:
+        return ()
+    candidates = {_normalize_scope_path(item) for item in scope.files if item.strip()}
+    candidates.update(_git_tracked_files(scope.root))
+    return tuple(sorted(path for path in candidates if _matches_scope(path, verifier.files)))
+
+
+def _scope_fingerprint(root: str, files: Sequence[str]) -> str:
+    digest = hashlib.sha256()
+    for relative in files:
+        path = Path(root) / relative
+        digest.update(relative.encode("utf-8"))
+        try:
+            digest.update(path.read_bytes() if path.is_file() else b"<deleted>")
+        except OSError:
+            digest.update(b"<unreadable>")
+    return digest.hexdigest()
+
+
+def _scoped_cache_key(
+    metadata: SpecMetadata,
+    rule: SpecRule,
+    verifier: SpecVerifier,
+    scope: VerificationScope,
+    confirmation: Optional[Mapping[str, object]],
+    stage: str,
+) -> Optional[str]:
+    """command/test 仅在声明 files 作用域时缓存；未声明保持全量执行。"""
+    if verifier.type not in ("command", "test") or not verifier.files:
+        return None
+    files = scoped_files(verifier, scope)
+    payload = {
+        "spec": metadata.hashes.file_sha256,
+        "rule": rule.text_sha256,
+        "verifier": {"type": verifier.type, "config": verifier.config, "files": list(verifier.files)},
+        "stage": stage,
+        "scope_files": files,
+        "scope_sha256": _scope_fingerprint(scope.root, files),
+        "confirmation": confirmation or {},
+    }
+    return hashlib.sha256(json.dumps(payload, ensure_ascii=False, sort_keys=True, default=str).encode()).hexdigest()
+
+
 def _artifact_fingerprint(verifier: SpecVerifier, scope: VerificationScope) -> Optional[str]:
     if verifier.type != "document":
         return None
@@ -143,13 +218,32 @@ def _cached_or_run(
     verifier: SpecVerifier,
     scope: VerificationScope,
     confirmation: Optional[Mapping[str, object]],
+    stage: str = "code",
 ) -> VerificationEvidence:
     cacheable = verifier.type in _PURE_VERIFIER_TYPES
-    key = _cache_key(metadata, rule, verifier, scope, confirmation) if cacheable else ""
+    scoped_key: Optional[str] = None
+    if cacheable:
+        key = _cache_key(metadata, rule, verifier, scope, confirmation, stage)
+    else:
+        scoped_key = _scoped_cache_key(metadata, rule, verifier, scope, confirmation, stage)
+        if scoped_key is None:
+            key = ""
+        else:
+            cacheable, key = True, scoped_key
     if cacheable:
         cached = _cached_evidence(key)
         if cached is not None:
-            return cached
+            if scoped_key is None:
+                return cached
+            details = dict(cached.details or {})
+            details["cache_reused"] = True
+            details["scope_files"] = list(scoped_files(verifier, scope))
+            return replace(
+                cached,
+                executed_at=datetime.now(timezone.utc).isoformat(),
+                diff_sha256=scope.diff_sha256,
+                details=details,
+            )
     current = _evidence(metadata, rule, verifier, scope, confirmation)
     if cacheable and current.status == "verified":
         _save_result_cache(key, current)
@@ -400,6 +494,7 @@ def _run_all_verifiers(
     confirmations: Optional[Mapping[str, Mapping[str, object]]] = None,
     skip_command: bool = False,
     timeout_budget: Optional[float] = None,
+    stage: str = "code",
 ) -> VerificationResult:
     verifier_by_rule = {item.rule: item for item in metadata.verifiers}
     confirmation_by_rule = confirmations or {}
@@ -410,12 +505,14 @@ def _run_all_verifiers(
     for rule in metadata.rules:
         if rule.enforcement != "required":
             continue
+        verifier = verifier_by_rule.get(rule.ref)
+        if verifier is not None and verifier.stage != stage:
+            continue
         if timeout_budget is not None:
             remaining = timeout_budget - (time.monotonic() - started)
             if remaining <= 0:
                 evidence_by_ref[rule.ref] = _budget_evidence(metadata, rule, scope, timeout_budget)
                 continue
-        verifier = verifier_by_rule.get(rule.ref)
         if verifier is None:
             evidence_by_ref[rule.ref] = _missing_evidence(metadata, rule, scope)
             continue
@@ -427,11 +524,11 @@ def _run_all_verifiers(
             parallel.append((rule, verifier, confirmation))
             continue
         cap = None if timeout_budget is None else max(0.1, timeout_budget - (time.monotonic() - started))
-        evidence_by_ref[rule.ref] = _cached_or_run(metadata, rule, verifier, scope, confirmation) if cap is None else _evidence(metadata, rule, verifier, scope, confirmation, cap)
+        evidence_by_ref[rule.ref] = _cached_or_run(metadata, rule, verifier, scope, confirmation, stage) if cap is None else _evidence(metadata, rule, verifier, scope, confirmation, cap)
     if parallel:
         with ThreadPoolExecutor(max_workers=min(8, len(parallel))) as pool:
             futures = {
-                rule.ref: pool.submit(_cached_or_run, metadata, rule, verifier, scope, confirmation)
+                rule.ref: pool.submit(_cached_or_run, metadata, rule, verifier, scope, confirmation, stage)
                 for rule, verifier, confirmation in parallel
             }
             evidence_by_ref.update({ref: future.result() for ref, future in futures.items()})
@@ -442,9 +539,10 @@ def _run_all_verifiers(
 
 def run_all_verifiers(metadata: SpecMetadata, scope: VerificationScope,
                       confirmations: Optional[Mapping[str, Mapping[str, object]]] = None,
-                      skip_command: bool = False, timeout_budget: Optional[float] = None) -> VerificationResult:
+                      skip_command: bool = False, timeout_budget: Optional[float] = None,
+                      stage: str = "code") -> VerificationResult:
     with execution_session():
-        return _run_all_verifiers(metadata, scope, confirmations, skip_command, timeout_budget)
+        return _run_all_verifiers(metadata, scope, confirmations, skip_command, timeout_budget, stage)
 
 
 def evidence_is_fresh(

package/src/core/code-flow/scripts/cf_task_parallel.py

@@ -266,20 +266,12 @@ def prepare(root: Path, task_file: str, tasks: Sequence[str], run_id: Optional[s
             "base_head": outcome["base_head"], "worktrees": worktrees}
 
 
-def _collect_one(root: Path, entry: dict[str, object], base_head: str, task_file: str) -> dict[str, object]:
+def _collect_one(root: Path, entry: dict[str, object], base_head: str, task_file: str, commit: bool = True) -> dict[str, object]:
     task = str(entry["task"])
     path = Path(str(entry["path"]))
     branch = str(entry["branch"])
     if not path.is_dir():
         raise ParallelError("worktree_missing", f"{task}: worktree 不存在: {path}")
-    dirty = _status_paths(path)
-    if dirty:
-        raise ParallelError("worktree_dirty", f"{task}: 尚有未提交改动: {', '.join(dirty[:8])}")
-    if (path / MARKER).exists():
-        raise ParallelError("active_marker_present", f"{task}: marker 未清理，finish 未完成")
-    head = _run_git(path, ("rev-parse", "HEAD")).strip()
-    if head == base_head:
-        raise ParallelError("no_commits", f"{task}: worktree 无新提交")
     try:
         nodes = parse_task_file(str(path / task_file))
     except ValueError as exc:
@@ -287,12 +279,28 @@ def _collect_one(root: Path, entry: dict[str, object], base_head: str, task_file
     status = next((node.status for node in nodes if node.task_id == task), None)
     if status not in FINISHED_STATUSES:
         raise ParallelError("task_not_finished", f"{task}: Status 为 {status}，未通过 Done Gate")
+    if (path / MARKER).exists():
+        raise ParallelError("active_marker_present", f"{task}: marker 未清理，finish 未完成")
+    dirty = _status_paths(path)
+    if dirty:
+        # finish 会在通过后回写 Evidence/状态；任务已 done 且 marker 已清理时，
+        # 这些回写由 collect 自动提交（--no-commit 可关闭，保持严格模式）。
+        if not commit:
+            raise ParallelError(
+                "worktree_dirty",
+                f"{task}: 尚有未提交改动: {', '.join(dirty[:8])}；可在 worktree 内提交后重跑 collect，或去掉 --no-commit",
+            )
+        _run_git(path, ("add", "-A"))
+        _run_git(path, ("commit", "-q", "-m", f"cf-task({task}): finish 回写验收证据与任务状态"))
+    head = _run_git(path, ("rev-parse", "HEAD")).strip()
+    if head == base_head:
+        raise ParallelError("no_commits", f"{task}: worktree 无新提交")
     files = _run_git(root, ("diff", "--name-only", f"{base_head}..{branch}")).splitlines()
     return {"task": task, "branch": branch, "path": str(path), "head": head,
             "status": status, "files": sorted(item for item in files if item)}
 
 
-def collect(root: Path, run_id: str, tasks: Optional[Sequence[str]]) -> dict[str, object]:
+def collect(root: Path, run_id: str, tasks: Optional[Sequence[str]], commit: bool = True) -> dict[str, object]:
     root = root.resolve()
     meta = _read_run_meta(root, run_id)
     entries = [item for item in meta.get("worktrees", []) if isinstance(item, dict)]
@@ -302,7 +310,7 @@ def collect(root: Path, run_id: str, tasks: Optional[Sequence[str]]) -> dict[str
     results: list[dict[str, object]] = []
     for entry in entries:
         try:
-            results.append(_collect_one(root, entry, str(meta["base_head"]), str(meta["task_file"])))
+            results.append(_collect_one(root, entry, str(meta["base_head"]), str(meta["task_file"]), commit))
         except ParallelError as exc:
             results.append({"task": str(entry.get("task", "")), "ok": False, "code": exc.code, "message": exc.message})
     ok = bool(results) and all(item.get("code") is None for item in results)
@@ -363,6 +371,7 @@ def main(argv: Optional[Sequence[str]] = None, stdout: IO[str] = sys.stdout) ->
     for name in ("collect", "cleanup"):
         sub.choices[name].add_argument("--run-id", required=True)
     sub.choices["collect"].add_argument("--tasks", default="")
+    sub.choices["collect"].add_argument("--no-commit", action="store_true")
     sub.choices["cleanup"].add_argument("--force", action="store_true")
     args = parser.parse_args(argv)
     root = Path(args.root).resolve()
@@ -372,7 +381,7 @@ def main(argv: Optional[Sequence[str]] = None, stdout: IO[str] = sys.stdout) ->
             payload = prepare(root, args.task_file, tasks, args.run_id or None)
         elif args.action == "collect":
             tasks = [item.strip() for item in args.tasks.split(",") if item.strip()] or None
-            payload = collect(root, args.run_id, tasks)
+            payload = collect(root, args.run_id, tasks, commit=not args.no_commit)
         else:
             payload = cleanup(root, args.run_id, args.force)
     except ParallelError as exc:

package/src/core/code-flow/scripts/cf_task_runtime.py

@@ -48,6 +48,7 @@ class DoneResult:
     files: tuple[str, ...]
     evidence: tuple[Mapping[str, object], ...]
     message: str = ""
+    deferred_review: int = 0
 
 
 def _context_path(task_dir: str) -> str:
@@ -153,10 +154,11 @@ def _evidence_data(evidence: VerificationEvidence) -> Mapping[str, object]:
 
 
 def _update_rule(rule: RuleBinding, evidence: Mapping[str, object]) -> RuleBinding:
-    if "code" not in rule.stage_status:
+    stage = rule.verifier_stage or "code"
+    if stage not in rule.stage_status:
         return rule
     statuses = dict(rule.stage_status)
-    current = statuses["code"]
+    current = statuses[stage]
     if current.status in ("not_applicable", "waived"):
         return rule
     status = "verified" if evidence.get("status") == "verified" else "unverified"
@@ -168,9 +170,9 @@ def _update_rule(rule: RuleBinding, evidence: Mapping[str, object]) -> RuleBindi
         (item.get("verifier_ref"), item.get("result_sha256"), item.get("diff_sha256")) == signature
         for item in current.evidence
     ):
-        statuses["code"] = replace(current, status=status)
+        statuses[stage] = replace(current, status=status)
     else:
-        statuses["code"] = replace(current, status=status, evidence=(*current.evidence, evidence))
+        statuses[stage] = replace(current, status=status, evidence=(*current.evidence, evidence))
     return replace(rule, stage_status=statuses)
 
 
@@ -267,9 +269,11 @@ def _run_done_gate(root: str, task_dir: str, cheap: bool = False, budget: Option
     diff_hash = _diff_hash(root, scope_result.files)
     phase_timing("done.load_context_and_diff", phase_started)
     all_evidence: list[Mapping[str, object]] = []
+    deferred_review = 0
     for binding in context.bindings:
         phase_started = time.monotonic()
         metadata = load_spec_metadata(str(Path(root) / ".code-flow/specs" / binding.path))
+        deferred_review += sum(1 for rule in binding.rules if rule.verifier_stage == "review")
         confirmations: dict[str, Mapping[str, object]] = {}
         for rule in binding.rules:
             confirmation = _rule_manual_confirmation(rule)
@@ -277,7 +281,8 @@ def _run_done_gate(root: str, task_dir: str, cheap: bool = False, budget: Option
                 confirmations[rule.ref] = confirmation
         remaining = None if budget is None else budget - (time.monotonic() - started)
         result = run_all_verifiers(
-            metadata, VerificationScope(root, scope_result.files, diff_hash), confirmations, cheap, remaining
+            metadata, VerificationScope(root, scope_result.files, diff_hash), confirmations, cheap, remaining,
+            stage="code",
         )
         phase_timing(f"done.verify.{binding.spec_id}", phase_started)
         all_evidence.extend(_evidence_data(item) for item in result.evidence)
@@ -288,10 +293,10 @@ def _run_done_gate(root: str, task_dir: str, cheap: bool = False, budget: Option
     if gate.decision == "pass" and not cheap:
         validation_issue = _run_finish_validation(root, scope_result.files)
         if validation_issue:
-            return DoneResult("block", scope_result.files, tuple(all_evidence), validation_issue)
+            return DoneResult("block", scope_result.files, tuple(all_evidence), validation_issue, deferred_review)
     phase_timing("done.total", started)
     return DoneResult(gate.decision, scope_result.files, tuple(all_evidence),
-                      "; ".join(issue.message for issue in gate.errors))
+                      "; ".join(issue.message for issue in gate.errors), deferred_review)
 
 
 def run_done_gate(root: str, task_dir: str, cheap: bool = False, budget: Optional[float] = None, include_e2e: bool = False, task_id: str = "") -> DoneResult:

package/src/core/code-flow/scripts/cf_task_workflow.py

@@ -11,8 +11,12 @@ import sys
 
 from cf_acceptance_runner import run_manifest
 from cf_acceptance_schema import load_manifest, validate_execution_baseline, verified_evidence
+from cf_spec_context import ContextError, _git_changes, _run_git, load_context, save_context
+from cf_spec_gate import validate_stage
+from cf_spec_metadata import load_spec_metadata
+from cf_spec_verify import VerificationScope, _git_tracked_files, run_all_verifiers
 from cf_task_index import parse_task_file
-from cf_task_runtime import run_done_gate
+from cf_task_runtime import _apply_evidence, _evidence_data, run_done_gate
 from cf_workflow_service import (FINISHED_STATUSES, _require_marker_task,
                                  _sync_markdown, block_task, complete_task, locate_task_file, resume_task)
 from cf_workflow_transaction import recover_transition
@@ -23,7 +27,10 @@ def finish_task(root: str, directory: str, task_file: str, task_id: str) -> dict
     gate = run_done_gate(root, directory, task_id=task_id)
     if gate.decision != "pass":
         return {"decision": "block", "reason": gate.message, "evidence": gate.evidence}
-    return {"decision": "pass", **complete_task(root, directory, task_file, task_id, True)}
+    result = {"decision": "pass", "deferred_review": gate.deferred_review, **complete_task(root, directory, task_file, task_id, True)}
+    if gate.deferred_review:
+        result["deferred_hint"] = f"{gate.deferred_review} review-layer verifier(s) deferred; run cf-task:verify-e2e for the requirement directory"
+    return result
 
 
 def _demand_tasks(directory: Path) -> list[tuple[Path, str, str]]:
@@ -44,6 +51,79 @@ def _demand_tasks(directory: Path) -> list[tuple[Path, str, str]]:
     return tasks
 
 
+def _head_token(root: str) -> str:
+    try:
+        return "head:" + _run_git(root, ("rev-parse", "HEAD")).strip()
+    except ContextError:
+        return "head:none"
+
+
+def _review_scope(root: str) -> VerificationScope:
+    files = set(_git_tracked_files(root))
+    try:
+        files.update(_git_changes(root))
+    except ContextError:
+        pass
+    return VerificationScope(root, tuple(sorted(files)), _head_token(root))
+
+
+def collect_review_bindings(directory: Path) -> dict[str, dict[str, object]]:
+    """收集需求目录下全部 task context 的 review 层绑定。
+
+    返回 spec_id -> {"path": spec 相对路径, "rules": {rule_ref: [(context_path, context), ...]}}。
+    读取失败 fail-closed（报告文件与原因），不允许静默跳过。
+    """
+    targets: dict[str, dict[str, object]] = {}
+    for ctx_path in sorted(directory.rglob("spec-context.yml")):
+        try:
+            context = load_context(str(ctx_path))
+        except (ContextError, OSError, ValueError) as exc:
+            raise ValueError(f"review_context_unreadable: {ctx_path}: {exc}") from exc
+        for binding in context.bindings:
+            for rule in binding.rules:
+                if rule.verifier_stage != "review":
+                    continue
+                entry = targets.setdefault(binding.spec_id, {"path": binding.path, "rules": {}})
+                entry["rules"].setdefault(rule.ref, []).append((ctx_path, context))
+    return targets
+
+
+def _run_review_targets(root: str, targets: dict[str, dict[str, object]]) -> dict[str, object]:
+    """执行 review 层 verifier（按 spec/rule 去重），证据写回全部相关 context。"""
+    executed = reused = 0
+    failures: list[str] = []
+    context_paths: set[Path] = set()
+    scope = _review_scope(root)
+    for spec_id in sorted(targets):
+        info = targets[spec_id]
+        metadata = load_spec_metadata(str(Path(root) / ".code-flow/specs" / str(info["path"])))
+        result = run_all_verifiers(metadata, scope, stage="review")
+        by_rule: dict[str, object] = {}
+        for evidence in result.evidence:
+            rule_ref = evidence.verifier_ref.split("#", 1)[-1]
+            by_rule[rule_ref] = evidence
+            if evidence.status != "verified":
+                failures.append(evidence.verifier_ref)
+            elif (evidence.details or {}).get("cache_reused"):
+                reused += 1
+            else:
+                executed += 1
+        for rule_ref, entries in info["rules"].items():
+            evidence = by_rule.get(rule_ref)
+            if evidence is None:
+                continue
+            payload = (_evidence_data(evidence),)
+            for ctx_path, context in entries:
+                context_paths.add(ctx_path)
+                updated = _apply_evidence(context, payload)
+                if updated != context:
+                    save_context(str(ctx_path), updated)
+    for ctx_path in sorted(context_paths):
+        gate = validate_stage(load_context(str(ctx_path)), "review", diff_sha256=scope.diff_sha256)
+        failures.extend(f"{issue.spec_id}#{issue.rule_ref}" for issue in gate.errors)
+    return {"executed": executed, "reused": reused, "failed": sorted(set(failures))}
+
+
 def verify_e2e(root: str, directory: str) -> dict[str, object]:
     recover_transition(root)
     tasks = _demand_tasks(Path(directory))
@@ -52,18 +132,36 @@ def verify_e2e(root: str, directory: str) -> dict[str, object]:
         return {"decision": "block", "reason": "unfinished_tasks", "tasks": unfinished}
     if (Path(root) / ".code-flow/.active-task.json").exists():
         return {"decision": "block", "reason": "finish_active_task_first"}
+    try:
+        targets = collect_review_bindings(Path(directory))
+    except ValueError as exc:
+        return {"decision": "block", "reason": "review_context_unreadable", "detail": str(exc)}
     manifest = Path(directory) / ".acceptance-manifest.json"
-    data = load_manifest(manifest)
-    validate_execution_baseline(manifest, data)
-    bound_task = (manifest.parent / str(data.get("task_file", ""))).resolve()
-    if {task.resolve() for task, _, _ in tasks} != {bound_task}:
-        return {"decision": "block", "reason": "acceptance_manifest_task_mismatch"}
-    required = [row["id"] for row in data["scenarios"] if row.get("kind", "functional") != "e2e"
-                and not verified_evidence(row)]
-    if required:
-        return {"decision": "block", "reason": "functional_or_manual_evidence_missing", "scenarios": required}
-    result = run_manifest(str(manifest), root, write_evidence=True, only_e2e=True)
-    if result["decision"] == "pass":
+    if not targets and not manifest.exists():
+        return {"decision": "pass", "executed": 0, "reused": 0, "failed": [], "reason": "nothing_to_verify"}
+    review = _run_review_targets(root, targets) if targets else {"executed": 0, "reused": 0, "failed": []}
+    acceptance: dict[str, object] = {"decision": "pass", "results": []}
+    if manifest.exists():
+        data = load_manifest(manifest)
+        validate_execution_baseline(manifest, data)
+        bound_task = (manifest.parent / str(data.get("task_file", ""))).resolve()
+        if {task.resolve() for task, _, _ in tasks} != {bound_task}:
+            return {"decision": "block", "reason": "acceptance_manifest_task_mismatch"}
+        required = [row["id"] for row in data["scenarios"] if row.get("kind", "functional") != "e2e"
+                    and not verified_evidence(row)]
+        if required:
+            return {"decision": "block", "reason": "functional_or_manual_evidence_missing", "scenarios": required}
+        acceptance = run_manifest(str(manifest), root, write_evidence=True, only_e2e=True)
+    decision = "pass" if not review["failed"] and acceptance.get("decision") == "pass" else "block"
+    result = {
+        **acceptance,
+        "decision": decision,
+        "executed": review["executed"],
+        "reused": review["reused"],
+        "failed": review["failed"],
+        "review": review,
+    }
+    if decision == "pass":
         for task_file, task_id, _ in tasks:
             _sync_markdown(str(task_file), task_id, "verified")
     return result