@fitlab-ai/agent-infra 0.6.4 → 0.7.0

package/templates/.agents/skills/check-task/SKILL.zh-CN.md

@@ -36,11 +36,12 @@ description: "查看任务的当前状态和进度"
 按产物类型扫描并记录以下文件的存在、轮次和状态：
 - `analysis.md`、`analysis-r{N}.md` - 需求分析
 - `plan.md`、`plan-r{N}.md` - 技术方案
-- `implementation.md`、`implementation-r2.md`、... - 实现报告
-- `refinement.md`、`refinement-r2.md`、... - 修复报告
-- `review.md`、`review-r2.md`、... - 审查报告
+- `code.md`、`code-r2.md`、... - 实现报告
+- `review-analysis.md`、`review-analysis-r{N}.md` - 需求分析审查报告
+- `review-plan.md`、`review-plan-r{N}.md` - 技术方案审查报告
+- `review-code.md`、`review-code-r{N}.md` - 代码审查报告
 
-对于版本化产物（`analysis`、`plan`、`implementation`、`refinement`、`review`）：
+对于版本化产物（`analysis`、`review-analysis`、`plan`、`review-plan`、`code`、`review-code`）：
 - 扫描任务目录中的所有同类版本化文件
 - 记录每类产物的最新轮次、最新文件路径和总轮次数
 - 如果 `task.md` 的 Activity Log 记录了最新轮次，优先核对其与实际文件是否一致
@@ -64,28 +65,30 @@ description: "查看任务的当前状态和进度"
 
 工作流进度：
   [已完成]    需求分析        analysis-r2.md (Round 2, latest)
+  [已完成]    需求分析审查    review-analysis.md (Round 1, latest)
   [已完成]    技术设计        plan.md (Round 1)
-  [进行中]    实现            implementation.md (Round 1)
-  [待处理]    修复            refinement.md (Round 1 will be created next)
-  [待处理]    代码审查        review.md (Round 1 will be created next)
+  [已完成]    技术方案审查    review-plan.md (Round 1, latest)
+  [进行中]    实现            code.md (Round 1)
+  [待处理]    代码审查        review-code.md (Round 1 will be created next)
   [待处理]    最终提交
 
 上下文文件：
 - analysis.md：           已存在 (Round 1)
 - analysis-r2.md：        已存在 (Round 2, latest)
+- review-analysis.md：    已存在 (Round 1, latest)
 - plan.md：               已存在 (Round 1, latest)
-- implementation.md：     已存在 (Round 1, latest)
-- refinement.md：         未开始
-- review.md：             未开始
+- review-plan.md：        已存在 (Round 1, latest)
+- code.md：               已存在 (Round 1, latest)
+- review-code.md：        未开始
 
 如果存在多轮产物，显示所有轮次，并标记最新版本，例如：
-- plan.md：已存在 (Round 1)
-- plan-r2.md：已存在 (Round 2, latest)
-- implementation.md：已存在 (Round 1)
-- implementation-r2.md：已存在 (Round 2, latest)
-- refinement.md：已存在 (Round 1)
-- review.md：已存在 (Round 1)
-- review-r2.md：已存在 (Round 2, latest)
+- plan.md：             已存在 (Round 1)
+- plan-r2.md：          已存在 (Round 2, latest)
+- review-plan.md：      已存在 (Round 1)
+- code.md：             已存在 (Round 1)
+- code-r2.md：          已存在 (Round 2, latest)
+- review-code.md：      已存在 (Round 1)
+- review-code-r2.md：   已存在 (Round 2, latest)
 
 下一步：
   完成实现，然后执行代码审查
@@ -107,26 +110,34 @@ description: "查看任务的当前状态和进度"
 > - `status = blocked` → 选择「任务被阻塞」
 > - `status = completed` → 选择「任务已完成」
 > - `current_step = requirement-analysis` 且最新分析产物已完成 → 选择「分析完成」
+> - `current_step = requirement-analysis-review` 且最新需求分析审查产物通过 → 选择「需求分析审查通过」
+> - `current_step = requirement-analysis-review` 且最新需求分析审查产物存在但未通过或有问题 → 选择「需求分析审查有问题」
 > - `current_step = technical-design` 且最新计划产物已完成 → 选择「计划完成」
