@fitlab-ai/agent-infra 0.6.5 → 0.7.0

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

@@ -115,6 +115,18 @@ tail .agents/workspace/active/{task-id}/task.md
 ## 依赖关系
 - {需要的依赖和与其他模块的协调}
 
+## 假设
+
+> 如本次分析依赖某些假设，列在此处；没有则可省略本段。
+
+- {本轮分析所依赖的假设}
+
+## 未决问题
+
+> 如有需要人工裁定的未决问题，列在此处；没有则可省略本段。
+
+- {未决问题}
+
 ## 工作量和复杂度评估
 - 复杂度：{高/中/低}
 - 风险等级：{高/中/低}
@@ -189,10 +201,10 @@ node .agents/scripts/validate-artifact.js gate analyze-task .agents/workspace/ac
 产出文件：
 - 分析报告：.agents/workspace/active/{task-id}/{analysis-artifact}
 
-下一步 - 设计技术方案：
-  - Claude Code / OpenCode：/plan-task {task-id}
-  - Gemini CLI：/agent-infra:plan-task {task-id}
-  - Codex CLI：$plan-task {task-id}
+下一步 - 审查需求分析：
+  - Claude Code / OpenCode：/review-analysis {task-id}
+  - Gemini CLI：/agent-infra:review-analysis {task-id}
+  - Codex CLI：$review-analysis {task-id}
 ```
 
 ## 完成检查清单

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

@@ -36,11 +36,12 @@ Extract from `task.md`:
 Scan and record the existence, round, and status of these artifact types:
 - `analysis.md`, `analysis-r{N}.md` - Requirement analysis
 - `plan.md`, `plan-r{N}.md` - Technical plan
-- `implementation.md`, `implementation-r2.md`, ... - Implementation reports
-- `refinement.md`, `refinement-r2.md`, ... - Refinement reports
-- `review.md`, `review-r2.md`, ... - Review reports
+- `code.md`, `code-r2.md`, ... - Code reports
+- `review-analysis.md`, `review-analysis-r{N}.md` - Requirement analysis review reports
+- `review-plan.md`, `review-plan-r{N}.md` - Technical plan review reports
+- `review-code.md`, `review-code-r{N}.md` - Code review reports
 
-For versioned artifacts (`analysis`, `plan`, `implementation`, `refinement`, `review`):
+For versioned artifacts (`analysis`, `review-analysis`, `plan`, `review-plan`, `code`, `review-code`):
 - Scan all versioned files of the same artifact type in the task directory
 - Record the latest round, latest file path, and total number of rounds for each artifact type
 - If the latest round is recorded in `task.md` Activity Log, cross-check it against the actual file when possible
@@ -64,28 +65,30 @@ Basic info:
 
 Workflow progress:
   [done]       Requirement Analysis  analysis-r2.md (Round 2, latest)
+  [done]       Analysis Review       review-analysis.md (Round 1, latest)
   [done]       Technical Design      plan.md (Round 1)
-  [current]    Implementation        implementation.md (Round 1)
-  [pending]    Refinement            refinement.md (Round 1 will be created next)
-  [pending]    Code Review           review.md (Round 1 will be created next)
+  [done]       Plan Review           review-plan.md (Round 1, latest)
+  [current]    Code                  code.md (Round 1)
+  [pending]    Code Review           review-code.md (Round 1 will be created next)
   [pending]    Final Commit
 
 Context files:
 - analysis.md:           Exists (Round 1)
 - analysis-r2.md:        Exists (Round 2, latest)
+- review-analysis.md:    Exists (Round 1, latest)
 - plan.md:               Exists (Round 1, latest)
-- implementation.md:     Exists (Round 1, latest)
-- refinement.md:         Not started
-- review.md:             Not started
+- review-plan.md:        Exists (Round 1, latest)
+- code.md:               Exists (Round 1, latest)
+- review-code.md:        Not started
 
 If multiple rounds exist, show all rounds and mark the latest, for example:
-- plan.md: Exists (Round 1)
-- plan-r2.md: Exists (Round 2, latest)
-- implementation.md: Exists (Round 1)
-- implementation-r2.md: Exists (Round 2, latest)
-- refinement.md: Exists (Round 1)
-- review.md: Exists (Round 1)
-- review-r2.md: Exists (Round 2, latest)
+- plan.md:             Exists (Round 1)
+- plan-r2.md:          Exists (Round 2, latest)
+- review-plan.md:      Exists (Round 1)
+- code.md:             Exists (Round 1)
+- code-r2.md:          Exists (Round 2, latest)
+- review-code.md:      Exists (Round 1)
+- review-code-r2.md:   Exists (Round 2, latest)
 
 Next step:
   Complete implementation, then run code review
@@ -107,26 +110,34 @@ Recommend the appropriate next skill based on the current workflow state. You mu
 > - `status = blocked` -> choose "Task Blocked"
 > - `status = completed` -> choose "Task Completed"
 > - `current_step = requirement-analysis` and the latest analysis artifact is complete -> choose "Analysis Complete"
+> - `current_step = requirement-analysis-review` and the latest analysis review artifact is approved -> choose "Analysis Review Passed"
+> - `current_step = requirement-analysis-review` and the latest analysis review artifact exists but is not approved or has findings -> choose "Analysis Review Has Issues"
 > - `current_step = technical-design` and the latest plan artifact is complete -> choose "Plan Complete"
-> - The latest implementation artifact exists and there is still no latest review artifact -> choose "Implementation Complete"
-> - The latest review artifact exists, the verdict is `Approved`, and `Blocker = 0`, `Major = 0`, `Minor = 0` -> choose "Review Passed"
-> - The latest review artifact exists, but any `Blocker`, `Major`, or `Minor` issue remains, or the verdict is not a clean approval -> choose "Review Has Issues"
+> - `current_step = technical-design-review` and the latest plan review artifact is approved -> choose "Plan Review Passed"
+> - `current_step = technical-design-review` and the latest plan review artifact exists but is not approved or has findings -> choose "Plan Review Has Issues"
+> - The latest code artifact exists and there is still no latest code review artifact -> choose "Code Complete"
+> - `current_step = code-review` and the latest code review artifact exists, the verdict is `Approved`, and `Blocker = 0`, `Major = 0`, `Minor = 0` -> choose "Code Review Passed"
+> - `current_step = code-review` and the latest code review artifact exists, but any `Blocker`, `Major`, or `Minor` issue remains, or the verdict is not a clean approval -> choose "Code Review Has Issues"
 >
-> **Important: if the latest review report contains any issue at all, do not use the "Review Passed" row. You must use "Review Has Issues" instead.**
-
-| Current State | Claude Code / OpenCode | Gemini CLI | Codex CLI |
-|--------------|------------------------|------------|-----------|
-| Analysis Complete | `/plan-task {task-id}` | `/{{project}}:plan-task {task-id}` | `$plan-task {task-id}` |
-| Plan Complete | `/implement-task {task-id}` | `/{{project}}:implement-task {task-id}` | `$implement-task {task-id}` |
-| Implementation Complete | `/review-task {task-id}` | `/{{project}}:review-task {task-id}` | `$review-task {task-id}` |
-| Review Passed | `/commit` | `/{{project}}:commit` | `$commit` |
-| Review Has Issues | `/refine-task {task-id}` | `/{{project}}:refine-task {task-id}` | `$refine-task {task-id}` |
-| Task Blocked | Unblock the task or provide the missing information | — | Unblock the task or provide the missing information |
-| Task Completed | No action needed | — | No action needed |
+> **Important: if the latest review report contains any issue at all, do not use the corresponding review-passed row. Use the corresponding has-issues row instead.**
+
+| Current State              | Claude Code / OpenCode                              | Gemini CLI                               | Codex CLI                                           |
+|----------------------------|-----------------------------------------------------|------------------------------------------|-----------------------------------------------------|
+| Analysis Complete          | `/review-analysis {task-id}`                        | `/{{project}}:review-analysis {task-id}` | `$review-analysis {task-id}`                        |
+| Analysis Review Passed     | `/plan-task {task-id}`                              | `/{{project}}:plan-task {task-id}`       | `$plan-task {task-id}`                              |
+| Analysis Review Has Issues | `/analyze-task {task-id}`                           | `/{{project}}:analyze-task {task-id}`    | `$analyze-task {task-id}`                           |
+| Plan Complete              | `/review-plan {task-id}`                            | `/{{project}}:review-plan {task-id}`     | `$review-plan {task-id}`                            |
+| Plan Review Passed         | `/code-task {task-id}`                              | `/{{project}}:code-task {task-id}`       | `$code-task {task-id}`                              |
+| Plan Review Has Issues     | `/plan-task {task-id}`                              | `/{{project}}:plan-task {task-id}`       | `$plan-task {task-id}`                              |
+| Code Complete              | `/review-code {task-id}`                            | `/{{project}}:review-code {task-id}`     | `$review-code {task-id}`                            |
+| Code Review Passed         | `/commit`                                           | `/{{project}}:commit`                    | `$commit`                                           |
+| Code Review Has Issues     | `/code-task {task-id}`                              | `/{{project}}:code-task {task-id}`       | `$code-task {task-id}`                              |
+| Task Blocked               | Unblock the task or provide the missing information | —                                        | Unblock the task or provide the missing information |
+| Task Completed             | No action needed                                    | —                                        | No action needed                                    |
 
 ## Notes
 
 1. **Read-only**: This skill only reads and reports -- it does not modify files
 2. **Multi-directory search**: Always check active, blocked, and completed
 3. **Quick reference**: Use this skill any time you need to see where a task is in the workflow
-4. **Versioned artifacts**: `analysis`, `plan`, `implementation`, `refinement`, and `review` must all report the actual round, not only the base filename
+4. **Versioned artifacts**: `analysis`, `review-analysis`, `plan`, `review-plan`, `code`, and `review-code` must all report the actual round, not only the base filename

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`