npm - @house365/comate - Versions diffs - 0.9.5 → 0.9.6 - Mend

@house365/comate 0.9.5 → 0.9.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (13) hide show

package/docs/COMATE_MANUAL.md +11 -9
package/package.json +1 -1
package/skills/comate/SKILL.md +151 -23
package/skills/comate/reference/decision-points.md +2 -2
package/skills/comate/scripts/comate-lib.sh +5 -1
package/skills/comate/scripts/comate.sh +98 -16
package/skills/comate/tests/comate.bats +96 -1
package/skills/comate-build/SKILL.md +83 -6
package/skills/comate-design/SKILL.md +75 -3
package/skills/comate-fix/SKILL.md +9 -5
package/skills/comate-gate/SKILL.md +7 -7
package/skills/comate-open/SKILL.md +62 -9
package/skills/comate-verify/SKILL.md +19 -10

package/docs/COMATE_MANUAL.md CHANGED Viewed

@@ -368,7 +368,7 @@ bash "$COMATE" doctor
 1. **进入验证与分类**：检查脏工作树，运行 guard，运行构建/测试命令。将失败分类为 SPEC、REGRESSION、COVERAGE、SECURITY、STYLE、OTHER。
 2. **验证失败决策（决策点 4）**：验证失败时，暂停让用户决定：全部修复 / 逐项处理 / 接受偏差。包括 Spec 漂移处理（设计文档与 delta spec 冲突）。CRITICAL 级别的失败必须修复。仅在用户选择修复后才执行 `state transition <name> verify-fail` 并返回 build。
 3. **验证通过**：全部通过或用户接受偏差后，写入 `verify_result: pass`，将验证报告路径写入 `verification_report`。
-4. **分支收尾（决策点 5）**：调用 `superpowers:finishing-a-development-branch`。暂停让用户选择：本地合并 / 推送为 PR / 保留分支 / 丢弃工作。仅在用户选择且对应操作完成后写入 `branch_status: handled`。
+4. **分支收尾（决策点 5）**：调用 `superpowers:finishing-a-development-branch`。暂停让用户选择：本地合并 / 推送为 PR / 保留分支 / 丢弃工作。前三项完成后写 `branch_status: handled`；丢弃写 `branch_status: discarded` 并停止，不得验证通过或归档。
 5. **退出**：运行 `bash $COMATE guard <name> verify --apply`，通过后自动推进到 archive。
 ### 5.5 阶段 5：归档（/comate-archive）
@@ -432,7 +432,7 @@ bash "$COMATE" doctor
 | 需新增 capability | 超出局部优化 |
 | 需 delta spec | 影响已有规格 |
-暂停等待用户确认升级（决策点 6）。用户确认后先 `state set <name> workflow full`，然后进入完整流程。
+提问前写 `phase_step: fix.upgrade-awaiting`。用户确认后执行 `state transition <name> fix-upgrade`，原子清理 fix 默认值并进入 design。
 ---
@@ -445,14 +445,15 @@ bash "$COMATE" doctor
 | 字段 | 含义 |
 |-------|---------|
 | `schema_version` | 状态文件格式版本（当前：1） |
-| `workflow` | `full` / `fix` |
-| `phase` | `open` / `design` / `build` / `verify` / `archive` |
+| `workflow` | `full` / `fix` |
+| `phase` | `open` / `design` / `build` / `verify` / `archive` |
+| `phase_step` / `phase_step_data` | 当前阶段内的恢复标记和附加数据；阶段转换时自动清空 |
 | `build_mode` | `subagent-driven-development` / `executing-plans` / `direct` |
 | `isolation` | `branch` / `worktree`（必须在 build->verify 之前设置） |
 | `verify_mode` | `light` / `full`（由规模评估写入） |
 | `verify_result` | `pending` / `pass` / `fail` |
 | `verification_report` | 验证报告路径，在 verify-pass 前必须指向真实文件 |
-| `branch_status` | `pending` / `handled` |
+| `branch_status` | `pending` / `handled` / `discarded` |
 | `handoff_context` / `handoff_hash` | 设计交接包路径 + 源文件 sha256 |
 | `impl_context` / `impl_hash` | 构建交接包路径 + plan+tasks sha256 |
 | `direct_override` | 对于使用 `direct` 的 full 流程必须显式为 `true` |
@@ -486,9 +487,9 @@ bash "$COMATE" doctor
 **4. 验证失败决策**（verify）：验证失败时，暂停让用户决定：全部修复 / 逐项处理 / 接受偏差。包括 Spec 漂移处理（设计文档与 delta spec 冲突）。CRITICAL 级别的失败必须修复。仅在用户选择修复后才执行 `state transition <name> verify-fail` 并返回 build。
-**5. 分支收尾选择**（verify/收尾开发分支）：暂停让用户选择：本地合并 / 推送为 PR / 保留分支 / 丢弃工作。仅在用户选择且对应操作完成后写入 `branch_status: handled`。
+**5. 分支收尾选择**（verify/收尾开发分支）：暂停让用户选择：本地合并 / 推送为 PR / 保留分支 / 丢弃工作。前三项成功后写 `handled`；丢弃写 `discarded` 并终止当前流程。
-**6. 预设升级确认**（fix -> full）：当升级条件满足时（bug 模式 3+ 文件等，调整模式 5+ 文件等），暂停让用户确认升级到完整的 `/comate`。不要直接进入 `/comate-design`，不要自动填充设计文档。用户确认后，先 `state set <name> workflow full`，然后进入完整流程。
+**6. 预设升级确认**（fix -> full）：当升级条件满足时，先写 `fix.upgrade-awaiting` 再暂停确认。确认后执行 `state transition <name> fix-upgrade`，由脚本清理 fix 默认构建选项并进入 design。
 **7. 构建范围扩展**（build）：如果实现过程揭示需要重新设计或拆分为新变更，暂停。判定标准：基于初始 tasks.md 任务数，新增任务超过总数一半（50% 阈值）视为超出范围。询问用户是否拆分。中等规模（接口变更、新组件）：确认后加载 `superpowers:brainstorming` 更新设计。大规模（新能力）：确认后使用 `/comate-open` 创建独立变更。
@@ -552,7 +553,8 @@ bash "$COMATE" doctor
 | `state <name> init <full|fix>` | 初始化 `.comate.yaml` |
 | `state <name> set <key> <value>` | 设置单个状态字段 |
 | `state <name> get <key>` | 读取单个状态字段 |
-| `state <name> transition <event>` | 执行状态转换 |
+| `state <name> transition <event>` | 执行状态转换 |
+| `dependency <name> archived` | 严格检查指定 change 已归档且状态为 `archived: true` |
 | `state <name> check <phase> [--json]` | 检查阶段进入条件 |
 | `state <name> recover <phase>` | 从文件状态推断并修复 `.comate.yaml` |
 | `state <name> scale` | 评估变更规模并写入 `verify_mode` |
@@ -592,7 +594,7 @@ bash "$COMATE" doctor
 |---------|-------------|
 | `gate <prd> review` | 建/刷新 gate.yaml，钉当前 PRD sha256，回显评审报告路径。PRD 变了则状态重置为 `reviewing` |
 | `gate <prd> set <field> <value>` | 写字段：`score` / `blocking_open` / `gate_status` 等 |
-| `gate <prd> pass [--tbd]` | 置 `passed`（`--tbd` 置 `passed-with-tbd`）。硬校验 `blocking_open=0` 且评审报告非空，并重钉哈希 |
+| `gate <prd> pass [--tbd]` | 校验评分、拆分映射和报告。普通 pass 要求 `blocking_open=0`；`--tbd` 要求至少一个经用户接受的未解决阻断项 |
 | `gate <prd> spawned <change>` | 记录据此 PRD 扇出的 change（逗号拼接） |
 | `gate <prd> status [--json]` | 查状态；哈希漂移时自动判 `stale`（不改文件） |
 | `gate <prd> check` | comate-open 建 change 前的前置守卫。PASS 要求 gate 存在、状态 ∈ {passed, passed-with-tbd}、哈希未漂移；否则退出码 1 阻塞 |

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@house365/comate",
-  "version": "0.9.5",
+  "version": "0.9.6",
   "description": "comate —— SDD (规约驱动开发) 的 AI 开发编排器（Agent Skills）",
   "type": "module",
   "license": "MIT",

package/skills/comate/SKILL.md CHANGED Viewed

@@ -16,24 +16,131 @@ agent 做决策只需读本节，其余参见末尾「参考附录」。决策
 ### 自动阶段探测