+> - `current_step = technical-design-review` 且最新技术方案审查产物通过 → 选择「技术方案审查通过」
+> - `current_step = technical-design-review` 且最新技术方案审查产物存在但未通过或有问题 → 选择「技术方案审查有问题」
 > - 最新实现产物已存在，且尚无最新审查产物 → 选择「实现完成」
-> - 最新审查产物存在，且结论为 `Approved`，同时 `Blocker = 0`、`Major = 0`、`Minor = 0` → 选择「审查通过」
-> - 最新审查产物存在，但仍有任何 `Blocker`、`Major` 或 `Minor` 问题，或结论不是无问题通过 → 选择「审查有问题」
+> - `current_step = code-review` 且最新代码审查产物存在，且结论为 `Approved`，同时 `Blocker = 0`、`Major = 0`、`Minor = 0` → 选择「代码审查通过」
+> - `current_step = code-review` 且最新代码审查产物存在，但仍有任何 `Blocker`、`Major` 或 `Minor` 问题，或结论不是无问题通过 → 选择「代码审查有问题」
 >
-> **特别注意：只要最新审查报告中存在任何问题，就不能使用「审查通过」行。必须改用「审查有问题」行。**
-
-| 当前状态 | Claude Code / OpenCode | Gemini CLI | Codex CLI |
-|---------|----------------------|------------|-----------|
-| 分析完成 | `/plan-task {task-id}` | `/agent-infra:plan-task {task-id}` | `$plan-task {task-id}` |
-| 计划完成 | `/implement-task {task-id}` | `/agent-infra:implement-task {task-id}` | `$implement-task {task-id}` |
-| 实现完成 | `/review-task {task-id}` | `/agent-infra:review-task {task-id}` | `$review-task {task-id}` |
-| 审查通过 | `/commit` | `/agent-infra:commit` | `$commit` |
-| 审查有问题 | `/refine-task {task-id}` | `/agent-infra:refine-task {task-id}` | `$refine-task {task-id}` |
-| 任务被阻塞 | 解除阻塞或提供所需信息 | — | 解除阻塞或提供所需信息 |
-| 任务已完成 | 无需操作 | — | 无需操作 |
+> **特别注意：只要最新审查报告中存在任何问题，就不能使用对应「审查通过」行。必须改用对应「审查有问题」行。**
+
+| 当前状态           | Claude Code / OpenCode       | Gemini CLI                               | Codex CLI                    |
+|--------------------|------------------------------|------------------------------------------|------------------------------|
+| 分析完成           | `/review-analysis {task-id}` | `/agent-infra:review-analysis {task-id}` | `$review-analysis {task-id}` |
+| 需求分析审查通过   | `/plan-task {task-id}`       | `/agent-infra:plan-task {task-id}`       | `$plan-task {task-id}`       |
+| 需求分析审查有问题 | `/analyze-task {task-id}`    | `/agent-infra:analyze-task {task-id}`    | `$analyze-task {task-id}`    |
+| 计划完成           | `/review-plan {task-id}`     | `/agent-infra:review-plan {task-id}`     | `$review-plan {task-id}`     |
+| 技术方案审查通过   | `/code-task {task-id}`       | `/agent-infra:code-task {task-id}`       | `$code-task {task-id}`       |
+| 技术方案审查有问题 | `/plan-task {task-id}`       | `/agent-infra:plan-task {task-id}`       | `$plan-task {task-id}`       |
+| 实现完成           | `/review-code {task-id}`     | `/agent-infra:review-code {task-id}`     | `$review-code {task-id}`     |
+| 代码审查通过       | `/commit`                    | `/agent-infra:commit`                    | `$commit`                    |
+| 代码审查有问题     | `/code-task {task-id}`       | `/agent-infra:code-task {task-id}`       | `$code-task {task-id}`       |
+| 任务被阻塞         | 解除阻塞或提供所需信息       | —                                        | 解除阻塞或提供所需信息       |
+| 任务已完成         | 无需操作                     | —                                        | 无需操作                     |
 
 ## 注意事项
 
 1. **只读**：本技能仅读取和报告 —— 不修改任何文件
 2. **多目录搜索**：始终检查 active、blocked 和 completed 目录
 3. **快速参考**：随时可以使用本技能检查任务在工作流中的位置
