sillyspec 3.23.5 → 3.23.7

package/.claude/skills/sillyspec-brainstorm/SKILL.md

@@ -1,86 +1,86 @@
----
-name: sillyspec:brainstorm
-description: 用于正式开始开发前的需求澄清和技术方案设计。适合用户提出新功能、新模块、架构调整、复杂改造，或说"先做需求分析、输出技术方案、创建变更前先梳理、帮我设计下"。产出结构化方案（design/proposal/requirements/tasks 四件套），但不直接写代码。
----
-
-## 交互规范
-
-**当需要用户从多个选项中做出选择时，必须使用 Claude Code 内置的 AskUserQuestion 工具，将选项以参数传入。** 不要用编号列表让用户手动输入数字。
-
-## 何时使用
-
-- 用户提出新功能、新模块、架构调整、复杂改造
-- 用户说"先做需求分析、输出技术方案、创建变更前先梳理、帮我设计下"
-- 产出：`design.md` + `proposal.md` + `requirements.md` + `tasks.md`（四件套），不写代码
-
-## 多变更说明
-
-项目有多个活跃变更（`.sillyspec/changes/` 下有多个目录）时，所有 `sillyspec run` 命令需加 `--change <变更名>` 指定操作目标；只有一个变更时可省略（CLI 自动检测）。建议变更名格式：`YYYY-MM-DD-<简短描述>`。
-
-## 步骤生命周期（所有阶段通用）
-
-> `sillyspec brainstorm` 是 `sillyspec run brainstorm` 的顶层别名，两者等价。
-
-```bash
-sillyspec run brainstorm                       # 输出当前步骤 prompt
-sillyspec run brainstorm --done --output "摘要"     # 完成当前步骤（--input "用户原话" 记录输入）
-sillyspec run brainstorm --status              # 查看阶段进度
-sillyspec run brainstorm --skip                # 跳过可选步骤
-sillyspec run brainstorm --reset               # 重置阶段（从头开始）
-sillyspec run brainstorm --reopen --from-step N     # 重新打开已完成阶段修订（N=序号或名称）
-sillyspec run brainstorm --wait --reason "..." --options "A,B"   # 暂停等用户决策
-sillyspec run brainstorm --continue --answer "..."               # 恢复等待中的步骤
-sillyspec run brainstorm --done --answer "..." --output "..."    # 一步完成 wait+done
-```
-
-## 通用参数（所有阶段适用）
-
-| 参数 | 说明 |
-|---|---|
-| `--change <名>` | 指定变更名（多活跃变更必填，单变更可省略自动检测） |
-| `--spec-dir <path>` | 指定规范目录（默认 `<项目>/.sillyspec`） |
-| `--non-interactive` | CI/脚本下禁用交互式 prompt |
-| `--interactive` | 强制交互（即便 stdin 非 TTY） |
-| `--skip-approval` | 跳过审批/校验门控（需明确意图） |
-| `--json` | 输出 JSON（程序化读取） |
-
-## brainstorm 特有：requiresWait 步骤
-
-某些步骤（如"对话式探索"）需要用户输入。两种方式：
-
-> 自动去重：若前置 step 已对同一问题（waitReason 归一化后相同，如"确认设计方案" vs "最终确认设计方案"）确认过，后续重复 wait 会自动跳过，无需再 `--wait`。
-
-- **方式一（推荐）**：AI 自行与用户交互后，一步完成：
-  ```bash
-  sillyspec run brainstorm --done --change <名> --answer "用户回答" --output "需求已澄清"
-  ```
-- **方式二**：分步——先 `--wait` 记录等待，再 `--continue --answer`，最后 `--done`：
-  ```bash
-  sillyspec run brainstorm --wait --change <名> --reason "等待用户回答" --output "探索问题"
-  sillyspec run brainstorm --continue --answer "用户回答" --change <名>
-  sillyspec run brainstorm --done --change <名> --output "需求已澄清"
-  ```
-
-## 阶段流转
-
-```
-                ┌─ scale=large → plan（四件套齐）
-scan → brainstorm ┤
-                └─ scale=small → quick --linked-changes（仅 design.md）
-```
-
-brainstorm 完成时按 design.md frontmatter 的 `scale` 分叉：
-- **large**（多文件/跨模块/有状态机或 schema 变更）：四件套齐 + 自审通过 → `sillyspec run plan --change <变更名>`
-- **small**（≤2 文件、单模块、无跨模块依赖）：仅生成 design.md → `sillyspec run quick --linked-changes <变更名>`
-
-> 规模由 AI 在 brainstorm 最后一步评估并写入 design.md frontmatter。判错可手动改 `scale` 后再跑相应阶段。
-
-## 铁律
-
-- **必须用 exec 工具（shell）执行 CLI，不要自己编造流程**
-- 只做当前步骤 prompt 描述的操作，不跳过、不自行扩展
-- 产物写入 CLI 输出的 `changeDir` 目录（如 `<changeDir>/design.md`），不要自己拼路径
-- 完成后立即 `--done`，不跳过
-
-## 用户指令
-$ARGUMENTS
+---
+name: sillyspec:brainstorm
+description: 用于正式开始开发前的需求澄清和技术方案设计。适合用户提出新功能、新模块、架构调整、复杂改造，或说"先做需求分析、输出技术方案、创建变更前先梳理、帮我设计下"。产出结构化方案（design/proposal/requirements/tasks 四件套），但不直接写代码。
+---
+
+## 交互规范
+
+**当需要用户从多个选项中做出选择时，必须使用 Claude Code 内置的 AskUserQuestion 工具，将选项以参数传入。** 不要用编号列表让用户手动输入数字。
+
+## 何时使用
+
+- 用户提出新功能、新模块、架构调整、复杂改造
+- 用户说"先做需求分析、输出技术方案、创建变更前先梳理、帮我设计下"
+- 产出：`design.md` + `proposal.md` + `requirements.md` + `tasks.md`（四件套），不写代码
+
+## 多变更说明
+
+项目有多个活跃变更（`.sillyspec/changes/` 下有多个目录）时，所有 `sillyspec run` 命令需加 `--change <变更名>` 指定操作目标；只有一个变更时可省略（CLI 自动检测）。建议变更名格式：`YYYY-MM-DD-<简短描述>`。
+
+## 步骤生命周期（所有阶段通用）
+
+> `sillyspec brainstorm` 是 `sillyspec run brainstorm` 的顶层别名，两者等价。
+
+```bash
+sillyspec run brainstorm                       # 输出当前步骤 prompt
+sillyspec run brainstorm --done --output "摘要"     # 完成当前步骤（--input "用户原话" 记录输入）
+sillyspec run brainstorm --status              # 查看阶段进度
+sillyspec run brainstorm --skip                # 跳过可选步骤
+sillyspec run brainstorm --reset               # 重置阶段（从头开始）
+sillyspec run brainstorm --reopen --from-step N     # 重新打开已完成阶段修订（N=序号或名称）
+sillyspec run brainstorm --wait --reason "..." --options "A,B"   # 暂停等用户决策
+sillyspec run brainstorm --continue --answer "..."               # 恢复等待中的步骤
+sillyspec run brainstorm --done --answer "..." --output "..."    # 一步完成 wait+done
+```
+
+## 通用参数（所有阶段适用）
+
+| 参数 | 说明 |
+|---|---|
+| `--change <名>` | 指定变更名（多活跃变更必填，单变更可省略自动检测） |
+| `--spec-dir <path>` | 指定规范目录（默认 `<项目>/.sillyspec`） |
+| `--non-interactive` | CI/脚本下禁用交互式 prompt |
+| `--interactive` | 强制交互（即便 stdin 非 TTY） |
+| `--skip-approval` | 跳过审批/校验门控（需明确意图） |
+| `--json` | 输出 JSON（程序化读取） |
+
+## brainstorm 特有：requiresWait 步骤
+
+某些步骤（如"对话式探索"）需要用户输入。两种方式：
+
+> 自动去重：若前置 step 已对同一问题（waitReason 归一化后相同，如"确认设计方案" vs "最终确认设计方案"）确认过，后续重复 wait 会自动跳过，无需再 `--wait`。
+
+- **方式一（推荐）**：AI 自行与用户交互后，一步完成：
+  ```bash
+  sillyspec run brainstorm --done --change <名> --answer "用户回答" --output "需求已澄清"
+  ```
+- **方式二**：分步——先 `--wait` 记录等待，再 `--continue --answer`，最后 `--done`：
+  ```bash
+  sillyspec run brainstorm --wait --change <名> --reason "等待用户回答" --output "探索问题"
+  sillyspec run brainstorm --continue --answer "用户回答" --change <名>
+  sillyspec run brainstorm --done --change <名> --output "需求已澄清"
+  ```
+
+## 阶段流转
+
+```
+                ┌─ scale=large → plan（四件套齐）
+scan → brainstorm ┤
+                └─ scale=small → quick --linked-changes（仅 design.md）
+```
+
+brainstorm 完成时按 design.md frontmatter 的 `scale` 分叉：
+- **large**（多文件/跨模块/有状态机或 schema 变更）：四件套齐 + Design Grill 审查通过（tier=independent 时由独立审查子代理产出 stage review.json）→ `sillyspec run plan --change <变更名>`
+- **small**（≤2 文件、单模块、无跨模块依赖）：仅生成 design.md → `sillyspec run quick --linked-changes <变更名>`
+
+> 规模由 AI 在 brainstorm 最后一步评估并写入 design.md frontmatter。判错可手动改 `scale` 后再跑相应阶段。
+
+## 铁律
+
+- **必须用 exec 工具（shell）执行 CLI，不要自己编造流程**
+- 只做当前步骤 prompt 描述的操作，不跳过、不自行扩展
+- 产物写入 CLI 输出的 `changeDir` 目录（如 `<changeDir>/design.md`），不要自己拼路径
+- 完成后立即 `--done`，不跳过
+
+## 用户指令
+$ARGUMENTS