-**Step 0：活跃 change 发现 + 意图探测**
-1. 先探测预设；命中 fix 条件则直接调用 `/comate-fix`，不进入普通 open 分支。
-2. 无预设命中时，运行 `openspec list --json` 获取所有活跃 change。
-**预设探测优先级最高**：
-- 用户明确描述 bug 修复或文案/配置/文档/prompt 小调整 + 满足 fix 条件 → 直接调用 `/comate-fix`
-- **用户输入指向一份原始 PRD**（给了 PRD 路径/编号，或明确说「这是 PRD / 从这份需求文档开始」，典型路径 `docs/knowledge-base/**/PRD-*.md`）**且无对应活跃 change** → 直接调用 `/comate-gate`（阶段 0：先过门禁，再拆分建 change）。不要直接调 `/comate-open`——PRD 必须先过质量门禁。
-- 无预设命中 → 按下表处理
-| 活跃 change | 用户输入 | 行为 |
-|-------------|----------|------|
-| 无 | 指向原始 PRD | → 调用 `/comate-gate` |
-| 无 | 非预设输入 | → 调用 `/comate-open` |
-| 恰好 1 个 | `/comate <描述>` | → **询问**：继续该 change 还是新建 |
-| 多个 | `/comate <描述>` | → **询问**：继续已有还是新建；继续则列出供选择 |
-| 恰好 1 个 | `/comate` 无描述 | → 自动选中，进入 Step 1 |
-| 多个 | `/comate` 无描述 | → 列出 change 供用户选择 |
+**Step 0：活跃 change 发现 + 决策状态优先检查**
+<CRITICAL>
+**执行顺序不可颠倒**：先识别用户是否明确要求新建 change；否则读取状态检查明确的 `*-awaiting` 决策标记，再做普通意图过滤和 change 匹配。
+若用户正在回答已持久化的决策问题（如"worktree + TDD"、"确认方案A"），直接路由到对应子 skill。
+</CRITICAL>
+1. **活跃 change 快速发现**：
+   运行 `openspec list --json` 获取所有活跃 change。
+   - **无活跃 change** → 跳到步骤 3（意图快速过滤 + 预设探测）
+   - **有活跃 change** → 继续步骤 2
+2. **待决策状态检查**（防止决策答复被误判为新任务）：
+   a. **确定目标 change**：
+      - 恰好 1 个活跃 change → 自动选中
+      - 多个活跃 change 且用户指定了 change 名称（`/comate <name>`）→ 选中该 change
+      - 多个活跃 change 且用户未指定 → **暂存待选列表，继续检查**（稍后在步骤 3.2 处理）
+   b. **读取状态（若已确定目标 change）**：
+      读取 `openspec/changes/<name>/.comate.yaml`，获取 `phase` 和 `phase_step`。
+   c. **检查是否在等待决策**：
+      只有 `phase_step` 是当前阶段的明确等待标记时，才说明子 skill 正在等待用户答复：
+      - `open.review-awaiting`
+      - `design.approval-awaiting`
+      - `build.options-awaiting` / `build.scope-awaiting` / `fix.upgrade-awaiting`
+      - `verify.failure-awaiting` / `verify.spec-drift-awaiting` / `verify.branch-awaiting`
+      兼容 `bd16c0f` 产生的活跃状态：仅在 phase 对应时，把 `open:4`、`design:1b`、`build:2` 分别视为上述等待标记；恢复后立即写入新格式。其它旧值只是普通进度。
+      普通进度（如 `design.brainstorm-complete`）、已确认状态和依赖阻塞状态都**不是**待决策，不得抢占用户的新请求。用户明确说“新建 change”时也优先按新建意图处理。
+      **立即路由到对应子 skill**（根据 `phase` 字段）：
+      - `phase: open` → 调用 `/comate-open`
+      - `phase: design` → 调用 `/comate-design`
+      - `phase: build` → 调用 `/comate-build`
+      - `phase: verify` → 调用 `/comate-verify`
+      - `phase: archive` → 调用 `/comate-archive`
+      子 skill 的**幂等性检查**会：
+      1. 读取 `phase_step` 的值
+      2. 验证该步骤是否与当前 `phase` 匹配
+      3. 恢复到正确的步骤（跳过已完成的步骤，直接进入下一步）
+      **结束 Step 0，不执行后续逻辑**。
+   d. **若没有匹配当前阶段的等待标记**：
+      说明没有未完成的决策点，继续步骤 3（意图过滤）。
+3. **意图快速过滤 + 幂等性匹配**：
+   3.1. **意图快速过滤**（仅当步骤 2 未命中时执行）：
+   先检查用户输入是否**明确表达了希望进入某个特定阶段**。如果用户没有明确指示，则无条件自动探测当前阶段，不询问不推测。
+   **明确意图的识别规则**：用户消息中包含以下**动作关键词 + 阶段名**的直接组合之一时，才算明确意图：
+   | 阶段 | 明确意图的关键词组合（任一命中即算） |
+   |------|-------------------------------------|
+   | open | "开题"/"创建 change"/"新建 change"/"起草 proposal" |
+   | design | "设计"/"写设计文档"/"brainstorming"/"开始设计" |
+   | build | "实施"/"开始构建"/"执行计划"/"写代码"/"开始 build" |
+   | verify | "验证"/"检查实现"/"运行测试"/"开始 verify" |
+   | archive | "归档"/"完成收尾"/"合并 delta spec"/"开始 archive" |
+   **不算明确意图的情况**（这些都应自动探测，不询问）：
+   - 仅提及问题、需求、想法，无阶段动作词："修复这个 bug" / "优化性能" / "加个功能"
+   - 仅描述当前状态："设计做完了" / "代码写好了" / "测试通过了"
+   - 询问式："现在该做什么" / "下一步是什么" / "继续"
+   - 澄清式："刚才的设计有问题" / "build 阶段遇到错误"
+   - **决策答复**："worktree + TDD" / "选择方案 A" / "确认" / "继续构建"（这些应在步骤 2 被拦截）
+   **过滤结果**：
+   - **明确意图命中** → 直接跳到对应阶段的 skill（不运行后续步骤）
+   - **无明确意图** → 继续步骤 3.2
+   3.2. **活跃 change 匹配**（防止重复创建 change）：
+   **前置条件**：有活跃 change 且用户输入无明确意图。
+   **处理逻辑**：
+   a. **用户输入仅为 `/comate` 无任何描述**：
+      - 恰好 1 个活跃 change → 已在步骤 2 选中，进入 Step 1
+      - 多个活跃 change → 列出所有 change 供用户选择，选中后进入 Step 1
+   b. **用户输入包含任务描述但未指定 change 名称**（`/comate <描述>`）：
+      - **关键幂等检查**（防止重复创建 change）：
+        1. 遍历所有活跃 change
+        2. 对每个 change，读取 `proposal.md` 和 `specs/*/spec.md`
+        3. 检查用户描述是否与该 change 的需求高度匹配（关键词重叠、问题域相同、目标一致）
+        4. **若找到匹配的 change**：
+           - 自动选中该 change
+           - 说明「检测到您的描述与活跃 change <name> 的需求匹配，将继续该 change」
+           - 进入 Step 1（读取该 change 的状态）
+        5. **若所有 change 都不匹配**：
+           - **AskUserQuestion 询问**：「检测到 {N} 个活跃 change：{列表及简要描述}。您的任务是：继续某个已有 change，还是新建 change？」
+           - 选项 1：「继续已有 change」→ 让用户选择具体哪个 change，进入 Step 1
+           - 选项 2：「新建 change」→ 进入步骤 4（预设探测）
+4. **预设探测**（决定新 change 的入口）：
+   当确定需要新建 change 时（无活跃 change，或用户选择新建），按以下优先级探测：
+   a. **fix 预设**：
+      - 用户明确描述 bug 修复或文案/配置/文档/prompt 小调整
+      - 且满足 fix 条件（见 `/comate-fix` skill）
+      - → 直接调用 `/comate-fix`，不进入普通 open 分支
+   b. **gate 预设**（原始 PRD 入口）：
+      - 用户输入指向一份原始 PRD（给了 PRD 路径/编号，或明确说「这是 PRD / 从这份需求文档开始」）
+      - 典型路径：`docs/knowledge-base/**/PRD-*.md`
+      - **且无对应活跃 change**
+      - → 直接调用 `/comate-gate`（阶段 0：先过门禁，再拆分建 change）
+      - **不要直接调 `/comate-open`**——PRD 必须先过质量门禁
+   c. **普通 open**（默认）：
+      - 无预设命中
+      - → 调用 `/comate-open`
 <IMPORTANT>
 用户选择「新建 change」时，**必须调用 `/comate-open`**，不要直接调 `/opsx:new`。
@@ -41,10 +148,26 @@ agent 做决策只需读本节，其余参见末尾「参考附录」。决策
 直接调 `/opsx:new` 会导致 `.comate.yaml` 缺失，破坏后续阶段探测。
 </IMPORTANT>
-**Step 1：读取 `.comate.yaml` 状态元数据**
+**Step 1：读取 `.comate.yaml` 状态元数据**（仅在 Step 0 未直接路由时执行）
 优先读 `openspec/changes/<name>/.comate.yaml`。不可用时回落到 `openspec status --change "<name>" --json`、`tasks.md`、`docs/superpowers/` 文件检查。
+**关键字段**：
+- `phase`：当前阶段（`open` / `design` / `build` / `verify` / `archive`）
+- `phase_step`：当前阶段内的步骤标记（如 `design.approval-awaiting`、`build.options-confirmed`）
+- `workflow`：流程类型（`full` / `fix`）
+- `build_mode`、`isolation`、`tdd_mode`：build 阶段的决策字段
+- `verify_result`：验证结果（`pending` / `pass` / `fail`）
+**phase_step 语义说明**：
+`phase_step` 记录**当前阶段**内的步骤，用于断点恢复和幂等性检查：
+- 非空值表示"已完成到该步骤"，恢复时从**下一步**开始
+- `*-awaiting` 表示正在等待用户答复，只有这类值触发决策优先路由
+- `*-confirmed` 表示用户已确认的决策点
+- `build.blocked-by-<dependency>` 表示被依赖阻塞，但不是等待当前用户决策
+- 空值或 `null` 表示该阶段尚未开始或已完成所有步骤
 **断点恢复规则**：
 - 每次上下文恢复都重跑 Step 0、Step 1；不要信任对话历史做阶段探测。
 - 有活跃 change 且工作树有未提交改动时，按 `comate/reference/dirty-worktree.md` 协议处理。