-4. **版本化产物**：`analysis`、`plan`、`implementation`、`refinement`、`review` 都需要报告实际轮次，而不是只报告固定文件名
+4. **版本化产物**：`analysis`、`review-analysis`、`plan`、`review-plan`、`code`、`review-code` 都需要报告实际轮次，而不是只报告固定文件名

package/templates/.agents/skills/code-task/SKILL.en.md

@@ -0,0 +1,117 @@
+---
+name: code-task
+description: "Implement code from the technical plan and output a report"
+---
+
+# Code Task
+
+Implement the approved plan and produce `code.md` or `code-r{N}.md`. This skill supports initial implementation and fix mode based on `review-code` feedback.
+
+## Boundary / Critical Rules
+
+- Follow the latest plan artifact: `plan.md` or `plan-r{N}.md`
+- Fix mode only addresses findings from the latest `review-code`; env-blocked items are out of scope
+- Never auto-run `git add` or `git commit`
+- Create a new code artifact for each round and never overwrite an older one
+- After executing this skill, you **must** immediately update task.md
+
+Version stamp rule: when creating or updating `task.md` frontmatter, read `.agents/rules/version-stamp.md` first and write or refresh `agent_infra_version`.
+
+## Step 0: State Check (pre-execution hard gate)
+
+After loading workflow / skill / rules instructions, and before any task-state judgment or user-visible conclusion, run the state check first.
+
+Run these commands and paste the raw output into both the user-facing reply and this round's `## State Check` section:
+
+```bash
+git status -s
+ls -la .agents/workspace/active/{task-id}/
+tail .agents/workspace/active/{task-id}/task.md
+```
+
+## Steps
+
+### 1. Verify Prerequisites
+
+Require `task.md` and at least one plan artifact: `plan.md` or `plan-r{N}.md`.
+
+### 2. Ensure the Task Branch
+
+Read `reference/branch-management.md`, ensure the current branch matches the task branch, and write the final branch back to task.md when needed.
+
+### 3. Narrow the Milestone
+
+If task.md has a valid `issue_number`, read `.agents/rules/issue-sync.md` and `.agents/rules/milestone-inference.md`; follow Phase 2 for `code-task`.
+
+### 4. Determine Mode and Round
+
+Run mode detection and preserve its exit code:
+
+```bash
+result=$(node .agents/skills/code-task/scripts/detect-mode.js .agents/workspace/active/{task-id})
+status=$?
+echo "$result"
+```
+
+Dispatch by `$status` and `result.mode`:
+
+- `0` + `"init"`: initial implementation; record `{code-artifact}` and `{code-round}`
+- `0` + `"fix"`: fix mode; record `{code-artifact}`, `{code-round}`, and `{review-artifact}`
+- `1` + `"refused"`: print `result.message`, stop, and do not write an artifact or Activity Log entry
+- `2` + `"error"`: print `result.message`, stop, and do not write an artifact or Activity Log entry
+
+> Read `reference/dual-mode.md` before this step.
+
+### 5. Determine the Input Plan
+
+Read the highest-round plan artifact and use the `{code-artifact}` selected in step 4. In fix mode, also read `{review-artifact}`.
+
+### 6. Read the Technical Plan
+
+Extract implementation steps, files, test strategy, constraints, risks, and approved tradeoffs.
+
+### 7. Implement the Code
+
+Follow the plan in order.
+
+> Read `reference/code-rules.md` before implementation.
+> In fix mode, read `reference/fix-mode.md` before editing.
+> Read `.agents/rules/testing-discipline.md` before adding or changing tests.
+
+### 8. Run Test Verification
+
+Use the project test commands from the `test` skill and iterate until all required tests pass.
+
+### 9. Write the Code Report
+
+Create `.agents/workspace/active/{task-id}/{code-artifact}`.
+
+> Read `reference/report-template.md` before writing the report.
+
+### 10. Update Task Status
+
+Get the current time:
+
+```bash
+date "+%Y-%m-%d %H:%M:%S%:z"
+```
+
+Set `current_step` to `code`, refresh task metadata, and append one Activity Log entry:
+
+- initial implementation: `Code (Round {N})`
+- fix mode: `Code (Round {N}, fix for {review-artifact})`
+
+If task.md has a valid `issue_number`, read `.agents/rules/issue-sync.md`, then:
+- Set `status: in-progress` according to issue-sync.md
+- Create or update the task comment marker defined in `.agents/rules/issue-sync.md`
+- Publish the `{code-artifact}` comment
+
+### 11. Run Completion Gate
+
+```bash
+node .agents/scripts/validate-artifact.js gate code-task .agents/workspace/active/{task-id} {code-artifact} --format text
+```
+
+### 12. Tell the User
+
+Use `reference/output-template.md` and show all TUI command formats.