package/.claude/skills/sillyspec-plan/SKILL.md

@@ -1,74 +1,74 @@
----
-name: sillyspec:plan
-description: 用于把 design 拆解为可执行的实现计划。适合用户说"拆任务、做计划、排 wave、规划实现步骤"。产出 plan.md（Wave 分组 + Task 列表 + 依赖关系）。
----
-
-## 何时使用
-
-- 用户说"拆任务、做计划、排 wave、规划实现步骤"
-- 把 brainstorm 的 design.md 拆成可执行的 Wave + Task
-- 产出：`plan.md`（Wave 分组 + Task 列表 + 依赖关系），可能含 `tasks/task-NN.md` 任务蓝图
-
-## 多变更说明
-
-项目有多个活跃变更（`.sillyspec/changes/` 下有多个目录）时，所有 `sillyspec run` 命令需加 `--change <变更名>` 指定操作目标；只有一个变更时可省略（CLI 自动检测）。
-
-## 步骤生命周期（所有阶段通用）
-
-> `sillyspec plan` 是 `sillyspec run plan` 的顶层别名，两者等价。
-
-```bash
-sillyspec run plan                             # 输出当前步骤 prompt
-sillyspec run plan --done --output "摘要"      # 完成当前步骤（--input "用户原话" 记录输入）
-sillyspec run plan --status                    # 查看阶段进度
-sillyspec run plan --skip                      # 跳过可选步骤
-sillyspec run plan --reset                     # 重置阶段（从头开始）
-sillyspec run plan --reopen --from-step N      # 重新打开已完成阶段修订（N=序号或名称）
-sillyspec run plan --wait --reason "..." --options "A,B"   # 暂停等用户决策
-sillyspec run plan --continue --answer "..."               # 恢复等待中的步骤
-sillyspec run plan --done --answer "..." --output "..."    # 一步完成 wait+done
-```
-
-## 通用参数（所有阶段适用）
-
-| 参数 | 说明 |
-|---|---|
-| `--change <名>` | 指定变更名（多活跃变更必填，单变更可省略自动检测） |
-| `--spec-dir <path>` | 指定规范目录（默认 `<项目>/.sillyspec`） |
-| `--non-interactive` | CI/脚本下禁用交互式 prompt |
-| `--interactive` | 强制交互（即便 stdin 非 TTY） |
-| `--skip-approval` | 跳过审批/校验门控（需明确意图） |
-| `--json` | 输出 JSON（程序化读取） |
-
-## plan 特有
-
-### 动态步骤
-
-plan 的步骤是动态的：`generate_plan` 步骤完成后，CLI 会从刚生成的 `plan.md` 解析出 task，自动插入"任务蓝图协调器"步骤（per-task）。这是正常行为，不要手动添加。
-
-### 契约门控（阻断完成）
-
-- **plan 启动前**：CLI 校验 `design.md` 是否满足 plan 契约（缺文件变更清单/风险登记/自审章节会阻断）。若失败需先 `sillyspec run brainstorm --reopen --from-step N` 修订设计。
-- **plan 完成时**：CLI 校验 `plan.md` 是否满足 execute 契约（Wave 结构、task 引用等）。失败会阻断完成，提示修复后重新 `--done`。
-
-### 生产接线路径检查
-
-plan 完成校验会检查：design 提到入口文件（cli.ts/main.ts/server.ts 等）但 task 的 allowed_paths 不含该文件 → 报 error。若确实不需要改入口，在 design.md 明示理由。
-
-## 阶段流转
-
-```
-brainstorm → plan → execute
-```
-
-plan 完成后（plan.md 通过 execute 契约校验），运行 `sillyspec run execute --change <变更名>` 开始实现。
-
-## 铁律
-
-- **必须用 exec 工具（shell）执行 CLI，不要自己编造流程**
-- 只做当前步骤 prompt 描述的操作，不跳过、不自行扩展
-- plan.md 是任务完成的唯一真相源，task 拆解粒度要均匀、依赖要明确
-- 完成后立即 `--done`，不跳过
-
-## 用户指令
-$ARGUMENTS
+---
+name: sillyspec:plan
+description: 用于把 design 拆解为可执行的实现计划。适合用户说"拆任务、做计划、排 wave、规划实现步骤"。产出 plan.md（Wave 分组 + Task 列表 + 依赖关系）。
+---
+
+## 何时使用
+
+- 用户说"拆任务、做计划、排 wave、规划实现步骤"
+- 把 brainstorm 的 design.md 拆成可执行的 Wave + Task
+- 产出：`plan.md`（Wave 分组 + Task 列表 + 依赖关系），可能含 `tasks/task-NN.md` 任务蓝图
+
+## 多变更说明
+
+项目有多个活跃变更（`.sillyspec/changes/` 下有多个目录）时，所有 `sillyspec run` 命令需加 `--change <变更名>` 指定操作目标；只有一个变更时可省略（CLI 自动检测）。
+
+## 步骤生命周期（所有阶段通用）
+
+> `sillyspec plan` 是 `sillyspec run plan` 的顶层别名，两者等价。
+
+```bash
+sillyspec run plan                             # 输出当前步骤 prompt
+sillyspec run plan --done --output "摘要"      # 完成当前步骤（--input "用户原话" 记录输入）
+sillyspec run plan --status                    # 查看阶段进度
+sillyspec run plan --skip                      # 跳过可选步骤
+sillyspec run plan --reset                     # 重置阶段（从头开始）
+sillyspec run plan --reopen --from-step N      # 重新打开已完成阶段修订（N=序号或名称）
+sillyspec run plan --wait --reason "..." --options "A,B"   # 暂停等用户决策
+sillyspec run plan --continue --answer "..."               # 恢复等待中的步骤
+sillyspec run plan --done --answer "..." --output "..."    # 一步完成 wait+done
+```
+
+## 通用参数（所有阶段适用）
+
+| 参数 | 说明 |
+|---|---|
+| `--change <名>` | 指定变更名（多活跃变更必填，单变更可省略自动检测） |
+| `--spec-dir <path>` | 指定规范目录（默认 `<项目>/.sillyspec`） |
+| `--non-interactive` | CI/脚本下禁用交互式 prompt |
+| `--interactive` | 强制交互（即便 stdin 非 TTY） |
+| `--skip-approval` | 跳过审批/校验门控（需明确意图） |
+| `--json` | 输出 JSON（程序化读取） |
+
+## plan 特有
+
+### 动态步骤
+
+plan 的步骤是动态的：`generate_plan`（生成分级计划）→ `review_plan`（审查计划，按规模分级：tier=self 当前 agent 自审 / tier=independent 启动独立审查子代理产出 stage review.json，避免生成+自审同一次输出的偏差）→ CLI 从 `plan.md` 解析出 task 自动插入"任务蓝图协调器"步骤（per-task）。这是正常行为，不要手动添加。
+
+### 契约门控（阻断完成）
+
+- **plan 启动前**：CLI 校验 `design.md` 是否满足 plan 契约（缺文件变更清单/风险登记/自审章节会阻断）。若失败需先 `sillyspec run brainstorm --reopen --from-step N` 修订设计。
+- **plan 完成时**：CLI 校验 `plan.md` 是否满足 execute 契约（Wave 结构、task 引用等）。失败会阻断完成，提示修复后重新 `--done`。
+
+### 生产接线路径检查
+
+plan 完成校验会检查：design 提到入口文件（cli.ts/main.ts/server.ts 等）但 task 的 allowed_paths 不含该文件 → 报 error。若确实不需要改入口，在 design.md 明示理由。
+
+## 阶段流转
+
+```
+brainstorm → plan → execute
+```
+
+plan 完成后（plan.md 通过 execute 契约校验），运行 `sillyspec run execute --change <变更名>` 开始实现。
+
+## 铁律
+
+- **必须用 exec 工具（shell）执行 CLI，不要自己编造流程**
+- 只做当前步骤 prompt 描述的操作，不跳过、不自行扩展
+- plan.md 是任务完成的唯一真相源，task 拆解粒度要均匀、依赖要明确
+- 完成后立即 `--done`，不跳过
+
+## 用户指令
+$ARGUMENTS