@@ -53,6 +176,10 @@ agent 做决策只需读本节，其余参见末尾「参考附录」。决策
 - 若 `phase: open` 但 proposal/design/tasks 已完成，先 `bash "$COMATE" guard <name> open --apply` 修复状态，再继续探测。
 - 若 `phase: archive`，只调用 `/comate-archive`；归档成功后 change 移入 archive 目录，不要再对旧活跃目录跑 guard。
+**phase_step 生命周期**：
+`phase_step` 严格属于当前阶段。所有 `state transition` 在切换 `phase` 时原子清空 `phase_step` 和 `phase_step_data`。禁止跨阶段保留或比较步骤编号；跨阶段事实必须记录在专用字段或落盘产物中。
 **Step 2：阶段判定**（按顺序检查，首个命中者生效）
 1. `archived: true` 或 change 已移入 archive → 流程完成
@@ -148,9 +275,10 @@ bash "$COMATE" state   <name> validate
 bash "$COMATE" guard   <name> <phase> [--apply] [--json]
 bash "$COMATE" handoff <name> <design|build> --write [--full]
 bash "$COMATE" sources <name> track <file...> [--note <text>]
-bash "$COMATE" sources <name> check | list
-bash "$COMATE" sources find <file>
-bash "$COMATE" archive <name> [--dry-run]
+bash "$COMATE" sources <name> check | list
+bash "$COMATE" sources find <file>
+bash "$COMATE" dependency <name> archived
+bash "$COMATE" archive <name> [--dry-run]
 bash "$COMATE" status
 bash "$COMATE" doctor
 ```
@@ -172,7 +300,7 @@ bash "$COMATE" doctor
 | `verify_mode` | `light` / `full`（由 scale 评估写入） |
 | `verify_result` | `pending` / `pass` / `fail` |
 | `verification_report` | 验证报告路径，verify-pass 前必须指向真实文件 |
-| `branch_status` | `pending` / `handled` |
+| `branch_status` | `pending` / `handled` / `discarded` |
 | `handoff_context` / `handoff_hash` | design 交接包路径 + 源文件 sha256 |
 | `impl_context` / `impl_hash` | build 交接包路径 + plan+tasks 的 sha256（防漂移） |
 | `direct_override` | full 流程用 `direct` 需显式 `true` |

package/skills/comate/reference/decision-points.md CHANGED Viewed

@@ -61,11 +61,11 @@
    引用：`comate-verify` Step 1b、Step 2b 的 Spec 漂移处理。
 5. **分支收尾方式选择**（verify / finishing-a-development-branch）
-   暂停请用户选择：本地合并 / 推送建 PR / 保持分支 / 丢弃工作。仅在用户选择且对应操作完成后，才写 `branch_status: handled`。
+   暂停请用户选择：本地合并 / 推送建 PR / 保持分支 / 丢弃工作。前三项操作成功后写 `branch_status: handled`；丢弃工作写 `branch_status: discarded` 并停止流程，禁止执行 verify guard 或归档。
    引用：`comate-verify` Step 3。
 6. **预设升级确认**（fix → full）
-   命中升级条件（见 `comate-fix` SKILL 的「升级条件」，bug 模式与调整模式各有阈值）时，暂停请用户确认升级为完整 `/comate`。不得直接进入 `/comate-design`，不得自动补 Design Doc。用户确认后先 `state set <name> workflow full` 再进入完整流程。
+   命中升级条件（见 `comate-fix` SKILL 的「升级条件」，bug 模式与调整模式各有阈值）时，先写 `phase_step: fix.upgrade-awaiting`，再暂停请用户确认。用户确认后执行原子转换 `state transition <name> fix-upgrade`，由脚本清除 fix 默认构建选项并进入 design。
    引用：`comate-fix`「升级条件」。
 7. **构建期范围扩张**（build）

package/skills/comate/scripts/comate-lib.sh CHANGED Viewed

@@ -50,6 +50,8 @@ FIELD_ORDER=(
   schema_version
   workflow
   phase
+  phase_step
+  phase_step_data
   build_mode
   tdd_mode
   isolation
@@ -88,7 +90,7 @@ declare -A ENUMS=(
   [isolation]="branch worktree"
   [verify_mode]="light full"
   [verify_result]="pending pass fail"
-  [branch_status]="pending handled"
+  [branch_status]="pending handled discarded"
   [direct_override]="true false"
   [archived]="true false"
   [source_kind]="conversation file"
@@ -111,6 +113,8 @@ declare -A FREEFORM_KEYS=(
   [verify_command]=1
   [created_at]=1
   [verified_at]=1
+  [phase_step]=1
+  [phase_step_data]=1
 )
 # --- Path location ---

package/skills/comate/scripts/comate.sh CHANGED Viewed

@@ -19,7 +19,7 @@
 #   sources find <file>                      — reverse lookup: changes citing a file
 #   gate    <prd> review                     — create/refresh gate.yaml next to the PRD, pin hash
 #   gate    <prd> set <field> <value>        — write score | blocking_open | gate_status | …
-#   gate    <prd> pass [--tbd]               — mark passed (needs blocking_open=0 + report)
+#   gate    <prd> pass [--tbd]               — pass clean gate or explicitly accepted TBD blockers
 #   gate    <prd> spawned <change>           — record a change fanned out from this PRD
 #   gate    <prd> status [--json]            — print gate status (computes stale on hash drift)
 #   gate    <prd> check                      — precondition guard before spawning a change
@@ -60,7 +60,7 @@ Usage: comate.sh <command> ...
   state   <name> init <workflow>            full | fix
   state   <name> get <field>
   state   <name> set <field> <value>
-  state   <name> transition <event>         open-complete|design-complete|build-complete|verify-pass|verify-fail|archived
+  state   <name> transition <event>         open-complete|design-complete|build-complete|verify-pass|verify-fail|fix-upgrade|archived
   state   <name> check <phase> [--json]
   state   <name> recover <phase>
   state   <name> scale
@@ -72,9 +72,10 @@ Usage: comate.sh <command> ...
   sources <name> check
   sources <name> list
   sources find <file>
+  dependency <name> archived              verify an exact archived change exists
   gate    <prd> review                      create/refresh gate.yaml next to PRD, pin hash
   gate    <prd> set <field> <value>         score | blocking_open | gate_status | …
-  gate    <prd> pass [--tbd]                mark passed (needs blocking_open=0 + report)
+  gate    <prd> pass [--tbd]                pass: zero blockers; --tbd: accepted blockers
   gate    <prd> spawned <change>            record a change fanned out from this PRD
   gate    <prd> status [--json]
   gate    <prd> check                       precondition guard before spawning a change
@@ -138,6 +139,8 @@ state_init() {
 schema_version: $COMATE_SCHEMA_VERSION
 workflow: $workflow
 phase: open
+phase_step: null
+phase_step_data: null
 build_mode: $build_mode
 tdd_mode: $tdd_mode
 isolation: $isolation
@@ -237,7 +240,7 @@ state_transition() {
   validate_change_name "$name"
   validate_enum_event() {
     case "$1" in
-      open-complete|design-complete|build-complete|verify-pass|verify-fail|archived) return 0 ;;
+      open-complete|design-complete|build-complete|verify-pass|verify-fail|fix-upgrade|archived) return 0 ;;
       *) die "$COMATE_USAGE" "ERROR: unknown event '$1'" ;;
     esac
   }
@@ -246,6 +249,13 @@ state_transition() {
   local yaml; yaml=$(require_yaml "$name")
   validate_flat_yaml "$yaml"
+  # phase_step is local to the current phase. Carrying it into the next phase
+  # makes identical step numbers ambiguous and can skip mandatory work.
+  _clear_phase_progress() {
+    yaml_set "$yaml" phase_step null
+    yaml_set "$yaml" phase_step_data null
+  }
   case "$event" in
     open-complete)
       _require_phase "$yaml" open
@@ -255,10 +265,12 @@ state_transition() {
       else
         yaml_set "$yaml" phase build
       fi
+      _clear_phase_progress
       ;;
     design-complete)
       _require_phase "$yaml" design
       yaml_set "$yaml" phase build
+      _clear_phase_progress
       ;;
     build-complete)
       _require_phase "$yaml" build
@@ -267,6 +279,7 @@ state_transition() {
       yaml_set "$yaml" verify_result pending
       yaml_set "$yaml" verification_report null
       yaml_set "$yaml" branch_status pending
+      _clear_phase_progress
       ;;
     verify-pass)
       _require_phase "$yaml" verify
@@ -274,12 +287,36 @@ state_transition() {
       yaml_set "$yaml" verify_result pass
       yaml_set "$yaml" phase archive
       yaml_set "$yaml" verified_at "$(today)"
+      _clear_phase_progress
       ;;
     verify-fail)
       _require_phase "$yaml" verify
-      yaml_set "$yaml" verify_result fail
+      # The failure is captured in the report; once routed back to build the
+      # active verification state must be pending or the orchestrator loops.
+      yaml_set "$yaml" verify_result pending
       yaml_set "$yaml" phase build
+      yaml_set "$yaml" verification_report null
+      yaml_set "$yaml" branch_status pending
+      _clear_phase_progress
+      ;;
+    fix-upgrade)
+      [ "$(yaml_get "$yaml" workflow)" = "fix" ] || \
+        die "$COMATE_BLOCK" "ERROR: fix-upgrade requires workflow=fix"
+      case "$(yaml_get "$yaml" phase)" in
+        open|build) ;;
+        *) die "$COMATE_BLOCK" "ERROR: fix-upgrade is only valid from open or build" ;;
+      esac
+      yaml_set "$yaml" workflow full
+      yaml_set "$yaml" phase design
+      yaml_set "$yaml" build_mode null
+      yaml_set "$yaml" tdd_mode null
+      yaml_set "$yaml" isolation null
+      yaml_set "$yaml" verify_mode null
+      yaml_set "$yaml" direct_override false
+      yaml_set "$yaml" verify_result pending
+      yaml_set "$yaml" verification_report null
       yaml_set "$yaml" branch_status pending
+      _clear_phase_progress
       ;;
     archived)
       _require_phase "$yaml" archive
@@ -498,15 +535,19 @@ state_recover() {
   yaml="$dir/.comate.yaml"
   [ -f "$yaml" ] || die "$COMATE_CORRUPT" "ERROR: .comate.yaml not found at $yaml"
-  local phase workflow
+  local phase workflow phase_step phase_step_data
   phase=$(yaml_get "$yaml" phase)
   workflow=$(yaml_get "$yaml" workflow)
+  phase_step=$(yaml_get "$yaml" phase_step)
+  phase_step_data=$(yaml_get "$yaml" phase_step_data)
   # If a phase arg was passed, honor it for reporting; else use stored phase.
   [ -n "$phase_arg" ] && phase="$phase_arg"
   echo "=== Recovery Context: $name ==="
   echo "Phase: $phase"
   echo "Workflow: $workflow"
+  echo "Phase step: ${phase_step:-null}"
+  echo "Phase step data: ${phase_step_data:-null}"
   echo ""
   local design_doc plan verify_result verify_mode verification_report
@@ -578,7 +619,11 @@ state_recover() {
         echo "Tasks: tasks.md MISSING"
       fi
       echo ""
-      if [ "$isolation" = "null" ] || [ -z "$isolation" ]; then
+      if [[ "$phase_step" == build.blocked-by-* ]]; then
+        local dep="$phase_step_data"
+        if [ -z "$dep" ] || [ "$dep" = "null" ]; then dep="${phase_step#build.blocked-by-}"; fi
+        echo "Recovery action: Blocked by $dep. Run: comate.sh dependency $dep archived"
+      elif [ "$isolation" = "null" ] || [ -z "$isolation" ]; then
         echo "Recovery action: Isolation not selected. AskUserQuestion for branch/worktree."
       elif [ "$build_mode" = "null" ] || [ -z "$build_mode" ]; then
         echo "Recovery action: Build mode not selected. AskUserQuestion for execution method."
@@ -600,7 +645,9 @@ state_recover() {
       _field_status "branch_status" "$branch_status"
       _field_status "impl_hash" "$impl_hash"
       echo ""
-      if [ "$verify_result" = "pass" ] && [ "$branch_status" = "handled" ]; then
+      if [ "$branch_status" = "discarded" ]; then
+        echo "Recovery action: Work was discarded. Run verify-fail to return to build before reimplementing, or explicitly abandon the change."
+      elif [ "$verify_result" = "pass" ] && [ "$branch_status" = "handled" ]; then
         echo "Recovery action: Verification complete. Run guard to transition to archive."
       elif [ "$verify_result" = "pass" ]; then
         echo "Recovery action: Verified but branch not handled. Complete branch handling, set branch_status=handled."
@@ -1345,6 +1392,23 @@ sources_find() {
   return 0
 }
+# dependency <name> archived — prove completion from archived state, rather
+# than inferring it from absence in `openspec list`.
+dependency_archived() {
+  local name="$1"
+  validate_change_name "$name"
+  [ ! -d "openspec/changes/$name" ] || \
+    die "$COMATE_BLOCK" "BLOCK: dependency '$name' is still active"
+  local found="" yaml
+  while IFS= read -r yaml; do
+    [ "$(yaml_get "$yaml" archived)" = "true" ] && found="$yaml"
+  done < <(find openspec/changes/archive -mindepth 2 -maxdepth 2 \
+    -path "*/????-??-??-${name}/.comate.yaml" -type f 2>/dev/null | sort)
+  [ -n "$found" ] || \
+    die "$COMATE_BLOCK" "BLOCK: no archived=true record found for dependency '$name'"
+  log_pass "[DEPENDENCY] archived: $name ($found)"
+}
 # =====================================================================
 # gate — phase 0: PRD quality gate + split precondition
 # =====================================================================
@@ -1416,10 +1480,8 @@ gate_set() {
   log_pass "[GATE] set $field=$value"
 }
-# gate <prd> pass [--tbd] — flip to passed/passed-with-tbd. Hard precondition:
-# blocking_open must be 0 (no open blocking issues). Re-pins prd_hash so a later
-# edit invalidates the pass. --tbd records that the user authorised proceeding
-# with unresolved TBDs (spawned changes must carry ⚠ markers).
+# gate <prd> pass [--tbd] — flip to passed/passed-with-tbd. Normal pass requires
+# zero blockers; --tbd requires at least one explicitly accepted blocker.
 gate_pass() {
   local prd; prd=$(require_prd "$1")
   local tbd=0
@@ -1427,9 +1489,22 @@ gate_pass() {
   local gate; gate=$(gate_path_for "$prd")
   [ -f "$gate" ] || die "$COMATE_CORRUPT" "ERROR: gate not found (run 'gate review' first): $gate"
-  local blocking; blocking=$(yaml_get "$gate" blocking_open)
-  if [ "$blocking" != "0" ]; then
-    die "$COMATE_BLOCK" "BLOCK: blocking_open='$blocking' — resolve all blocking issues (set blocking_open 0) before passing the gate"
+  local score blocking changes_map
+  score=$(yaml_get "$gate" score)
+  blocking=$(yaml_get "$gate" blocking_open)
+  changes_map=$(yaml_get "$gate" changes_map)
+  [[ "$score" =~ ^[0-9]+$ ]] && [ "$score" -ge 0 ] && [ "$score" -le 100 ] || \
+    die "$COMATE_BLOCK" "BLOCK: score must be an integer from 0 to 100 (got '$score')"
+  [[ "$blocking" =~ ^[0-9]+$ ]] || \
+    die "$COMATE_BLOCK" "BLOCK: blocking_open must be a non-negative integer (got '$blocking')"
+  if [ "$tbd" -eq 1 ]; then
+    [ "$blocking" -gt 0 ] || \
+      die "$COMATE_BLOCK" "BLOCK: --tbd requires at least one recorded unresolved blocker"
+  elif [ "$blocking" -ne 0 ]; then
+    die "$COMATE_BLOCK" "BLOCK: blocking_open='$blocking' — resolve all blocking issues or use --tbd after explicit user authorization"
+  fi
+  if [ -z "$changes_map" ] || [ "$changes_map" = "null" ]; then
+    die "$COMATE_BLOCK" "BLOCK: changes_map is required before passing the gate"
   fi
   local report; report=$(yaml_get "$gate" review_report)
   if [ -z "$report" ] || [ "$report" = "null" ] || ! file_nonempty "$report"; then
@@ -1703,7 +1778,7 @@ status() {
     echo "No active changes."
     return 0
   fi
-  local any=0 d name yaml phase workflow build_mode vr dd plan total done tasks_file
+  local any=0 d name yaml phase phase_step workflow build_mode vr dd plan total done tasks_file
   for d in "$changes_dir"/*/; do
     [ -d "$d" ] || continue
     name=$(basename "$d")
@@ -1713,6 +1788,7 @@ status() {
     [ "$(yaml_get "$yaml" archived)" = "true" ] && continue
     any=1
     phase=$(yaml_get "$yaml" phase)
+    phase_step=$(yaml_get "$yaml" phase_step)
     workflow=$(yaml_get "$yaml" workflow)
     build_mode=$(yaml_get "$yaml" build_mode)
     vr=$(yaml_get "$yaml" verify_result)
@@ -1726,6 +1802,7 @@ status() {
     fi
     echo "• $name [phase: $phase, $done/$total tasks]"
     echo "    workflow: $workflow | build_mode: $build_mode"
+    [ -n "$phase_step" ] && [ "$phase_step" != "null" ] && echo "    step: $phase_step"
     [ -n "$dd" ] && [ "$dd" != "null" ] && echo "    design: $dd"
     [ -n "$plan" ] && [ "$plan" != "null" ] && echo "    plan:   $plan"
     [ "$phase" = "verify" ] && echo "    verify_result: $vr"
@@ -1870,6 +1947,11 @@ case "$CMD" in
       esac
     fi
     ;;
+  dependency)
+    NAME="${1:-}"; SUB="${2:-}"
+    [ -n "$NAME" ] && [ "$SUB" = "archived" ] || { usage_top; exit "$COMATE_USAGE"; }
+    dependency_archived "$NAME"
+    ;;
   gate)
     PRD="${1:-}"; SUB="${2:-}"
     [ -n "$PRD" ] && [ -n "$SUB" ] || { usage_top; exit "$COMATE_USAGE"; }

package/skills/comate/tests/comate.bats CHANGED Viewed

@@ -144,8 +144,10 @@ seed_open() {
 @test "open-complete routes full to design" {
   seed_open
+  comate state demo set phase_step open.review-confirmed >/dev/null
   comate state demo transition open-complete
   [ "$(comate state demo get phase)" = "design" ]
+  [ "$(comate state demo get phase_step)" = "null" ]
 }
 @test "open-complete routes fix to build" {
@@ -201,6 +203,56 @@ seed_open() {
   [ "$status" -eq 1 ]
 }
+@test "fix-upgrade resets preset decisions and enters design" {
+  comate state demo init fix
+  comate state demo transition open-complete
+  comate state demo set phase_step build.options-confirmed >/dev/null
+  comate state demo transition fix-upgrade
+  [ "$(comate state demo get workflow)" = "full" ]
+  [ "$(comate state demo get phase)" = "design" ]
+  [ "$(comate state demo get build_mode)" = "null" ]
+  [ "$(comate state demo get tdd_mode)" = "null" ]
+  [ "$(comate state demo get isolation)" = "null" ]
+  [ "$(comate state demo get phase_step)" = "null" ]
+}
+@test "discarded branch cannot pass verification" {
+  comate state demo init full
+  comate state demo set phase verify >/dev/null
+  printf '# pass\n' > report.md
+  comate state demo set verification_report report.md >/dev/null
+  comate state demo set branch_status discarded >/dev/null
+  run comate state demo transition verify-pass
+  [ "$status" -eq 1 ]
+  [ "$(comate state demo get phase)" = "verify" ]
+}
+@test "verify-fail returns to build without a failure routing loop" {
+  comate state demo init full
+  comate state demo set phase verify >/dev/null
+  comate state demo set verify_result fail >/dev/null
+  comate state demo transition verify-fail
+  [ "$(comate state demo get phase)" = "build" ]
+  [ "$(comate state demo get verify_result)" = "pending" ]
+  [ "$(comate state demo get verification_report)" = "null" ]
+}
+@test "recover reports phase-local progress" {
+  comate state demo init full
+  comate state demo set phase_step open.review-awaiting >/dev/null
+  run comate state demo recover open
+  [ "$status" -eq 0 ]
+  [[ "$output" == *"Phase step: open.review-awaiting"* ]]
+}
+@test "status exposes awaiting decisions" {
+  comate state demo init full
+  comate state demo set phase_step open.review-awaiting >/dev/null
+  run comate status
+  [ "$status" -eq 0 ]
+  [[ "$output" == *"step: open.review-awaiting"* ]]
+}
 # --- guard open ---
 @test "guard open passes with full artifacts and applies" {
@@ -436,6 +488,18 @@ SH
   [ "$status" -eq 0 ]
 }
+@test "dependency archived requires an archived=true record" {
+  comate state dep init full
+  run comate dependency dep archived
+  [ "$status" -eq 1 ]
+  comate state dep set phase archive >/dev/null
+  comate state dep transition archived >/dev/null
+  mkdir -p openspec/changes/archive
+  mv openspec/changes/dep openspec/changes/archive/2026-08-20-dep
+  run comate dependency dep archived
+  [ "$status" -eq 0 ]
+}
 @test "top-level usage error returns code 2" {
   run comate frobnicate
   [ "$status" -eq 2 ]
@@ -503,16 +567,41 @@ seed_prd() {
   comate gate "$prd" review >/dev/null
   comate gate "$prd" set score 90 >/dev/null
   comate gate "$prd" set blocking_open 0 >/dev/null
+  comate gate "$prd" set changes_map "demo:功能项1" >/dev/null
   run comate gate "$prd" pass
   [ "$status" -eq 1 ]
   [[ "$output" == *"report"* ]]
 }
+@test "gate pass blocks without a confirmed changes map" {
+  local prd; prd=$(seed_prd)
+  comate gate "$prd" review >/dev/null
+  comate gate "$prd" set score 90 >/dev/null
+  comate gate "$prd" set blocking_open 0 >/dev/null
+  printf '# report\n' > "docs/knowledge-base/requirements/test/PRD-001-REVIEW.md"
+  run comate gate "$prd" pass
+  [ "$status" -eq 1 ]
+  [[ "$output" == *"changes_map"* ]]
+}
+@test "gate pass --tbd requires unresolved blockers" {
+  local prd; prd=$(seed_prd)
+  comate gate "$prd" review >/dev/null
+  comate gate "$prd" set score 90 >/dev/null
+  comate gate "$prd" set blocking_open 0 >/dev/null
+  comate gate "$prd" set changes_map "demo:功能项1" >/dev/null
+  printf '# report\n' > "docs/knowledge-base/requirements/test/PRD-001-REVIEW.md"
+  run comate gate "$prd" pass --tbd
+  [ "$status" -eq 1 ]
+  [[ "$output" == *"requires at least one"* ]]
+}
 @test "gate pass succeeds and check passes after report written" {
   local prd; prd=$(seed_prd)
   comate gate "$prd" review >/dev/null
   comate gate "$prd" set score 90 >/dev/null
   comate gate "$prd" set blocking_open 0 >/dev/null
+  comate gate "$prd" set changes_map "demo:功能项1" >/dev/null
   printf '# 评审报告\n' > \
     "docs/knowledge-base/requirements/test/PRD-001-REVIEW.md"
   run comate gate "$prd" pass
@@ -525,7 +614,8 @@ seed_prd() {
   local prd; prd=$(seed_prd)
   comate gate "$prd" review >/dev/null
   comate gate "$prd" set score 65 >/dev/null
-  comate gate "$prd" set blocking_open 0 >/dev/null
+  comate gate "$prd" set blocking_open 2 >/dev/null
+  comate gate "$prd" set changes_map "demo:功能项1" >/dev/null
   printf '# 评审报告\n' > \
     "docs/knowledge-base/requirements/test/PRD-001-REVIEW.md"
   run comate gate "$prd" pass --tbd
@@ -539,6 +629,7 @@ seed_prd() {
   comate gate "$prd" review >/dev/null
   comate gate "$prd" set score 90 >/dev/null
   comate gate "$prd" set blocking_open 0 >/dev/null
+  comate gate "$prd" set changes_map "demo:功能项1" >/dev/null
   printf '# 评审报告\n' > \
     "docs/knowledge-base/requirements/test/PRD-001-REVIEW.md"
   comate gate "$prd" pass >/dev/null
@@ -554,6 +645,7 @@ seed_prd() {
   comate gate "$prd" review >/dev/null
   comate gate "$prd" set score 90 >/dev/null
   comate gate "$prd" set blocking_open 0 >/dev/null
+  comate gate "$prd" set changes_map "demo:功能项1" >/dev/null
   printf '# 评审报告\n' > \
     "docs/knowledge-base/requirements/test/PRD-001-REVIEW.md"
   comate gate "$prd" pass >/dev/null
@@ -572,6 +664,7 @@ seed_prd() {
   comate gate "$prd" review >/dev/null
   comate gate "$prd" set score 90 >/dev/null
   comate gate "$prd" set blocking_open 0 >/dev/null
+  comate gate "$prd" set changes_map "login-flow:功能项1" >/dev/null
   printf '# 报告\n' > \
     "docs/knowledge-base/requirements/test/PRD-001-REVIEW.md"
   comate gate "$prd" pass >/dev/null
@@ -587,6 +680,7 @@ seed_prd() {
   comate gate "$prd" review >/dev/null
   comate gate "$prd" set score 90 >/dev/null
   comate gate "$prd" set blocking_open 0 >/dev/null
+  comate gate "$prd" set changes_map "login-flow:功能项1;logout-flow:功能项2" >/dev/null
   printf '# 报告\n' > \
     "docs/knowledge-base/requirements/test/PRD-001-REVIEW.md"
   comate gate "$prd" pass >/dev/null
@@ -616,6 +710,7 @@ seed_prd() {
   comate gate "$prd" review >/dev/null
   comate gate "$prd" set score 90 >/dev/null
   comate gate "$prd" set blocking_open 0 >/dev/null
+  comate gate "$prd" set changes_map "demo:功能项1" >/dev/null
   printf '# 报告\n' > \
     "docs/knowledge-base/requirements/test/PRD-001-REVIEW.md"
   comate gate "$prd" pass >/dev/null

package/skills/comate-build/SKILL.md CHANGED Viewed

@@ -25,7 +25,43 @@ fi
 bash "$COMATE" state <name> check build
 ```