package/templates/.agents/skills/{implement-task → code-task}/SKILL.zh-CN.md

@@ -1,15 +1,16 @@
 ---
-name: implement-task
-description: "根据技术方案实施任务并输出报告"
+name: code-task
+description: "根据技术方案编码任务并输出报告"
 ---
 
-# 实施任务
+# 编码任务
 
-根据已批准的技术方案实施任务，并产出 `implementation.md` 或 `implementation-r{N}.md`。
+根据已批准的技术方案编码任务，并产出 `code.md` 或 `code-r{N}.md`。本技能支持初次实现和基于 `review-code` 反馈的修复双模式。
 
 ## 行为边界 / 关键规则
 
 - 严格遵循最新方案产物：`plan.md` 或 `plan-r{N}.md`
+- 修复模式只处理最新 `review-code` 标记的问题；env-blocked 项不在修复范围
 - 绝不自动执行 `git add` 或 `git commit`
 - 每轮实现都创建新的实现产物，不覆盖旧文件
 - 执行本技能后，你**必须**立即更新 task.md
@@ -66,18 +67,40 @@ tail .agents/workspace/active/{task-id}/task.md
 
 ### 3. 收窄里程碑
 
-如果 task.md 中存在有效的 `issue_number`，执行前先读取 `.agents/rules/issue-sync.md`，完成 upstream 仓库检测和权限检测；再读取 `.agents/rules/milestone-inference.md`，按其中的「阶段 2：`implement-task`」收窄 Issue milestone；如果 `has_triage=false`，则保持原 milestone 不变。
+如果 task.md 中存在有效的 `issue_number`，执行前先读取 `.agents/rules/issue-sync.md`，完成 upstream 仓库检测和权限检测；再读取 `.agents/rules/milestone-inference.md`，按其中的「阶段 2：`code-task`」收窄 Issue milestone；如果 `has_triage=false`，则保持原 milestone 不变。
 
-### 4. 确定输入方案与实现轮次
+### 4. 确定模式与轮次
+
+执行 mode detection 脚本，先保存 exit code 再处理输出：
+
+```bash
+result=$(node .agents/skills/code-task/scripts/detect-mode.js .agents/workspace/active/{task-id})
+status=$?
+echo "$result"
+```
+
+按 `$status` 与 `result.mode` 分流；二者不一致时按 `$status` 为准并报告异常：
+
+| `$status` | `result.mode` | 行动 |
+|---|---|---|
+| 0 | `"init"` | 进入初次实现模式。记录 `{code-artifact}` = `result.next_artifact`、`{code-round}` = `result.next_round` |
+| 0 | `"fix"` | 进入修复模式。记录 `{code-artifact}` = `result.next_artifact`、`{code-round}` = `result.next_round`、`{review-artifact}` = `result.review_artifact` |
+| 1 | `"refused"` | 输出 `result.message` 给用户；立即停止；不写 Activity Log、不创建产物 |
+| 2 | `"error"` | 输出 `result.message` 给用户；立即停止；不写 Activity Log、不创建产物 |
+| 其他 | 任意 | 视为脚本异常，输出 `Mode detection failed: status={status}, output={result}` 并停止 |
+
+> 双模式判定规则见 `reference/dual-mode.md`。执行此步骤前先读取 `reference/dual-mode.md`。
+
+### 5. 确定输入方案
 
 扫描 `.agents/workspace/active/{task-id}/` 并记录：
 - 最高轮次的方案文件为 `{plan-artifact}`