package/.claude/skills/sillyspec-propose/SKILL.md

@@ -1,61 +1,61 @@
----
-name: sillyspec:propose
-description: 生成结构化规范 — proposal + design + tasks。适合用户说"生成规范、补全四件套、propose"。产出 proposal.md + design.md + tasks.md（+ 可能的 requirements.md）。
----
-
-## 何时使用
-
-- 用户说"生成规范、补全四件套、propose"
-- 已有零散设计/需求，需补全结构化规范四件套
-- 产出：`proposal.md` + `design.md` + `tasks.md`（+ 可选 `requirements.md`）
-
-> 注：propose 与 brainstorm 都产出四件套。brainstorm 是从需求开始的完整设计流程；propose 更偏"补全/生成规范"。新需求一般走 brainstorm。
-
-## 多变更说明
-
-项目有多个活跃变更（`.sillyspec/changes/` 下有多个目录）时，所有 `sillyspec run` 命令需加 `--change <变更名>` 指定操作目标；只有一个变更时可省略（CLI 自动检测）。
-
-## 步骤生命周期（所有阶段通用）
-
-> `sillyspec run propose` 需用 `run` 形式（propose 无顶层别名，与 brainstorm/plan 等不同）。
-
-```bash
-sillyspec run propose                          # 输出当前步骤 prompt
-sillyspec run propose --done --output "摘要"   # 完成当前步骤
-sillyspec run propose --status                 # 查看阶段进度
-sillyspec run propose --skip                   # 跳过可选步骤
-sillyspec run propose --reset                  # 重置阶段（从头开始）
-sillyspec run propose --reopen --from-step N   # 重新打开已完成阶段修订
-```
-
-## 通用参数（所有阶段适用）
-
-| 参数 | 说明 |
-|---|---|
-| `--change <名>` | 指定变更名（多活跃变更必填，单变更可省略自动检测） |
-| `--spec-dir <path>` | 指定规范目录（默认 `<项目>/.sillyspec`） |
-| `--non-interactive` | CI/脚本下禁用交互式 prompt |
-| `--skip-approval` | 跳过审批/校验门控 |
-| `--json` | 输出 JSON（程序化读取） |
-
-## propose 特有：自检门控
-
-propose 含自检步骤，完成时校验四件套文档齐全 + 内容章节（如 proposal 的 Non-Goals、design 的文件变更清单/风险登记/自审）。缺失会阻断完成。
-
-## 阶段流转
-
-```
-(零散设计/需求) → propose → plan
-```
-
-propose 完成后（四件套齐 + 自检通过），运行 `sillyspec run plan --change <变更名>` 进入实现计划。
-
-## 铁律
-
-- **必须用 exec 工具（shell）执行 CLI，不要自己编造流程**
-- 只做当前步骤 prompt 描述的操作，不跳过
-- 产物写入 CLI 输出的 `changeDir` 目录
-- 完成后立即 `--done`，不跳过
-
-## 用户指令
-$ARGUMENTS
+---
+name: sillyspec:propose
+description: 生成结构化规范 — proposal + design + tasks。适合用户说"生成规范、补全四件套、propose"。产出 proposal.md + design.md + tasks.md（+ 可能的 requirements.md）。
+---
+
+## 何时使用
+
+- 用户说"生成规范、补全四件套、propose"
+- 已有零散设计/需求，需补全结构化规范四件套
+- 产出：`proposal.md` + `design.md` + `tasks.md`（+ 可选 `requirements.md`）
+
+> 注：propose 与 brainstorm 都产出四件套。brainstorm 是从需求开始的完整设计流程；propose 更偏"补全/生成规范"。新需求一般走 brainstorm。
+
+## 多变更说明
+
+项目有多个活跃变更（`.sillyspec/changes/` 下有多个目录）时，所有 `sillyspec run` 命令需加 `--change <变更名>` 指定操作目标；只有一个变更时可省略（CLI 自动检测）。
+
+## 步骤生命周期（所有阶段通用）
+
+> `sillyspec run propose` 需用 `run` 形式（propose 无顶层别名，与 brainstorm/plan 等不同）。
+
+```bash
+sillyspec run propose                          # 输出当前步骤 prompt
+sillyspec run propose --done --output "摘要"   # 完成当前步骤
+sillyspec run propose --status                 # 查看阶段进度
+sillyspec run propose --skip                   # 跳过可选步骤
+sillyspec run propose --reset                  # 重置阶段（从头开始）
+sillyspec run propose --reopen --from-step N   # 重新打开已完成阶段修订
+```
+
+## 通用参数（所有阶段适用）
+
+| 参数 | 说明 |
+|---|---|
+| `--change <名>` | 指定变更名（多活跃变更必填，单变更可省略自动检测） |
+| `--spec-dir <path>` | 指定规范目录（默认 `<项目>/.sillyspec`） |
+| `--non-interactive` | CI/脚本下禁用交互式 prompt |
+| `--skip-approval` | 跳过审批/校验门控 |
+| `--json` | 输出 JSON（程序化读取） |
+
+## propose 特有：自检门控
+
+propose 含自检步骤（按规模分级：tier=self 当前 agent 自审 / tier=independent 启动独立审查子代理产出 stage review.json），完成时校验四件套文档齐全 + 内容章节（如 proposal 的 Non-Goals、design 的文件变更清单/风险登记/自审）。缺失会阻断完成。
+
+## 阶段流转
+
+```
+(零散设计/需求) → propose → plan
+```
+
+propose 完成后（四件套齐 + 自检通过），运行 `sillyspec run plan --change <变更名>` 进入实现计划。
+
+## 铁律
+
+- **必须用 exec 工具（shell）执行 CLI，不要自己编造流程**
+- 只做当前步骤 prompt 描述的操作，不跳过
+- 产物写入 CLI 输出的 `changeDir` 目录
+- 完成后立即 `--done`，不跳过
+
+## 用户指令
+$ARGUMENTS

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sillyspec",
-  "version": "3.23.5",
+  "version": "3.23.7",
   "description": "SillySpec CLI — 流程状态机，让 AI 严格按步骤来",
   "icon": "logo.jpg",
   "homepage": "https://sillyspec.ppdmq.top/",

package/src/contract-matrix.js