-**幂等性**：build 阶段操作可安全重复。读 `phase` 确认仍在 build，读 plan 文件头的 `base-ref`，再读 tasks.md 找第一个未勾选任务继续。已提交的任务不得重复提交。
+**幂等性检查**：
+1. 读取 `.comate.yaml` 的 `plan`、`isolation`、`build_mode`、`tdd_mode`、`phase_step`、`phase_step_data`
+2. **检查是否被依赖阻塞**（最高优先级检查）：
+   - 若 `phase_step` 为 `build.blocked-by-<dependency>`：
+     - 从 `phase_step` 或 `phase_step_data` 中提取依赖的 change 名称
+     - 运行 `bash "$COMATE" dependency <dependency> archived` 检查归档目录中是否存在该 change 且其 `.comate.yaml` 明确记录 `archived: true`；不得用“不在活跃列表”推断归档完成
+     - **若依赖已归档**：
+       ```bash
+       bash "$COMATE" state <name> set phase_step build.options-confirmed
+       bash "$COMATE" state <name> set phase_step_data null
+       ```
+       清除阻塞标记，说明「依赖 change <dependency> 已完成，继续当前 change 的 build」，继续第 3 步检查
+     - **若依赖未归档**：提示「当前 change 正在等待 <dependency> 完成。请先完成 <dependency> 的全流程后再继续。」，**立即退出**
+3. **已完成 Step 3（工作方式已选定）** 的判定条件：
+   - `isolation`、`build_mode`、`tdd_mode` **三个字段全部已设置且非 null**
+   - 或 `phase_step` 值为 `build.options-confirmed`
+4. **幂等分支**：
+   - **三个决策字段全部已设置** → 跳过 Step 3a-3c，说明「工作方式已选定：isolation={value}, build_mode={value}, tdd_mode={value}」，直接进入执行（加载对应技能）
+   - **任一字段未设置或为 null**：
+     - 若 `phase_step` 为 `build.plan-created` 或 `build.plan-recorded` → 继续对应步骤（见下方第 5 点）
+     - 若 `plan` 未设置 → 从 Step 1 开始
+     - 若 `plan` 已设置但决策未完成 → 从 Step 3 开始
+5. **断点恢复**（根据 `phase_step` 值）：
+   - `phase_step` 为 `build.plan-created`（或旧版 `1`）→ 从 Step 2 开始并改写新格式
+   - `phase_step` 为 `build.plan-recorded` / `build.options-awaiting`（或旧版 `2`）→ 从 Step 3 恢复并改写新格式
+   - `phase_step` 为 `build.options-confirmed`（或旧版 `3-confirmed`）→ 直接加载执行技能并改写新格式
+   - `phase_step` 为 `build.blocked-by-*` → 见第 2 点的依赖阻塞检查
+6. **已进入执行阶段**（plan 已设置、决策已完成）：
+   - 读 tasks.md 找第一个未勾选任务继续
+   - 已提交的任务不得重复提交
+   - 上下文压缩恢复时，重新加载对应的执行技能，然后继续未完成的任务
 ### 1. 制定计划