-- 本轮实现产物为 `implementation.md` 或 `implementation-r{N}.md`
-- `{implementation-round}` 与 `{implementation-artifact}`
+- 使用步骤 4 记录的 `{code-round}` 与 `{code-artifact}`
+- 若为修复模式，同时记录 `{review-artifact}`
 
 如果存在 `plan-r{N}.md`，读取最高轮次的方案文件；否则读取 `plan.md`。
 
-### 5. 阅读技术方案
+### 6. 阅读技术方案
 
 仔细阅读 `{plan-artifact}`，提取：
 - 实施步骤
@@ -85,26 +108,29 @@ tail .agents/workspace/active/{task-id}/task.md
 - 测试策略
 - 约束、风险与已批准的取舍
 
-### 6. 执行代码实现
+修复模式还必须读取 `{review-artifact}`，并只处理其中标记的问题。
+
+### 7. 执行代码实现
 
 按照 `.agents/workflows/feature-development.yaml` 和方案顺序实施。
 
-> 详细实现规则、测试执行循环和偏离处理见 `reference/implementation-rules.md`。执行此步骤前，先读取 `reference/implementation-rules.md`。
+> 详细实现规则、测试执行循环和偏离处理见 `reference/code-rules.md`。执行此步骤前，先读取 `reference/code-rules.md`。
+> 修复模式的范围纪律见 `reference/fix-mode.md`。进入修复模式前先读取 `reference/fix-mode.md`。
 > 测试编写纪律（RED-GREEN-REFACTOR 与反模式）见 `.agents/rules/testing-discipline.md`；新增或调整测试前先读取该文件。
 
-### 7. 运行测试验证
+### 8. 运行测试验证
 
 使用 `test` 技能中的项目测试命令，直到所有必需测试通过。
 
 如果测试失败，先尝试修复并重新运行测试。只有在确认存在外部阻塞、环境缺失或需求不明确且超出任务范围时，才可以停止。
 
-### 8. 编写实现报告
+### 9. 编写实现报告
 
-创建 `.agents/workspace/active/{task-id}/{implementation-artifact}`。
+创建 `.agents/workspace/active/{task-id}/{code-artifact}`。
 
 > 报告结构、必填章节和完整模板见 `reference/report-template.md`。写报告前先读取 `reference/report-template.md`。
 
-### 9. 更新任务状态
+### 10. 更新任务状态
 
 获取当前时间：
 
@@ -113,26 +139,27 @@ date "+%Y-%m-%d %H:%M:%S%:z"
 ```
 
 更新 `.agents/workspace/active/{task-id}/task.md`：
-- `current_step`：implementation
+- `current_step`：code
 - `assigned_to`：{当前代理}
 - `updated_at`：{当前时间}
 - `agent_infra_version`：按 `.agents/rules/version-stamp.md` 取值
 - 审查 `## 需求` 段落，仅把本轮已由代码实现且有测试通过支撑的条目从 `- [ ]` 勾为 `- [x]`
-- 记录 Round `{implementation-round}` 的 `{implementation-artifact}`
+- 记录 Round `{code-round}` 的 `{code-artifact}`
 - 追加：
-  `- {YYYY-MM-DD HH:mm:ss±HH:MM} — **Implementation (Round {N})** by {agent} — Code implemented, {n} files modified, {n} tests passed → {implementation-artifact}`
+  - 初次实现：`- {YYYY-MM-DD HH:mm:ss±HH:MM} — **Code (Round {N})** by {agent} — Code implemented, {n} files modified, {n} tests passed → {code-artifact}`
+  - 修复模式：`- {YYYY-MM-DD HH:mm:ss±HH:MM} — **Code (Round {N}, fix for {review-artifact})** by {agent} — Fixed {n} blockers, {n} major, {n} minor issues[, skipped {n} env-blocked] → {code-artifact}`
 
 如果 task.md 中存在有效的 `issue_number`，执行以下同步操作（任一失败则跳过并继续；执行前先读取 `.agents/rules/issue-sync.md`，完成 upstream 仓库检测和权限检测）：
 - 按 issue-sync.md 设置 `status: in-progress`
 - 创建或更新 `.agents/rules/issue-sync.md` 中定义的 task 评论标记（按 issue-sync.md 的 task.md 评论同步规则）