@@ -134,8 +134,10 @@ function parseTaskDependencies(planContent) {
  * @param {string} taskName - task-04
  * @returns {{ ok: boolean, endpoints: Array, artifactPath: string|null }}
  */
-export function extractProviderArtifact(changeDir, worktreePath, specBase, taskName) {
-  const artifactDir = join(specBase, '.runtime', 'contract-artifacts', taskName)
+export function extractProviderArtifact(changeDir, worktreePath, specBase, taskName, runtimeRoot) {
+  // 平台模式 contract-artifacts 落 runtimeRoot；否则落 specBase/.runtime
+  const artifactRoot = runtimeRoot || join(specBase, '.runtime')
+  const artifactDir = join(artifactRoot, 'contract-artifacts', taskName)
   const artifactPath = join(artifactDir, 'endpoints.json')
 
   if (!worktreePath || !existsSync(worktreePath)) {
@@ -179,13 +181,15 @@ export function extractProviderArtifact(changeDir, worktreePath, specBase, taskN
  * @param {Array<{ provider: string, consumer: string, type: string }>} contracts
  * @returns {string|null} 注入到 prompt 的契约文本，无契约时返回 null
  */
-export function buildConsumerInjection(changeDir, specBase, taskName, contracts) {
+export function buildConsumerInjection(changeDir, specBase, taskName, contracts, runtimeRoot) {
+  // 平台模式 contract-artifacts 落 runtimeRoot；否则落 specBase/.runtime
+  const artifactRoot = runtimeRoot || join(specBase, '.runtime')
   const myContracts = contracts.filter(c => c.consumer === taskName)
   if (myContracts.length === 0) return null
 
   const parts = []
   for (const contract of myContracts) {
-    const artifactDir = join(specBase, '.runtime', 'contract-artifacts', contract.provider)
+    const artifactDir = join(artifactRoot, 'contract-artifacts', contract.provider)
     const artifactFile = join(artifactDir, 'endpoints.json')
 
     let endpoints = []
@@ -293,11 +297,13 @@ export function buildContractFieldInjection(changeDir, taskName) {
  * @param {string} worktreePath - worktree 路径
  * @returns {{ ok: boolean, missingBackend: Array, unusedBackend: Array, summary: string }}
  */
-export function verifyApiParity(specBase, worktreePath) {
+export function verifyApiParity(specBase, worktreePath, runtimeRoot) {
   const { diffApiParity } = require('./endpoint-extractor.js')
 
+  // 平台模式 contract-artifacts 落 runtimeRoot；否则落 specBase/.runtime
+  const artifactRoot = runtimeRoot || join(specBase, '.runtime')
   // 读取所有 provider artifacts
-  const artifactBase = join(specBase, '.runtime', 'contract-artifacts')
+  const artifactBase = join(artifactRoot, 'contract-artifacts')
   const allProviderEndpoints = []
 
   if (existsSync(artifactBase)) {

package/src/db.js

@@ -83,7 +83,7 @@ export class DB {
       CREATE TABLE IF NOT EXISTS project (
         id INTEGER PRIMARY KEY DEFAULT 1,
         name TEXT NOT NULL,
-        schema_version INTEGER DEFAULT 4,
+        schema_version INTEGER DEFAULT 3,
         created_at TEXT NOT NULL,
         updated_at TEXT NOT NULL
       )

package/src/progress.js

@@ -4,8 +4,7 @@
  * 纯 Node.js，无外部依赖。支持多变更并行。
  *
  * 存储结构：
- *   .sillyspec/.runtime/sillyspec.db          — SQLite 数据库（权威状态源）
- *   .sillyspec/.runtime/global.json           — 全局状态缓存（项目名、活跃变更列表）
+ *   .sillyspec/.runtime/sillyspec.db          — SQLite 数据库（权威状态源，含全局状态/项目名/活跃变更）
  *   .sillyspec/.runtime/gate-status.json      — worktree-guard 门禁状态缓存
  *
  * 历史迁移：v1/v2 使用 progress.json 文件，v3 已全部迁移至 SQLite。
@@ -103,7 +102,6 @@ export function resolvePlatformSpecDir(cwd, explicitSpecDir = null) {
 }
 
 const CHANGES_SUBDIR = 'changes';
-const GLOBAL_FILE = 'global.json';
 const CURRENT_VERSION = 3;
 const VALID_STAGES = ['scan', 'brainstorm', 'plan', 'execute', 'verify', 'archive', 'quick', 'explore'];
 const VALID_STATUSES = ['pending', 'in-progress', 'completed', 'failed', 'blocked', 'waiting', 'stale'];
@@ -731,7 +729,11 @@ export class ProgressManager {
       console.warn('⚠️  initChange: changeName 为空，跳过');
       return null;
     }
-    this._ensureChangeDir(cwd, changeName);
+    // quick 会话 id（quick-<uuid8>，见 run.js QUICK_SID_RE）只作 progress 的跨进程 session key，
+    // 进度存 SQL 不需要实体 change 目录——跳过避免 changes/quick-<uuid>/ 空目录残留。
+    if (!/^quick-[0-9a-f]{8}$/.test(changeName)) {
+      this._ensureChangeDir(cwd, changeName);
+    }
 
     const db = await this._ensureDB(cwd);
     db.transaction((sqlDb) => {

package/src/review-tier.js

@@ -0,0 +1,65 @@
+/**
+ * SillySpec Review Tier — 审查分级
+ *
+ * 决定某阶段的"审查/自检"由「当前 agent 自审」还是「独立审查子代理」执行。
+ *
+ * 为什么需要分级：
+ *   scanProfile（决定 maxAgentCalls / 是否禁子代理）只在 scan 阶段生效（run.js:810
+ *   门控 stageName==='scan'）；change-risk-profile 的 P0/P1/P2 只管 apply 阻塞与
+ *   verify 证据。两者都不约束 brainstorm/plan/execute/propose 的审查方式。
+ *   故新选「plan_level / 变更文件数」作为审查分级维度。
+ *
+ * 分级结果：
+ *   - tier=self         → 当前 agent 自审，CLI 放行（不要求 review.json）
+ *   - tier=independent  → 强制独立审查子代理 + review.json，CLI 硬校验
+ *
+ * CLI 侧（run.js done gate）与 prompt 注入侧用同一个函数，保证两边判定一致——
+ * 不信 agent 自报 tier。
+ */
+
+import { parseFileChangeList } from './change-list.js'
+
+/**
+ * 审查分级阈值：变更文件数 ≤ 此值 → tier=self。
+ * 依据：≤3 文件的变更通常是单点修复/文案调整，独立审查子代理的仪式成本 > 收益。
+ */
+export const SELF_REVIEW_FILE_THRESHOLD = 3
+
+/**
+ * 审查分级
+ *
+ * 判定顺序（短路）：
+ *   1. plan_level === 'none'                          → self（极小变更）
+ *   2. design.md 变更文件数 ≤ SELF_REVIEW_FILE_THRESHOLD → self
+ *   3. 否则                                            → independent
+ *
+ * fail-safe：designPath 传了但解析不到文件清单（fileCount=0）按字面 0 处理（真无文件
+ * 变更 = 极小）；designPath 完全没传（fileCount=null，无法证明规模）→ independent
+ * （宁严勿松）。
+ *
+ * @param {object} [opts]
+ * @param {string} [opts.planLevel] - plan_level 分类结果（none/light/full）。brainstorm/propose 在 plan 之前，可能拿不到。
+ * @param {string} [opts.designPath] - design.md 绝对路径，用于算变更文件数
+ * @returns {{ tier: 'self'|'independent', reason: string, fileCount: number|null }}
+ */
+export function classifyReviewTier({ planLevel, designPath } = {}) {
+  if (planLevel === 'none') {
+    return { tier: 'self', reason: `plan_level=none（极小变更，≤${SELF_REVIEW_FILE_THRESHOLD} 文件等价）`, fileCount: null }
+  }
+
+  let fileCount = null
+  if (designPath) {
+    fileCount = parseFileChangeList(designPath).size
+  }
+
+  if (fileCount !== null && fileCount <= SELF_REVIEW_FILE_THRESHOLD) {
+    return { tier: 'self', reason: `变更文件 ${fileCount} ≤ ${SELF_REVIEW_FILE_THRESHOLD}`, fileCount }
+  }
+
+  const reason = fileCount === null
+    ? (planLevel
+        ? `plan_level=${planLevel}，无法解析变更文件数，按正常规模处理`
+        : '无法解析 design.md 变更文件清单，按正常规模处理')
+    : `变更文件 ${fileCount} > ${SELF_REVIEW_FILE_THRESHOLD}`
+  return { tier: 'independent', reason, fileCount }
+}

package/src/run.js

@@ -893,6 +893,39 @@ async function outputStep(stageName, stepIndex, steps, cwd, changeName, dbProjec
     promptText = promptText.replace(/\{EXECUTE_RUN_ID\}/g, runId)
   }
 
+  // Stage Review Tier：brainstorm/plan/propose/execute 阶段注入审查分级占位符
+  // （scanProfile 只在 scan 生效、change-risk-profile 只管 apply/verify，都不约束这些阶段的审查方式，
+  //  故按 plan_level / 变更文件数分级：self 当前 agent 自审，independent 强制独立子代理 + review.json）
+  if (['brainstorm', 'plan', 'propose', 'execute'].includes(stageName) && promptText.includes('{REVIEW_TIER}')) {
+    try {
+      const { classifyReviewTier } = await import('./review-tier.js')
+      const { generateStageReviewRunId } = await import('./stage-review.js')
+      const tierSpecBase = platformOpts?.specRoot || join(cwd, '.sillyspec')
+      const tierChangeDir = changeName ? join(tierSpecBase, 'changes', changeName) : null
+      const designPath = tierChangeDir ? join(tierChangeDir, 'design.md') : null
+      let planLevel = null
+      if (tierChangeDir) {
+        const planPath = join(tierChangeDir, 'plan.md')
+        if (existsSync(planPath)) {
+          const fmLine = readFileSync(planPath, 'utf8').split('\n').find(l => l.trim().startsWith('plan_level:'))
+          if (fmLine) planLevel = fmLine.split(':')[1].trim()
+        }
+      }
+      const tier = classifyReviewTier({ planLevel, designPath })
+      const reviewRunId = generateStageReviewRunId()
+      promptText = promptText
+        .split('{REVIEW_TIER}').join(tier.tier)
+        .split('{REVIEW_TIER_REASON}').join(tier.reason)
+        .split('{STAGE_REVIEW_RUN_ID}').join(reviewRunId)
+    } catch (e) {
+      // 降级 self，避免 prompt 残留占位符
+      promptText = promptText
+        .split('{REVIEW_TIER}').join('self')
+        .split('{REVIEW_TIER_REASON}').join('分级异常降级 self: ' + e.message)
+        .split('{STAGE_REVIEW_RUN_ID}').join('review-unknown')
+    }
+  }
+
   // 注入模块上下文（brainstorm/plan/execute 阶段，基于 Module Context Index）
   if (['brainstorm', 'plan', 'execute'].includes(stageName) && projectName) {
     const effectiveSpecBase = platformOpts?.specRoot || join(cwd, '.sillyspec')
@@ -1511,6 +1544,15 @@ export async function runCommand(args, cwd, specDir = null) {
     }
   }
 
+  // execute 阶段必须带 --change：不允许自动检测或默认值，变更名必须由 agent 显式传入
+  // --status 豁免（纯查看不需要指定变更）
+  if (stageName === 'execute' && !changeName && !isStatus) {
+    console.error('❌ execute 阶段必须用 --change <变更名> 指定要操作的变更。')
+    console.error('   agent 必须传参，不设默认值、不做自动检测。')
+    console.error('   请加 --change <变更名> 重新执行。')
+    process.exit(1)
+  }
+
   let progress = await pm.read(cwd, changeName)
 
   if (!progress) {
@@ -1844,7 +1886,7 @@ async function runStage(pm, progress, stageName, cwd, changeName, skipApproval =
   if (stageName === 'execute') {
     const { generateExecuteRunId } = await import('./task-review.js')
     const execSpecBase = platformOpts?.specRoot || join(cwd, '.sillyspec')
-    const runtimeRoot = join(execSpecBase, '.runtime')
+    const runtimeRoot = platformOpts?.runtimeRoot || join(execSpecBase, '.runtime')
     const runIdFile = join(runtimeRoot, `current-execute-run-id-${changeName}`)
     mkdirSync(runtimeRoot, { recursive: true })
     // 优先读取已有的变更专属标记文件
@@ -3305,6 +3347,56 @@ async function completeStep(pm, progress, stageName, cwd, outputText, inputText
         }
       }
 
+      // ── Stage Review Gate：brainstorm/plan/propose/execute 独立审查（按 tier 分级）──
+      // tier=self 放行+审计打印；tier=independent 必须 review.json 且 verdict 非 fail，fail-closed
+      if (['brainstorm', 'plan', 'propose', 'execute'].includes(stageName)) {
+        try {
+          const { classifyReviewTier } = await import('./review-tier.js')
+          const { validateStageReview, getLatestStageReviewRunId, printStageReviewResult } = await import('./stage-review.js')
+          const effectiveSpecBase = platformOpts?.specRoot || specBase
+          const reviewChangeDir = resolveChangeDir(cwd, progress, platformOpts?.specRoot)
+          const designPath = reviewChangeDir ? join(reviewChangeDir, 'design.md') : null
+          let planLevel = null
+          if (reviewChangeDir) {
+            const planPath = join(reviewChangeDir, 'plan.md')
+            if (existsSync(planPath)) {
+              const fmLine = readFileSync(planPath, 'utf8').split('\n').find(l => l.trim().startsWith('plan_level:'))
+              if (fmLine) planLevel = fmLine.split(':')[1].trim()
+            }
+          }
+          const tier = classifyReviewTier({ planLevel, designPath })
+          const runtimeRoot = platformOpts?.runtimeRoot || join(effectiveSpecBase, '.runtime')
+
+          if (tier.tier === 'self') {
+            console.log('\nℹ️  Stage Review: ' + stageName + ' tier=self（' + tier.reason + '），已降级为当前 agent 自审，不强制独立子代理。')
+          } else {
+            const reviewRunId = getLatestStageReviewRunId(runtimeRoot, stageName)
+            const reviewType = stageName === 'brainstorm' ? 'design'
+              : stageName === 'plan' ? 'plan'
+              : stageName === 'propose' ? 'proposal'
+              : 'acceptance'
+            const searchDirs = [effectiveSpecBase, reviewChangeDir, cwd].filter(Boolean)
+            const reviewResult = validateStageReview({ stage: stageName, reviewType, runtimeRoot, reviewRunId, searchDirs })
+            printStageReviewResult(reviewResult, { stage: stageName })
+            if (!reviewResult.ok) {
+              rollbackStageCompletion(stageData, steps, currentIdx)
+              progress.lastActive = new Date().toLocaleString('zh-CN', { hour12: false })
+              await pm._write(cwd, progress, changeName)
+              triggerSync(cwd, changeName, platformOpts)
+              return { stageCompleted: false, currentIdx, nextPendingIdx: currentIdx }
+            }
+          }
+        } catch (e) {
+          // fail-closed：Gate 自身异常阻断完成，不静默放行（与 Task Review Gate 一致）
+          console.error('❌ Stage Review Gate 异常，阻断 ' + stageName + ' 完成: ' + e.message)
+          rollbackStageCompletion(stageData, steps, currentIdx)
+          progress.lastActive = new Date().toLocaleString('zh-CN', { hour12: false })
+          await pm._write(cwd, progress, changeName)
+          triggerSync(cwd, changeName, platformOpts)
+          return { stageCompleted: false, currentIdx, nextPendingIdx: currentIdx }
+        }
+      }
+
       // ── Execute Task Review Gate：所有 task 必须有 review.json 且 verdict 通过 ──
       if (stageName === 'execute') {
         try {
@@ -3315,7 +3407,7 @@ async function completeStep(pm, progress, stageName, cwd, outputText, inputText
 
           if (planPath && existsSync(planPath)) {
             const planContent = readFileSync(planPath, 'utf8')
-            const runtimeRoot = join(effectiveSpecBase, '.runtime')
+            const runtimeRoot = platformOpts?.runtimeRoot || join(effectiveSpecBase, '.runtime')
 
             // execute run id：从变更专属标记文件读取
             const runIdFile = join(runtimeRoot, `current-execute-run-id-${changeName}`)
@@ -3513,7 +3605,7 @@ async function completeStep(pm, progress, stageName, cwd, outputText, inputText
       if (wf && changeName) {
         const raw = JSON.stringify(wf)
         const resolved = JSON.parse(raw.replace(/<change-name>/g, changeName))
-        const result = runPostCheck(resolved, cwd, 'sillyspec', {}, specBase)
+        const result = runPostCheck(resolved, cwd, progress.project || basename(cwd), {}, specBase)
         // 只报告 impact-analyzer 的结果（doc-syncer 是后续步骤）
         const impactResult = (result.roles || []).find(r => r.id === 'impact-analyzer')
         if (impactResult) {

package/src/stage-review.js

@@ -0,0 +1,300 @@
+/**
+ * SillySpec Stage Review Gate — 阶段级审查校验（文档型）
+ *
+ * 与 task-review.js 的关系：
+ *   task-review 校验 execute 每个 task 的 review.json（git 代码 diff 证据：base/head）。
+ *   stage-review 校验 brainstorm/plan/propose/execute-acceptance 的阶段级 review.json
+ *   （文档证据：reviewedFiles + docHash）。两者 verdict 语义一致（pass/fail/cannot_verify
+ *   三态 + cannot_verify 必须带 requiredEvidence 的反逃逸规则），复用 task-review 导出的
+ *   VALID_VERDICTS / REVIEW_SCHEMA_VERSION 常量；task-review.js 本身不改、execute 路径零风险。
+ *
+ * 目录结构：
+ *   .sillyspec/.runtime/stage-reviews/<stage>-<reviewRunId>/review.json
+ *   （平台模式落 <runtimeRoot>/stage-reviews/...，与 execute-runs 同构）
+ */
+
+import { existsSync, readFileSync, mkdirSync, readdirSync } from 'fs'
+import { join } from 'path'
+import { createHash } from 'crypto'
+import { VALID_VERDICTS, REVIEW_SCHEMA_VERSION } from './task-review.js'
+
+// 文档型 stage review 的合法 reviewType
+export const STAGE_REVIEW_TYPES = ['design', 'plan', 'proposal', 'code', 'acceptance']
+
+// checklist 每项 result 的合法值
+const CHECKLIST_RESULTS = ['pass', 'gap', 'fail']
+
+/**
+ * 计算文件内容的 sha256（用于 docHash 真实性校验，防 agent 凭空伪造 review.json）
+ * @param {string} filePath - 绝对路径
+ * @returns {string|null} sha256 hex；文件不存在返回 null
+ */
+export function computeDocHash(filePath) {
+  if (!filePath || !existsSync(filePath)) return null
+  const content = readFileSync(filePath)
+  return createHash('sha256').update(content).digest('hex')
+}
+
+/**
+ * 校验文档型 stage review.json 的 schema
+ *
+ * 与 task-review.validateReviewSchema 的区别：
+ *   - 不要求 git base/head（证据形态不同）
+ *   - 改要求 reviewedFiles（被审查文档路径数组）+ docHash（主文档内容 sha256）
+ *   - 新增 reviewType（design/plan/proposal/code/acceptance）+ checklist
+ *   - 复用 VALID_VERDICTS 三态 + cannot_verify 联动规则（task-review.js:65-69）
+ *
+ * @param {object} review - 解析后的 JSON 对象
+ * @returns {{ ok: boolean, errors: string[] }}
+ */
+export function validateStageReviewSchema(review) {
+  const errors = []
+  if (!review || typeof review !== 'object') {
+    return { ok: false, errors: ['stage review.json 不是有效 JSON 对象'] }
+  }
+
+  if (review.schemaVersion !== REVIEW_SCHEMA_VERSION) {
+    errors.push(`schemaVersion 应为 ${REVIEW_SCHEMA_VERSION}，实际为 ${review.schemaVersion}`)
+  }
+
+  if (!STAGE_REVIEW_TYPES.includes(review.reviewType)) {
+    errors.push(`reviewType 无效：${review.reviewType}（应为 ${STAGE_REVIEW_TYPES.join('/')}）`)
+  }
+
+  if (!VALID_VERDICTS.includes(review.specVerdict)) {
+    errors.push(`specVerdict 无效：${review.specVerdict}（应为 ${VALID_VERDICTS.join('/')}）`)
+  }
+  if (!VALID_VERDICTS.includes(review.qualityVerdict)) {
+    errors.push(`qualityVerdict 无效：${review.qualityVerdict}（应为 ${VALID_VERDICTS.join('/')}）`)
+  }
+
+  // cannot_verify 必须提供非空 requiredEvidence（与 task-review:65-69 一致，反逃逸）
+  if (review.specVerdict === 'cannot_verify' || review.qualityVerdict === 'cannot_verify') {
+    if (!Array.isArray(review.requiredEvidence) || review.requiredEvidence.length === 0) {
+      errors.push('cannot_verify 的 verdict 必须提供非空的 requiredEvidence 数组')
+    }
+  }
+
+  // reviewedFiles 必须是非空数组
+  if (!Array.isArray(review.reviewedFiles) || review.reviewedFiles.length === 0) {
+    errors.push('缺少 reviewedFiles 字段（应为被审查文档路径数组，[0] 为主审查对象，docHash 对应它）')
+  }
+
+  // docHash 非空
+  if (!review.docHash || typeof review.docHash !== 'string') {
+    errors.push('缺少 docHash 字段（被审查主文档内容的 sha256）')
+  }
+
+  // checklist 若提供，校验每项结构
+  if (review.checklist !== undefined) {
+    if (!Array.isArray(review.checklist)) {
+      errors.push('checklist 若提供必须是数组')
+    } else {
+      for (let i = 0; i < review.checklist.length; i++) {
+        const item = review.checklist[i]
+        if (!item || typeof item !== 'object' || !item.item) {
+          errors.push(`checklist[${i}] 缺少 item 描述`)
+          continue
+        }
+        if (item.result !== undefined && !CHECKLIST_RESULTS.includes(item.result)) {
+          errors.push(`checklist[${i}].result 无效：${item.result}（应为 ${CHECKLIST_RESULTS.join('/')}）`)
+        }
+      }
+    }
+  }
+
+  return { ok: errors.length === 0, errors }
+}
+
+/**
+ * docHash 真实性交叉校验：review 声称审查了某文档，重算该文档 sha256 对比。
+ *
+ * 对应 task-review.verifyReviewGitEvidence 的"防伪造"职责——agent 不能凭空编一份
+ * review.json 贴个假 hash。约定 docHash 对应 reviewedFiles[0]（主审查对象）。
+ *
+ * searchDirs 依次尝试解析 reviewedFiles 的相对路径（specBase / changeDir / cwd 都可能）。
+ * 主文档在所有基准下都找不到时降级 warning，不阻断（不因路径基准差异误杀）。
+ *
+ * @param {object} review - 已通过 schema 校验
+ * @param {string[]} searchDirs - 解析相对路径的候选基准目录（绝对路径）
+ * @returns {{ ok: boolean, errors: string[], warnings: string[] }}
+ */
+export function verifyStageReviewDocHash(review, searchDirs) {
+  const errors = []
+  const warnings = []
+  const files = Array.isArray(review.reviewedFiles) ? review.reviewedFiles : []
+  if (files.length === 0) {
+    return { ok: false, errors: ['reviewedFiles 为空，无法做 docHash 校验'], warnings }
+  }
+
+  const primaryRel = files[0]
+
+  for (const base of searchDirs || []) {
+    const abs = join(base, primaryRel)
+    const actual = computeDocHash(abs)
+    if (actual === null) continue
+    // 找到主文档，比对 hash
+    if (review.docHash !== actual) {
+      errors.push(`docHash 与主审查文档 ${primaryRel} 的实际内容不匹配 — review.json 疑似伪造（未真正读取文档）`)
+      return { ok: false, errors, warnings }
+    }
+    return { ok: true, errors, warnings }
+  }
+
+  // 所有基准都找不到主文档：路径基准差异，降级 warning
+  warnings.push(`主审查文档 ${primaryRel} 在候选目录下均不存在，跳过 docHash 校验（可能路径基准不同）`)
+  return { ok: true, errors, warnings }
+}
+
+/**
+ * 生成 stage review run id
+ * @returns {string} 如 'review-2026-07-16-143000'
+ */
+export function generateStageReviewRunId() {
+  const now = new Date()
+  const pad = (n) => String(n).padStart(2, '0')
+  return `review-${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`
+}
+
+/**
+ * 获取最新的 stage review run id（扫描 stage-reviews/<stage>-review-* 目录取最新）
+ *
+ * @param {string} runtimeRoot - .runtime 绝对路径
+ * @param {string} stage - brainstorm|plan|propose|execute
+ * @returns {string|null} run id（如 'review-2026-07-16-143000'），无则 null
+ */
+export function getLatestStageReviewRunId(runtimeRoot, stage) {
+  const dir = join(runtimeRoot, 'stage-reviews')
+  if (!existsSync(dir)) return null
+  try {
+    const entries = readdirSync(dir, { withFileTypes: true })
+      .filter(e => e.isDirectory() && e.name.startsWith(`${stage}-review-`))
+      .map(e => e.name)
+      .sort()
+      .reverse()
+    if (!entries[0]) return null
+    // entries[0] = "plan-review-2026-..."，剥掉 `${stage}-` 前缀得到 runId "review-2026-..."
+    return entries[0].slice(stage.length + 1)
+  } catch {
+    return null
+  }
+}
+
+/**
+ * stage-level review 总校验（brainstorm/plan/propose/execute-acceptance 的 done gate）
+ *
+ * 规则（与 task-review.validateTaskReviews 对称）：
+ *   - review.json 缺失 → error 阻断
+ *   - 解析失败 / schema 失败 → error 阻断
+ *   - reviewType 与期望不符 → error（agent 复制模板未改）
+ *   - specVerdict 或 qualityVerdict 为 fail → error 阻断
+ *   - cannot_verify + 非空 requiredEvidence → warning
+ *   - cannot_verify + 空 requiredEvidence → error（schema 已拦，双保险）
+ *   - docHash 与主文档实际内容不符 → error（伪造）
+ *
+ * 调用方约定：先用 classifyReviewTier 判定 tier——tier=self 不调用本函数（直接放行），
+ * tier=independent 才调用。
+ *
+ * @param {object} opts
+ * @param {string} opts.stage - brainstorm|plan|propose|execute
+ * @param {string} opts.reviewType - design|plan|proposal|code|acceptance
+ * @param {string} opts.runtimeRoot - .runtime 绝对路径（平台模式为 runtimeRoot）
+ * @param {string} opts.reviewRunId - stage review run id（review-<ts>）
+ * @param {string[]} [opts.searchDirs] - docHash 校验的候选基准目录
+ * @param {boolean} [opts.verifyDocHash=true] - 是否做 docHash 真实性校验
+ * @returns {{ ok: boolean, errors: string[], warnings: string[], review: object|null }}
+ */
+export function validateStageReview(opts) {
+  const { stage, reviewType, runtimeRoot, reviewRunId, searchDirs = [], verifyDocHash = true } = opts
+  const errors = []
+  const warnings = []
+
+  const reviewDir = join(runtimeRoot, 'stage-reviews', `${stage}-${reviewRunId}`)
+  const reviewPath = join(reviewDir, 'review.json')
+
+  if (!reviewRunId || !existsSync(reviewPath)) {
+    return {
+      ok: false,
+      errors: [`缺少 ${stage} 阶段的 stage review.json — tier=independent 要求独立审查子代理产出（期望路径：${reviewPath}）`],
+      warnings,
+      review: null,
+    }
+  }
+
+  let raw
+  try {
+    raw = readFileSync(reviewPath, 'utf8')
+  } catch (e) {
+    return { ok: false, errors: [`${stage} review.json 读取失败: ${e.message}`], warnings, review: null }
+  }
+
+  let parsed
+  try {
+    parsed = JSON.parse(raw)
+  } catch (e) {
+    return { ok: false, errors: [`${stage} review.json 解析失败: ${e.message}`], warnings, review: null }
+  }
+
+  const schemaResult = validateStageReviewSchema(parsed)
+  if (!schemaResult.ok) {
+    return { ok: false, errors: [`${stage} review.json schema 校验失败 — ${schemaResult.errors.join('; ')}`], warnings, review: parsed }
+  }
+
+  // reviewType 与期望一致性
+  if (parsed.reviewType && parsed.reviewType !== reviewType) {
+    errors.push(`${stage} review.json 的 reviewType 为 "${parsed.reviewType}"，与期望 "${reviewType}" 不符 — agent 可能复制模板未修改`)
+  }
+
+  // fail verdict
+  if (parsed.specVerdict === 'fail' || parsed.qualityVerdict === 'fail') {
+    errors.push(`${stage} review 未通过 — spec: ${parsed.specVerdict}, quality: ${parsed.qualityVerdict}`)
+    if (parsed.reviewerNotes) errors.push(`${stage}: ${parsed.reviewerNotes}`)
+  }
+
+  // docHash 真实性（fail verdict 已错时跳过，避免噪声）
+  if (errors.length === 0 && verifyDocHash && searchDirs.length > 0) {
+    const dh = verifyStageReviewDocHash(parsed, searchDirs)
+    for (const w of dh.warnings) warnings.push(`${stage}: ${w}`)
+    if (!dh.ok) {
+      for (const err of dh.errors) errors.push(`${stage}: ${err}`)
+    }
+  }
+
+  // cannot_verify → warning（requiredEvidence 非空已由 schema 保证）
+  if (errors.length === 0 && (parsed.specVerdict === 'cannot_verify' || parsed.qualityVerdict === 'cannot_verify')) {
+    const verdicts = []
+    if (parsed.specVerdict === 'cannot_verify') verdicts.push('spec')
+    if (parsed.qualityVerdict === 'cannot_verify') verdicts.push('quality')
+    warnings.push(`${stage}: ${verdicts.join('+')}=cannot_verify，requiredEvidence 需在后续阶段满足`)
+  }
+
+  return { ok: errors.length === 0, errors, warnings, review: parsed }
+}
+
+/**
+ * 打印 stage review 校验结果
+ * @param {{ ok: boolean, errors: string[], warnings: string[] }} result
+ * @param {object} context - { stage, reviewRunId } 用于错误提示路径
+ */
+export function printStageReviewResult(result, context = {}) {
+  const { stage } = context
+  if (result.ok && result.warnings.length === 0) {
+    console.log(`\n✅ Stage Review Gate — ${stage} 阶段独立审查通过`)
+    return
+  }
+
+  if (result.errors.length > 0) {
+    console.error(`\n🚫 Stage Review Gate — ${stage} FAILED`)
+    for (const err of result.errors) {
+      console.error(`   - ${err}`)
+    }
+    console.error(`\n   提示：tier=independent 要求独立审查子代理产出 review.json，补全后重新 --done`)
+  }
+
+  if (result.warnings.length > 0) {
+    console.warn(`\n⚠️ Stage Review Gate — ${stage} WARNING`)
+    for (const w of result.warnings) {
+      console.warn(`   - ${w}`)
+    }
+  }
+}

package/src/stages/brainstorm.js

@@ -430,6 +430,11 @@ design.md 文件路径 + 自审结果
 ### 定位
 这是设计完成后的质量门，不是需求探索。目标不是继续发散，而是找出 design.md 内部、四件套之间、文档与外部约束之间的结构性矛盾。
 
+### 审查执行方式（CLI 按变更规模判定，占位符由 run.js 注入）
+tier: {REVIEW_TIER}（{REVIEW_TIER_REASON}）
+- tier=self：当前 agent 直接执行下方交叉审查（小变更）
+- tier=independent：必须用 Agent tool 启动一个独立的设计审查子代理（独立上下文，不共享你的分析与倾向），子代理按下方"交叉审查模型"审查 design.md 并输出 review.json 到 {SPEC_ROOT}/.runtime/stage-reviews/brainstorm-{STAGE_REVIEW_RUN_ID}/review.json。字段：reviewType=design；reviewedFiles=[changes/<change>/design.md]；docHash=design.md 的 sha256（必须真实读取文件计算，禁止编造，CLI 会重算对比）；specVerdict/qualityVerdict=pass|fail|cannot_verify；checklist 按"定义层/一致性层/可行性层"每条给 pass|gap|fail。子代理只产出 review + Unresolved Blockers，**是否调用 sillyspec run brainstorm --wait 仍由你（主 agent）根据其 verdict 决定**（子代理不直接操作 CLI 状态机）。
+
 ### 默认行为
 1. 默认必须执行一次交叉审查；不要让用户凭主观判断决定"要不要 Grill"。
 2. 只有以下情况可以轻量跳过，并必须记录原因：

package/src/stages/execute.js

@@ -215,9 +215,10 @@ const acceptanceSteps = [
     mode: 'acceptance',
     prompt: `对照 design.md 检查所有实现是否与设计一致。
 
-### 执行方式
-本步骤由当前 agent 汇总执行，不需要为每个检查项启动独立子代理。
-如需深入验证某个模块，可启动单个 QA 子代理统一处理。
+### 执行方式（CLI 按变更规模判定，占位符由 run.js 注入）
+tier: {REVIEW_TIER}（{REVIEW_TIER_REASON}）
+- tier=self：当前 agent 汇总执行（对照 design.md 逐项检查 + 偏差说明）
+- tier=independent：必须用 Agent tool 启动一个独立的 QA 子代理（独立上下文，不共享实现者的分析），子代理对照 design.md 逐项检查实现一致性并输出 review.json 到 {SPEC_ROOT}/.runtime/stage-reviews/execute-{STAGE_REVIEW_RUN_ID}/review.json。字段：reviewType=acceptance；reviewedFiles=[changes/<change>/design.md] + git diff 涉及的源码文件；docHash=design.md 的 sha256（禁止编造）；specVerdict/qualityVerdict=pass|fail|cannot_verify；checklist 按每个设计要点给 pass|gap|fail。该 acceptance review 同时覆盖"代码审查"视角（风格/bug/安全/冗余），后续代码审查步骤仅需轻量复审。
 
 ### 操作
 1. 读取 design.md（技术方案）

package/src/stages/plan.js

@@ -154,14 +154,14 @@ needs_human_review: true | false
 
 const stepGeneratePlan = {
   id: 'generate_plan',
-  name: '生成分级计划与自检',
-  prompt: `根据上一步的 plan_level 结果，按对应级别生成计划，然后立即自检。
+  name: '生成分级计划',
+  prompt: `根据上一步的 plan_level 结果，按对应级别生成计划。
 
 ### 操作
 1. 读取上一步输出的 plan_level 分类结果
 2. 读取 tasks.md 和 design.md 了解需求范围
 3. 按 plan_level 选择对应模板输出
-4. 生成后立即自检（见下方自检清单）
+4. 保存 plan.md（审查在下一步"审查计划"独立进行，不在本步自审——避免生成与自审同一次输出）
 
 ---
 
@@ -319,53 +319,59 @@ full 计划的约束：
 
 ---
 
-### 自检（生成后立即执行，不另开步骤）
-
-读取上一步的 plan_level 分类结果，按级别执行对应的自检：
-
-#### plan_level = none
-- [ ] plan.md 文件存在且包含 plan_level: none
-- [ ] 给出了可操作的修改建议（2-5 条）
-- [ ] 不含 Wave、Mermaid、估时、任务总表、依赖关系等完整蓝图内容
-- [ ] 建议了直接 execute
-- [ ] 包含至少一个 \`- [ ] task-XX:\` 格式的 checkbox 任务（execute 解析依赖此格式）
+### 输出
+plan_level + 计划内容（审查在下一步独立进行）`,
+  outputHint: 'plan_level + 计划内容',
+  optional: false
+}
 
-#### plan_level = light
-- [ ] 输出明确标注 plan_level: light
-- [ ] 有来源、范围、任务列表、验收标准四个部分
-- [ ] 来源直接引用已有文档，未重新扩写
-- [ ] 任务列表清晰且无实现细节
-- [ ] 任务使用 checkbox 格式（\`- [ ] task-XX:\`），不是纯编号列表
-- [ ] 验收标准具体可验证（非笼统表述）
-- [ ] 如果存在 decisions.md，所有当前版本 D-xxx@vN 在 plan.md 中可追踪
-- [ ] 不存在 P0/P1 unresolved blocker
-- [ ] 没有 Mermaid 图、估时、风险分析
-- [ ] 没有函数签名、代码示例等实现细节
-- [ ] plan.md 与 design.md 的文件变更清单一致
-- [ ] 包含至少一个 \`- [ ] task-XX:\` 格式的 checkbox 任务（execute 解析依赖此格式）
+// ═══════════════════════════════════════════════════════════════
+// 第 2.5 步（LLM）：审查计划（独立于生成，按规模分级）
+// ═══════════════════════════════════════════════════════════════
 
-#### plan_level = full
-- [ ] 每个 task 有编号（task-01、task-02 ...）
-- [ ] 每个 task 在 Wave 下有 checkbox（\`- [ ] task-XX:\` 格式，execute 解析依赖此格式）
-- [ ] 已标注 Wave 分组和依赖关系
-- [ ] 有任务总表（含优先级、依赖列，**无估时列**）
-- [ ] 有关键路径标注
-- [ ] 有全局验收标准
-- [ ] 如果存在 decisions.md，任务总表或覆盖矩阵覆盖全部当前版本 D-xxx@vN
-- [ ] 不存在 P0/P1 unresolved blocker
-- [ ] （brownfield）全局验收包含兼容性条款
-- [ ] 没有实现细节（接口定义、代码示例等不应该在 plan.md 里）
-- [ ] plan.md 与 design.md 的文件变更清单一致
-- [ ] 如果涉及构造函数/接口/DTO/client 方法变更，是否搜索了所有调用点并纳入任务范围？
-- [ ] 调用点搜索命令的输出是否记录在 plan.md 或 task-NN.md 中？
-- [ ] 跨任务契约自检：若 task-A 的产出（接口/DTO/响应）被 task-B 消费，consumer 是否在 TaskCard expects_from 里声明所需字段、provider 是否在 provides 里承诺这些字段、两边字段是否一致？（plan-postcheck 会硬校验，此处先自查）
-- [ ] 文件覆盖自检：design.md「文件变更清单」中的每个源码文件，是否都被至少一个 task 的 allowed_paths 覆盖？（plan-postcheck 会硬校验，漏覆盖 = execute 必然漏改，此处先自查）
-- [ ] 如果有 Mermaid 图，依赖关系确实非平凡（非线性/非全并行）
-- [ ] 没有泛泛风险分析（如"需要充分测试"）
+/**
+ * 审查计划 step —— 把"审查"从生成 step 拆出（原 stepGeneratePlan 生成+自检同次输出是最严重的 self-review）。
+ * 按规模分级：tier=self 当前 agent 自审；tier=independent 强制独立子代理 + review.json。
+ * 占位符 {REVIEW_TIER} / {REVIEW_TIER_REASON} / {STAGE_REVIEW_RUN_ID} 由 run.js 注入。
+ */
+const stepReviewPlan = {
+  id: 'review_plan',
+  name: '审查计划',
+  prompt: `对上一步生成的 plan.md 做审查。生成与审查分离——不在生成 plan 的同一上下文里自审，避免确认偏差。
+
+### 当前审查分级（CLI 按变更规模判定，占位符由 run.js 注入）
+tier: {REVIEW_TIER}（{REVIEW_TIER_REASON}）
+- tier=self：当前 agent 直接执行下方审查清单（小变更，独立审查仪式成本 > 收益）
+- tier=independent：必须用 Agent tool 启动一个独立的计划审查子代理（独立上下文，不共享你生成 plan 时的分析与倾向），由子代理执行下方审查清单并输出 review.json
+
+### 审查清单（读取 plan.md 的 plan_level，逐条核对）
+- [ ] task 编号与 Wave checkbox 格式正确，execute 依赖此格式解析任务
+- [ ] plan_level 档位与实际复杂度匹配（none/light/full 没选错）
+- [ ] 跨任务契约：task-A 的产出（接口/DTO/响应）被 task-B 消费时，consumer 是否在 TaskCard expects_from 声明所需字段、provider 是否在 provides 承诺、两边字段一致？（plan-postcheck 会硬校验，此处是独立视角复查）
+- [ ] 文件覆盖：design.md 文件变更清单中的每个源码文件，是否都被至少一个 task 的 allowed_paths 覆盖？（漏覆盖 = execute 必然漏改）
+- [ ] 不存在 P0/P1 unresolved blocker 残留
+- [ ] 没有实现细节泄漏到 plan.md（接口签名/代码示例应在 tasks/task-NN.md）
+- [ ] 关键路径与 Wave 依赖合理（无循环依赖、无遗漏前置）
+
+### tier=independent 时：启动 plan-review 子代理
+用 Agent tool 启动子代理（subagent_type: general），prompt 要点：
+1. 独立读取 {SPEC_ROOT}/changes/<change>/plan.md + design.md + tasks/*.md（不要让生成者喂结论给你，自己读原始文件）
+2. 执行上方审查清单，每条给 pass/gap/fail + 证据
+3. 输出 review.json 到 {SPEC_ROOT}/.runtime/stage-reviews/plan-{STAGE_REVIEW_RUN_ID}/review.json，字段：
+   - schemaVersion: 1
+   - reviewType: plan ; stage: plan
+   - specVerdict / qualityVerdict: pass | fail | cannot_verify
+   - reviewedFiles: [changes/<change>/plan.md]
+   - docHash: plan.md 内容的 sha256（必须真实读取文件计算，禁止编造——CLI 会重算对比）
+   - checklist: 每条 { item, result: pass|gap|fail, note }
+   - requiredEvidence: cannot_verify 时必填非空
+   - reviewerNotes: 说明
+4. verdict=fail 时在 reviewerNotes 写明阻断项
 
 ### 输出
-plan_level + 计划内容 + 自检结果（一次输出）`,
-  outputHint: '计划内容 + 自检结果',
+- tier=self：审查清单结果（每条状态 + 偏差说明）
+- tier=independent：子代理产出的 review.json 路径 + verdict 摘要`,
+  outputHint: 'plan 审查结果（self=清单 / independent=review.json 路径+verdict）',
   optional: false
 }
 
@@ -524,7 +530,7 @@ export function buildPostcheckStep(changeDir) {
 // 向后兼容：导出 fixedPrefix / fixedSuffix（供 run.js 切片用）
 // ═══════════════════════════════════════════════════════════════
 
-export const fixedPrefix = [stepClassify, stepGeneratePlan]
+export const fixedPrefix = [stepClassify, stepGeneratePlan, stepReviewPlan]
 
 export const fixedSuffix = [] // postcheck 是动态生成的（需要 changeDir）
 

package/src/stages/propose.js

@@ -138,7 +138,12 @@ export const definition = {
     },
     {
       name: '自检门控',
-      prompt: `自检生成的规范文件。
+      prompt: `自检生成的规范文件（按规模分级）。
+
+### 当前审查分级（CLI 按变更规模判定，占位符由 run.js 注入）
+tier: {REVIEW_TIER}（{REVIEW_TIER_REASON}）
+- tier=self：当前 agent 直接执行下方 checklist
+- tier=independent：必须用 Agent tool 启动一个独立的规范审查子代理（独立上下文，不共享你的分析），子代理执行下方 checklist 并输出 review.json 到 {SPEC_ROOT}/.runtime/stage-reviews/propose-{STAGE_REVIEW_RUN_ID}/review.json。字段：reviewType=proposal；reviewedFiles=[proposal.md, design.md, requirements.md, tasks.md]（相对 changes/<change>/）；docHash=proposal.md 的 sha256（禁止编造）；specVerdict/qualityVerdict=pass|fail|cannot_verify；checklist 每条 pass|gap|fail。
 
 ### 操作
 检查以下各项：