@@ -44,10 +80,17 @@ base-ref: <实施前的 git rev-parse HEAD>
 `base-ref` 用于验证阶段跨提交统计改动规模。创建计划时先 `git rev-parse HEAD` 记录。
+**步骤完成后记录**：
+```bash
+bash "$COMATE" state <name> set phase_step build.plan-created
+```
 ### 2. 记录计划路径
 ```bash
 bash "$COMATE" state <name> set plan docs/superpowers/plans/YYYY-MM-DD-feature.md
+bash "$COMATE" state <name> set phase_step build.plan-recorded
 ```
 无需手动改 phase，guard 会在退出条件满足后自动流转。
@@ -79,11 +122,17 @@ bash "$COMATE" state <name> set plan docs/superpowers/plans/YYYY-MM-DD-feature.m
 #### 3c. 联合决策（仍有 ≥2 有效选项的维度才问）
-对仍有多个有效选项的维度，**一次 AskUserQuestion 问清全部**，选 `branch` 时**分支名也在同一次确认**，不得先问是否继续再二次追问配置或命名。已在 3b 自动写入的维度不再列入问题。每个选项附推荐理由（推荐只说明倾向，不代替用户拍板）：
+对仍有多个有效选项的维度，**一次 AskUserQuestion 问清全部**，选 `branch` 时**分支名也在同一次确认**，不得先问是否继续再二次追问配置或命名。已在 3b 自动写入的维度不再列入问题。每个选项附推荐理由（推荐只说明倾向，不代替用户拍板）：
 - **工作区隔离**：`branch` 新建分支（简单快速，≤3 文件推荐）/ `worktree` 独立工作区（需并行或当前分支有未提交工作时推荐）。
 - **执行方式**：`subagent-driven-development`（任务 ≥3、独立、需双阶段审查）/ `executing-plans`（任务 ≤2 且无跨模块依赖，或来自 fix 预设）。