-- 发布 `{implementation-artifact}` 评论
+- 发布 `{code-artifact}` 评论
 
-### 10. 完成校验
+### 11. 完成校验
 
 运行完成校验，确认任务产物和同步状态符合规范：
 
 ```bash
-node .agents/scripts/validate-artifact.js gate implement-task .agents/workspace/active/{task-id} {implementation-artifact} --format text
+node .agents/scripts/validate-artifact.js gate code-task .agents/workspace/active/{task-id} {code-artifact} --format text
 ```
 
 处理结果：
@@ -142,7 +169,7 @@ node .agents/scripts/validate-artifact.js gate implement-task .agents/workspace/
 
 将校验输出保留在回复中作为当次验证输出。没有当次校验输出，不得声明完成。
 
-### 11. 告知用户
+### 12. 告知用户
 
 > 仅在校验通过后执行本步骤。
 
@@ -151,7 +178,7 @@ node .agents/scripts/validate-artifact.js gate implement-task .agents/workspace/
 ## 完成检查清单
 
 - [ ] 已完成批准范围内的代码实现
-- [ ] 已创建 `{implementation-artifact}`
+- [ ] 已创建 `{code-artifact}`
 - [ ] 所有必需测试通过
 - [ ] 已更新 task.md 并追加 Activity Log
 - [ ] 已向用户展示所有 TUI 格式的下一步命令（含自定义 TUI）
@@ -162,7 +189,7 @@ node .agents/scripts/validate-artifact.js gate implement-task .agents/workspace/
 
 ## 注意事项
 
-- 首轮实现使用 `implementation.md`，后续轮次使用 `implementation-r{N}.md`
+- 首轮实现使用 `code.md`，后续轮次使用 `code-r{N}.md`
 - 如偏离 `{plan-artifact}`，必须在报告中记录原因
 - 新测试必须验证有意义的业务行为，而不是机械透传
 

package/templates/.agents/skills/{implement-task → code-task}/config/verify.en.json

@@ -1,5 +1,5 @@
 {
-  "skill": "implement-task",
+  "skill": "code-task",
   "checks": {
     "task-meta": {
       "required_fields": [
@@ -13,10 +13,10 @@
         "current_step",
         "assigned_to"
       ],
-      "expected_step": "implementation"
+      "expected_step": "code"
     },
     "artifact": {
-      "file_pattern": "implementation.md|implementation-r{N}.md",
+      "file_pattern": "code.md|code-r{N}.md",
       "required_sections": [
         "Modified Files",
         "Key Code Explanation",
@@ -32,7 +32,7 @@
       ]
     },
     "activity-log": {
-      "expected_action_pattern": "Implementation \\(Round \\d+\\)",
+      "expected_action_pattern": "Code \\(Round \\d+(?:, fix for review-code(?:-r\\d+)?\\.md)?\\)",
       "freshness_minutes": 30
     },
     "platform-sync": {

package/templates/.agents/skills/{implement-task → code-task}/config/verify.zh-CN.json

@@ -1,5 +1,5 @@
 {
-  "skill": "implement-task",
+  "skill": "code-task",
   "checks": {
     "task-meta": {
       "required_fields": [
@@ -13,10 +13,10 @@
         "current_step",
         "assigned_to"
       ],
-      "expected_step": "implementation"
+      "expected_step": "code"
     },
     "artifact": {
-      "file_pattern": "implementation.md|implementation-r{N}.md",
+      "file_pattern": "code.md|code-r{N}.md",
       "required_sections": [
         "变更文件",
         "关键代码说明",
@@ -32,7 +32,7 @@
       ]
     },
     "activity-log": {
-      "expected_action_pattern": "Implementation \\(Round \\d+\\)",
+      "expected_action_pattern": "Code \\(Round \\d+(?:, fix for review-code(?:-r\\d+)?\\.md)?\\)",
       "freshness_minutes": 30
     },
     "platform-sync": {

package/templates/.agents/skills/{implement-task → code-task}/reference/branch-management.zh-CN.md

@@ -4,7 +4,7 @@
 
 ## 分支名规则
 
-- 格式：`{{project}}-{type}-{slug}`
+- 格式：`agent-infra-{type}-{slug}`
 - 项目前缀：读取 `.agents/.airc.json` 中的 `project`
 - `{type}`：读取 `task.md` frontmatter 中的 `type`
 - `{slug}`：根据任务标题提取 3-6 个英文关键词，转为 kebab-case
@@ -23,7 +23,7 @@
 - 当前分支不一致：按下方”创建与切换命令”章节切换到已记录分支
 
 场景 B：`task.md` 未记录任务分支
-- 判断当前分支是否符合项目分支命名规范（`{{project}}-{type}-{slug}`）且语义上属于当前任务
+- 判断当前分支是否符合项目分支命名规范（`agent-infra-{type}-{slug}`）且语义上属于当前任务
 - 符合：将当前分支名回写到 `task.md`，继续
 - 不符合：生成新的任务分支名，按下方”创建与切换命令”章节创建并切换，回写到 `task.md`
 

package/templates/.agents/skills/{implement-task/reference/implementation-rules.en.md → code-task/reference/code-rules.en.md}

@@ -4,7 +4,7 @@ Read this file before coding or interpreting test failures.
 
 ## Execute Code Implementation
 
-Follow the `implementation` step in `.agents/workflows/feature-development.yaml`.
+Follow the `code` step in `.agents/workflows/feature-development.yaml`.
 
 **Required tasks**:
 - [ ] implement the feature code according to the plan
@@ -23,7 +23,7 @@ Follow the `implementation` step in `.agents/workflows/feature-development.yaml`
 
 During implementation:
 - **Inner loop**: after each change, run the project's **smoke subset** (see the `test` skill) for fast feedback
-- **Before writing the implementation report**: run the **core subset** as final verification so code entering review has passed the complete core checks
+- **Before writing the code report**: run the **core subset** as final verification so code entering review has passed the complete core checks
 
 > Refer to the `test` skill for project-specific commands; downstream projects without layered scripts should fall back to the full project test command.
 
@@ -39,8 +39,8 @@ Two-way failure handling:
    - continue until all required tests pass
 2. external blockers:
    - confirm the failure comes from missing environment, unrelated upstream breakage, or unclear requirements outside this task
-   - stop without creating `implementation.md` / `implementation-r{N}.md`
-   - do not mark implementation complete in `task.md`
+   - stop without creating `code.md` / `code-r{N}.md`
+   - do not mark code complete in `task.md`
    - do not output the normal success/next-step template
 
 ## Notes
@@ -49,5 +49,5 @@ Two-way failure handling:
 2. **No auto-commit**: do not run `git commit` or `git add`
 3. **Test quality**: new tests must validate meaningful business logic
 4. **Code quality**: follow project coding conventions
-5. **Plan deviation**: record any deviation in the implementation report
-6. **Versioning**: Round 1 uses `implementation.md`; later rounds use `implementation-r{N}.md`
+5. **Plan deviation**: record any deviation in the code report
+6. **Versioning**: Round 1 uses `code.md`; later rounds use `code-r{N}.md`

package/templates/.agents/skills/{implement-task/reference/implementation-rules.zh-CN.md → code-task/reference/code-rules.zh-CN.md}

@@ -4,7 +4,7 @@
 
 ## 执行代码实现
 
-遵循 `.agents/workflows/feature-development.yaml` 中的 `implementation` 步骤。
+遵循 `.agents/workflows/feature-development.yaml` 中的 `code` 步骤。
 
 **必做任务**：
 - [ ] 按计划实现功能代码
@@ -39,7 +39,7 @@
    - 持续处理直到所有必需测试通过
 2. 外部阻塞：
    - 确认失败来自缺失环境、无关的上游损坏，或任务范围外的需求不明确
-   - 停止，并且不要创建 `implementation.md` / `implementation-r{N}.md`
+   - 停止，并且不要创建 `code.md` / `code-r{N}.md`
    - 不要在 `task.md` 中把实现标记为完成
    - 不要输出正常的成功/下一步模板
 
@@ -50,4 +50,4 @@
 3. **测试质量**：新增测试必须验证有意义的业务逻辑
 4. **代码质量**：遵循项目编码规范
 5. **方案偏离**：任何偏离都要记录到实现报告中
-6. **版本命名**：Round 1 使用 `implementation.md`，后续轮次使用 `implementation-r{N}.md`
+6. **版本命名**：Round 1 使用 `code.md`，后续轮次使用 `code-r{N}.md`

package/templates/.agents/skills/code-task/reference/dual-mode.en.md

@@ -0,0 +1,69 @@
+# code-task dual mode
+
+This file documents `scripts/detect-mode.js`. The script is the source of truth; update this document whenever the script changes.
+
+## Input
+
+```bash
+node .agents/skills/code-task/scripts/detect-mode.js .agents/workspace/active/{task-id}
+```
+
+The script scans `plan.md` / `plan-r{N}.md`, `review-plan.md` / `review-plan-r{N}.md`, `code.md` / `code-r{N}.md`, and `review-code.md` / `review-code-r{N}.md` in the task directory.
+
+## Eight Branches
+
+> Branches are evaluated top-down in this table; the first match returns and skips later rows.
+
+| Condition | mode | exit | Behavior |
+|---|---|---:|---|
+| no code artifact | `init` | 0 | initial implementation, output `code.md` |
+| latest review-plan is approved (`Approved` or `Approved-with-issues`, i.e. `Overall Verdict: Approved` regardless of findings counts), its "Review Input" / "审查输入" entry names the same plan file as the latest `plan(-r{N})?.md` in the task directory, and its mtime is newer than the latest code artifact | `init` | 0 | plan has been approved after the latest code; enter a new implementation round, `next_round = code_max + 1`, `next_artifact = code-r{next_round}.md`. This branch fires regardless of whether review-code exists or passes. Plan and review-plan rounds are independent counters (e.g. `plan-r5` may be approved by `review-plan-r4`); the link is established via the review-plan's "Review Input" entry, not by matching round numbers. |
+| `rev_max < code_max` | `error` | 2 | latest code round is unreviewed; run `review-code` first |
+| `rev_max > code_max` | `error` | 2 | inconsistent state; manual inspection required |
+| latest review-code is Approved with 0/0/0 | `refused` | 1 | already approved; do not run `code-task` again |
+| latest review-code is Approved with major/minor findings | `fix` | 0 | optional fix mode |
+| latest review-code is Changes Requested | `fix` | 0 | required fix mode |
+| latest review-code is Rejected | `refused` | 1 | re-plan instead of local fixing |
+
+## Verdict Parsing
+
+The script supports zh-CN and English review-code reports:
+
+| Meaning | zh-CN | English |
+|---|---|---|
+| summary section | `## 审查摘要` | `## Review Summary` |
+| verdict field | `**总体结论**：` | `**Overall Verdict**:` |
+| findings field | `**发现（AI 可处理）**：` | `**Findings (AI-actionable)**:` |
+
+Verdict mapping:
+
+- `通过` / `Approved` -> `Approved`, then blocker/major/minor counts split it into `Approved` or `Approved-with-issues`
+- `需要修改` / `Changes Requested` -> `Changes Requested`
+- `拒绝` / `Rejected` -> `Rejected`
+
+env-blocked counts do not affect mode selection.
+
+## Output Contract
+
+The script prints JSON:
+
+```json
+{
+  "mode": "init",
+  "code_max": 0,
+  "rev_max": 0,
+  "verdict": null,
+  "next_round": 1,
+  "next_artifact": "code.md",
+  "review_artifact": null,
+  "message": "..."
+}
+```
+
+In the replan-driven init branch (row #2), `review_artifact` points to the `review-plan-r{N}.md` that triggered replan rather than a review-code artifact, preserving the attribution chain.
+
+exit code:
+
+- `0`: continue, `mode` is `init` or `fix`
+- `1`: stop, `mode` is `refused`
+- `2`: inconsistent state, `mode` is `error`