-- **TDD 模式**：`tdd`（涉及业务逻辑/新功能/API，推荐）/ `direct`（无需测试覆盖或用户明确跳过）。
+- **TDD 模式**：`tdd`（涉及业务逻辑/新功能/API，推荐）/ `direct`（无需测试覆盖或用户明确跳过）。
+提问前先持久化：
+```bash
+bash "$COMATE" state <name> set phase_step build.options-awaiting
+```
 用户选择后（连同 3b 已自动应用的维度）写入：
@@ -91,6 +140,7 @@ bash "$COMATE" state <name> set plan docs/superpowers/plans/YYYY-MM-DD-feature.m
 bash "$COMATE" state <name> set isolation <branch|worktree>
 bash "$COMATE" state <name> set build_mode <subagent-driven-development|executing-plans|direct>
 bash "$COMATE" state <name> set tdd_mode <tdd|direct>
+bash "$COMATE" state <name> set phase_step build.options-confirmed
 ```
 `isolation` 是脚本级硬约束，保持 `null` 时 `build → verify` 的 guard 和 `state transition build-complete` 都会失败。
@@ -136,9 +186,36 @@ bash "$COMATE" state <name> set build_mode direct
 |------|------|------|
 | 小 | 遗漏验收场景、边界条件 | 直接编辑 delta spec + design.md，追加 tasks.md |
 | 中 | 接口变更、新增组件、数据流变化 | **AskUserQuestion 确认后**加载 `superpowers:brainstorming` 更新 Design Doc + delta spec |
-| 大 | 全新 capability | **AskUserQuestion 确认拆分后**用 `/comate-open` 创建独立 change |
-**50% 阈值**：以 tasks.md 初始任务总数为基准，新增任务超过总数一半即视为超范围，**必须 AskUserQuestion 暂停**决定是否拆分。创建独立 change 必须调 `/comate-open`，不得直接调 `/opsx:new`。
+| 大 | 全新 capability | **AskUserQuestion 确认拆分后**用 `/comate-open` 创建独立 change，**当前 change 的 build 流程立即终止** |
+**50% 阈值**：以 tasks.md 初始任务总数为基准，新增任务超过总数一半即视为超范围，**必须 AskUserQuestion 暂停**决定是否拆分。创建独立 change 必须调 `/comate-open`，不得直接调 `/opsx:new`。
+凡需 AskUserQuestion 决定范围扩张时，提问前先写 `phase_step: build.scope-awaiting`；用户决定继续当前 change 后恢复为 `build.options-confirmed`。
+**大规模扩张（全新 capability）确认拆分后的流程终止规则**：
+1. 用 `/comate-open` 创建独立 change `<new-change-name>`
+2. **当前 change `<current>` 的 build 流程立即暂停**，记录依赖关系：
+   ```bash
+   bash "$COMATE" state <current> set phase_step "build.blocked-by-<new-change-name>"
+   bash "$COMATE" state <current> set phase_step_data "<new-change-name>"
+   ```
+3. 提示用户：
+   ```
+   已创建独立 change <new-change-name>。
+   当前 change <current> 的 build 流程已暂停，等待 <new-change-name> 完成。
+   请先完成 <new-change-name> 的全流程（design → build → verify → archive），
+   然后再继续 <current> 的 build。
+   ```
+4. **立即退出当前 /comate 调用**，不继续执行当前 change 的后续任务，不进入 Step 5
+**恢复被阻塞的 change**：
+当用户稍后运行 `/comate <current>` 时，Step 0 幂等性检查会发现 `phase_step` 包含 `blocked-by` 标记：
+- 检查依赖的 change 是否已归档
+- 若 `dependency <name> archived` 通过 → 清除阻塞标记，恢复 `phase_step` 为 `build.options-confirmed`，继续执行 tasks.md 中未完成的任务
+- 若未归档 → 提示用户先完成依赖 change，退出
 ### 5. 上下文管理与 build 交接包

package/skills/comate-design/SKILL.md CHANGED Viewed

@@ -25,7 +25,39 @@ fi
 bash "$COMATE" state <name> check design
 ```
-**幂等性**：design 阶段操作可安全重试。若 `handoff_context` 和 `handoff_hash` 已存在，先确认与当前产物一致再决定是否重新生成。
+**幂等性检查**：
+1. 读取 `.comate.yaml` 的 `design_doc`、`handoff_context`、`handoff_hash`、`phase_step`
+2. **已完成 Step 1c（方案已确认）** 的判定条件（按优先级，首个命中即算）：
+   a. **phase_step 明确标记已确认**（最高优先级）：
+      - `phase_step` 值为 `design.approval-confirmed` 或 `design.complete`（旧版 `1c-confirmed` / `2` 兼容一次）
+      - → **立即判定为已完成 Step 1c**，跳过 Step 1a-1c
+   b. **Design Doc 文件存在且格式正确**（次优先级）：
+      - `design_doc` 已设置且文件存在
+      - frontmatter 含 `comate_change: <name>`
+      - frontmatter 含 `role: technical-design`
+      - frontmatter 含 `canonical_spec: openspec`
+      - 文件内容非空（除了 frontmatter 外有实质设计内容）
+      - → **判定为已完成 Step 1c**，跳过 Step 1a-1c
+   **说明**：之所以 `phase_step` 优先级更高，是因为它是原子操作记录的决策状态，即使 Design Doc 文件创建失败或被误删，也能防止重复进入决策流程。
+3. **幂等分支**：
+   - **已完成 Step 1c 且 Design Doc 存在** → 跳过 Step 1a-1c，检查交接包：
+     - 若 `handoff_context` 和 `handoff_hash` 已设置且验证通过 → 直接进入 Step 2 的 guard 检查
+     - 若交接包缺失或 hash 不匹配 → 重新生成交接包（`bash "$COMATE" handoff <name> design --write`），**但不重新 brainstorming，不重新确认方案**，然后进入 Step 2
+   - **已确认但 Design Doc 缺失** → 从 `.comate/design-candidate.md` 恢复已确认方案并创建 Design Doc；候选文件也缺失时停止并报告状态损坏，不得假称 Design Doc 已存在，也不得重新向用户询问同一决策
+   - **未完成 Step 1c** → 继续 Step 1a
+4. **断点恢复**（根据 `phase_step` 值）：
+   - `phase_step` 为 `design.handoff-written`（或旧版 `1a`）→ 从 Step 1b 开始并改写新格式
+   - `phase_step` 为 `design.brainstorm-complete` / `design.approval-awaiting`（或旧版 `1b`）→ 从候选文件恢复 Step 1c 并改写新格式
+   - `phase_step` 为 `design.approval-confirmed` 或 `design.complete` → 见第 3 点幂等分支
+5. **特别注意**：即使上下文压缩或会话中断，只要 `phase_step` 已标记 `design.approval-confirmed` 或 Design Doc 文件存在且格式正确，**就不得重新执行 brainstorming 或重新要求用户确认方案**。
 ### 1a. 生成 OpenSpec → Superpowers 交接包
@@ -33,6 +65,8 @@ bash "$COMATE" state <name> check design
 ```bash
 bash "$COMATE" handoff <name> design --write
+# 记录步骤完成
+bash "$COMATE" state <name> set phase_step design.handoff-written
 ```
 脚本生成 `openspec/changes/<name>/.comate/handoff/design-context.{json,md}` 并在 `.comate.yaml` 写入 `handoff_context` / `handoff_hash`。默认是 **compact 可追溯摘录**（含脚本标记 `Generated-by: comate`、source path、line range、sha256），不是 agent summary。需全文时加 `--full`。
@@ -62,13 +96,48 @@ canonical_spec: openspec
 禁止跳过；该技能不可用时停止流程并提示安装 Superpowers，不要用普通对话替代。
-brainstorming 阶段不写 Design Doc 文件，仅产出方案供 Step 1c 确认。
+brainstorming 阶段不写最终 Design Doc；但必须把完整候选方案写入 `openspec/changes/<name>/.comate/design-candidate.md`，供确认与上下文恢复使用。
+**步骤完成后记录**：
+```bash
+bash "$COMATE" state <name> set phase_step design.brainstorm-complete
+```
 ### 1c. 用户确认设计方案（决策阻塞点 2）
 **必须使用 AskUserQuestion 工具暂停等待用户明确确认设计方案**。规则见 `comate/reference/decision-points.md` 第 2 条。确认前不得创建最终 Design Doc、写 `design_doc`、跑 design guard 或进入 build。
-展示摘要：采用的技术方案、关键取舍与风险、测试策略、Spec Patch（如有）。用户确认后才继续 Step 2；要求调整则继续迭代。
+展示摘要：采用的技术方案、关键取舍与风险、测试策略、Spec Patch（如有）。用户确认后才继续 Step 2；要求调整则继续迭代。
+提问前先确认候选文件非空，并持久化等待状态：
+```bash
+bash "$COMATE" state <name> set phase_step design.approval-awaiting
+```
+**确认后的处理顺序（不可颠倒）**：
+1. **立即记录决策状态**：
+   ```bash
+   bash "$COMATE" state <name> set phase_step design.approval-confirmed
+   ```
+2. **然后创建 Design Doc 文件**（保存到 `docs/superpowers/specs/YYYY-MM-DD-topic-design.md`），frontmatter 必须包含：
+   ```yaml
+   ---
+   comate_change: <name>
+   role: technical-design
+   canonical_spec: openspec
+   ---
+   ```
+3. **记录 design_doc 路径**：
+   ```bash
+   bash "$COMATE" state <name> set design_doc docs/superpowers/specs/YYYY-MM-DD-topic-design.md
+   ```
+**说明**：候选方案先落盘，确认后再记录 `design.approval-confirmed` 并创建最终文件。这样中断恢复既不会重复提问，也不会丢失创建 Design Doc 所需内容。
 ### 2. 更新 comate 状态
@@ -79,6 +148,9 @@ bash "$COMATE" state <name> set design_doc docs/superpowers/specs/YYYY-MM-DD-top
 # 如有 delta spec 变更，重新生成 handoff 以更新 hash
 bash "$COMATE" handoff <name> design --write
+# 记录步骤完成
+bash "$COMATE" state <name> set phase_step design.complete
 # 自动流转
 bash "$COMATE" guard <name> design --apply
 ```

package/skills/comate-fix/SKILL.md CHANGED Viewed

@@ -138,15 +138,19 @@ Fix 为**一次性连续执行**。调用后在自有步骤间自动推进，但
 | 需新增 capability | 超出局部优化 |
 | 需 delta spec | 影响已有规格 |
-**必须使用 AskUserQuestion 工具暂停确认升级**。用户确认后**先回退到 open 阶段并更新 workflow**，再走完整流程：
+**必须使用 AskUserQuestion 工具暂停确认升级**。提问前记录：
 ```bash
-bash "$COMATE" state <name> set phase open
-bash "$COMATE" state <name> set workflow full
-bash "$COMATE" state <name> transition open-complete
+bash "$COMATE" state <name> set phase_step fix.upgrade-awaiting
 ```
-此时 phase 已转换到 `design`（因为 workflow 是 full），然后**立即加载 `comate-design` skill** 补 Design Doc。用户不确认则停止 fix 并报告超出适用范围。
+用户确认后使用原子状态转换进入完整流程：
+```bash
+bash "$COMATE" state <name> transition fix-upgrade
+```
+该转换会原子设置 `workflow: full`、进入 `phase: design`，并清空 fix 预置的 `build_mode` / `tdd_mode` / `isolation` / `verify_mode` 及阶段进度，避免 full build 误沿用 `direct`。然后**立即加载 `comate-design` skill** 补 Design Doc。用户不确认则停止 fix 并报告超出适用范围。
 ## 退出条件

package/skills/comate-gate/SKILL.md CHANGED Viewed

@@ -42,7 +42,7 @@ gate 命令族（退出码：`0` 通过 / `1` 阻塞 / `2` 用法 / `3` 环境 /
 ```bash
 bash "$COMATE" gate <prd> review              # 建/刷新 gate.yaml，钉 PRD 哈希，回报告路径
 bash "$COMATE" gate <prd> set <field> <value> # 写 score | blocking_open | gate_status
-bash "$COMATE" gate <prd> pass [--tbd]         # 置 passed（要求 blocking_open=0 且报告非空）
+bash "$COMATE" gate <prd> pass [--tbd]         # 普通通过要求 0 阻断；--tbd 要求有已授权的未解决阻断
 bash "$COMATE" gate <prd> spawned <change>     # 记录据此 PRD 扇出的 change
 bash "$COMATE" gate <prd> status [--json]      # 查状态（哈希漂移自动判 stale）
 bash "$COMATE" gate <prd> check                # comate-open 建 change 前的前置守卫
@@ -209,12 +209,12 @@ bash "$COMATE" gate <prd> set changes_map "changeA:功能项1,2,3;changeB:功能
 映射与 `blocking_open` 都就绪后，置门禁通过：
 ```bash
-bash "$COMATE" gate <prd> pass          # 阻断已清零
-# 或用户授权带 TBD：
-bash "$COMATE" gate <prd> pass --tbd
-```
-`pass` 会硬校验 `blocking_open=0` 且报告非空，并重钉 PRD 哈希——之后 PRD 再被改，哈希漂移会使门禁 `stale`，须重跑 `/comate-gate`。
+bash "$COMATE" gate <prd> pass          # 阻断已清零
+# 或用户授权带 TBD：
+bash "$COMATE" gate <prd> pass --tbd
+```
+`pass` 会硬校验评分为 0–100、`changes_map` 非空、报告非空；普通 pass 要求 `blocking_open=0`，`--tbd` 则要求存在至少 1 个已记录且经用户明确接受的未解决阻断项。之后 PRD 再被改，哈希漂移会使门禁 `stale`，须重跑 `/comate-gate`。
 ### 6. 逐 Change 初始化（调 comate-open）

package/skills/comate-open/SKILL.md CHANGED Viewed

@@ -63,8 +63,11 @@ if [ -z "$COMATE" ]; then
   return 1 2>/dev/null || exit 1
 fi
+bash "$COMATE" state <name> init full
 ```
+这会创建 `openspec/changes/<name>/.comate.yaml`，初始状态：`workflow: full`, `phase: open`, `phase_step: null`。
 ### 3b. 判定需求来源(源文件追踪)
 `state init` 默认写入 `source_kind: conversation`、`source_manifest: null`(需求由对话产生)。
@@ -91,7 +94,7 @@ bash "$COMATE" gate <prd路径> spawned <name>
 需求**来自对话**时跳过本步。
-### 3. 入口状态验证
+### 3. 入口状态验证与幂等性检查
 ```bash
 bash "$COMATE" state <name> check open
@@ -99,16 +102,41 @@ bash "$COMATE" state <name> check open
 验证通过后继续 Step 4。失败时脚本输出具体原因。
-**幂等性**：open 阶段所有操作可安全重复。若 `.comate.yaml` 已是 `phase: open` 且三件套已存在，跳过已完成步骤，从第一个缺失步骤继续。
+**幂等性检查**：
+1. 读取 `.comate.yaml` 的 `phase`、`phase_step`、workflow、以及三件套文件路径
+2. **已完成 Step 5（产物已审视确认）** 的判定条件：
+   - `phase_step` 值为 `open.review-confirmed`（旧版 `5-confirmed` 兼容一次）
+   - 或 `phase` 已经不是 `open`（说明已流转到下一阶段）
+3. **幂等分支**：
+   - **已完成 Step 5** → 跳过所有步骤，说明「开题已完成，三件套已确认」，直接检查退出条件（guard）
+   - **未完成 Step 5** → 检查三件套是否存在：
+     - 三件套全部存在且非空 → 跳到 Step 4（内容完整性检查）
+     - 任一文件缺失或为空 → 从 Step 1 开始（如果是首次）或 Step 3b/3c（如果是 PRD 来源）
+4. **断点恢复**（根据 `phase_step` 值）：
+   - `phase_step` 为 `open.artifacts-created` → 从 Step 4 开始
+   - `phase_step` 为 `open.review-awaiting`（或旧版 `4`）→ 恢复 Step 5 的用户确认，并改写为新格式
+   - `phase_step` 为 `open.review-confirmed`（或旧版 `5-confirmed`）→ 见第 3 点幂等分支
+5. **open 阶段特点**：open 阶段的所有操作（explore、创建三件套、状态初始化）可安全重复执行。但**产物审视（Step 5）的用户确认不可重复**，一旦 `phase_step: open.review-confirmed` 被记录，即使上下文压缩也不得重新要求用户确认。
 ### 4. 内容完整性检查
-逐个确认三个文件路径存在且非空：
+逐个确认三个文件路径存在且非空：
 - **proposal.md**：问题背景、目标、范围、非目标
 - **design.md**：高层架构决策、方案选型、数据流
 - **tasks.md**：任务列表，每个任务有明确描述
-任一文件缺失或为空时，不得进入 Step 5 或执行守卫，必须回创建步骤补充。
+任一文件缺失或为空时，不得进入 Step 5 或执行守卫，必须回创建步骤补充。
+完整性检查通过后记录：
+```bash
+bash "$COMATE" state <name> set phase_step open.artifacts-created
+```
 ### 5. 产物审视（决策阻塞点 1，按来源分类）
@@ -119,21 +147,46 @@ bash "$COMATE" state <name> check open
 同时满足以下**全部**条件时，本决策点降级为自动流转，**不 AskUserQuestion**：
 1. `source_kind: file`（本 change 追踪了源文件）；
-2. 追踪的源是一份 PRD，且 `bash "$COMATE" gate <prd路径> check` 返回 PASS（exit 0）——即门禁 `passed`/`passed-with-tbd` 且 PRD 哈希未漂移。PRD 路径从 `sources <name> list` 或 Step 2c 的上下文取得；
-3. change 名已记入该 PRD 的 `spawned_changes`（Step 6 的 `gate spawned` 已执行，通常由 `/comate-gate` 备妥）；
+2. 追踪的源是一份 PRD，且 `bash "$COMATE" gate <prd路径> check` 返回 PASS（exit 0）——即门禁 `passed`/`passed-with-tbd` 且 PRD 哈希未漂移。PRD 路径从 `sources <name> list` 或 Step 3c 的上下文取得；
+3. change 名已记入该 PRD 的 `spawned_changes`（Step 3c 的 `gate spawned` 已执行，通常由 `/comate-gate` 备妥）；
 4. **范围一致性自检**：proposal 的目标/范围/非目标忠实承接 gate 映射里本 change 认领的功能项——没有擅自扩大或缩小、没有认领未分配的功能项、没有漏掉已分配项。
-四条全成立时：范围/映射/命名已在决策点 6 由用户拍板，三件套只是承接，无新的有效选项。直接进入退出条件执行守卫流转，并**如实报告**：本 change 承接自哪份 PRD、认领哪些功能项、已核对范围与映射一致。
+四条全成立时：范围/映射/命名已在决策点 6 由用户拍板，三件套只是承接，无新的有效选项。
+**自动流转处理**：
+1. **记录自动确认状态**：
+   ```bash
+   bash "$COMATE" state <name> set phase_step open.review-confirmed
+   ```
+2. **如实报告**：「本 change 承接自 PRD <prd-name>，认领功能项：<列出项>。已核对范围与映射一致，自动进入下一阶段。」
+3. 直接进入退出条件执行守卫流转
 #### 5b. 需要用户输入的两种情形（AskUserQuestion 阻塞）
 - **对话来源**（`source_kind: conversation`）：范围此前未经用户拍板，三件套第一次成形。
 - **PRD 扇出但 5a 第 4 条不成立**（范围与映射有偏差）：分歧重新出现。
-以上任一情形，**必须使用 AskUserQuestion 工具暂停等待用户确认**。以单选题呈现摘要（proposal 问题/目标/范围、design 架构决策/选型、tasks 数量与关键任务；PRD 偏差场景额外列出偏差点）和选项：
-- 「确认，继续下一阶段」— 执行守卫流转
+以上任一情形，**必须使用 AskUserQuestion 工具暂停等待用户确认**。以单选题呈现摘要（proposal 问题/目标/范围、design 架构决策/选型、tasks 数量与关键任务；PRD 偏差场景额外列出偏差点）和选项：
+- 「确认，继续下一阶段」— 记录确认状态后执行守卫流转
 - 「需要调整」— 附调整说明（PRD 偏差场景默认建议按映射修正），修改后重新请求确认
+**提问前先持久化等待状态**：
+```bash
+bash "$COMATE" state <name> set phase_step open.review-awaiting
+```
+**用户确认后立即记录**：
+```bash
+bash "$COMATE" state <name> set phase_step open.review-confirmed
+```
+然后继续执行退出条件（guard）。
 ## 退出条件
 - 三件套已创建且内容完整

package/skills/comate-verify/SKILL.md CHANGED Viewed

@@ -67,10 +67,12 @@ git diff --stat "$BASE_REF"...HEAD
    ```
    然后调 `/comate-build`。回到 build 前如实报告：哪些是 CRITICAL 失败项、判定依据、将如何修复。
-2. **无 CRITICAL，仅 WARNING / SUGGESTION** —— 属"用户决策"（接受偏差是合法选择）。**一次性 AskUserQuestion 批量展示**全部失败项与推荐处理，提供：
+2. **无 CRITICAL，仅 WARNING / SUGGESTION** —— 属"用户决策"（接受偏差是合法选择）。**一次性 AskUserQuestion 批量展示**全部失败项与推荐处理，提供：
    - **全部修复**：`bash "$COMATE" state <name> transition verify-fail` 然后调 `/comate-build`
    - **逐项处理**：勾选要修的项，其余接受偏差
-   - **接受偏差**：全部接受，须在报告记录每项原因和影响
+   - **接受偏差**：全部接受，须在报告记录每项原因和影响
+   提问前先写 `phase_step: verify.failure-awaiting`；作出决定后清除或写入对应处理结果。
 3. **Spec 漂移** —— 按 Step 2b 的单选题处理（属"用户决策"，必须暂停）。
@@ -91,10 +93,12 @@ git diff --stat "$BASE_REF"...HEAD
 规模为「大」时**立即使用 Skill 工具加载 `openspec-verify-change`**。检查项：tasks 全勾、实现符合 design.md 高层决策、符合 Design Doc、能力规格场景全通过、proposal 目标满足、delta spec 与 design doc 无矛盾、关联设计文档可定位。
-**Spec 漂移处理**（决策阻塞点 4 的一部分）：若发现 delta spec 与 design doc 矛盾，**必须以单选题 AskUserQuestion 暂停**：
+**Spec 漂移处理**（决策阻塞点 4 的一部分）：若发现 delta spec 与 design doc 矛盾，**必须以单选题 AskUserQuestion 暂停**：
 - A：在 design doc 追加 "Implementation Divergence" 节记录偏差（属 verify 阶段允许产物，写入后不再触发 Step 1b dirty 决策）
 - B：`state transition verify-fail` 然后调 `/comate-build` 由 Spec 增量更新规则更新
-- C：确认偏差可接受继续（归档时 design doc 标记 `superseded-by-main-spec`）
+- C：确认偏差可接受继续（归档时 design doc 标记 `superseded-by-main-spec`）
+提问前先写 `phase_step: verify.spec-drift-awaiting`。
 ### 3. 记录验证证据
@@ -123,15 +127,20 @@ bash "$COMATE" state <name> set verification_report docs/superpowers/reports/YYY
 **立即执行：** 使用 Skill 工具加载 `superpowers:finishing-a-development-branch`。不可用时停止并提示安装。
-分支处理选项：本地合并 / 推送建 PR / 保持分支 / 丢弃工作。**必须使用 AskUserQuestion 工具暂停等待用户选择**。规则见 `comate/reference/decision-points.md` 第 5 条。
+分支处理选项：本地合并 / 推送建 PR / 保持分支 / 丢弃工作。**必须使用 AskUserQuestion 工具暂停等待用户选择**。规则见 `comate/reference/decision-points.md` 第 5 条。提问前先写：
+```bash
+bash "$COMATE" state <name> set phase_step verify.branch-awaiting
+```
-操作完成后写入状态：
+选择本地合并 / 推送建 PR / 保持分支且操作完成后写入状态：
 ```bash
-bash "$COMATE" state <name> set branch_status handled
-```
-**重要**：无论选择哪种收尾方式（包括"丢弃工作"），都必须在分支操作完成后才设置 `branch_status: handled`。这确保 guard 检查时状态已完整记录。
+bash "$COMATE" state <name> set branch_status handled
+bash "$COMATE" state <name> set phase_step verify.branch-handled
+```
+选择**丢弃工作**时必须写 `branch_status: discarded` 和 `phase_step: verify.discarded`，随后立即停止；不得运行 verify guard、不得设置 `verify_result: pass`、不得归档。若之后要继续该 change，先执行 `state transition <name> verify-fail` 回到 build，再重新实现并生成新的 build handoff。
 ## 退出条件