@fitlab-ai/agent-infra 0.6.5 → 0.7.1

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

@@ -0,0 +1,121 @@
+---
+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
+```
+
+## Task id short ref
+
+> If `{task-id}` begins with `#`, follow the "SKILL parameter resolver" section of `.agents/rules/task-short-id.md`; treat `{task-id}` as the resolved full `TASK-YYYYMMDD-HHMMSS` form for every downstream command.
+
+## 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
@@ -41,8 +42,11 @@ tail .agents/workspace/active/{task-id}/task.md
 
 状态核对完成前，禁止任何关于外部状态的断言（例如“代码没变”“测试已通过”“没有其他引用”），包括思考阶段。本门禁只提供结构下限；逐条证据配对和真实性仍需按报告模板与审查要求核对。
 
-## 执行步骤
+## 任务入参短号别名
+
+> 如果 `{task-id}` 入参以 `#` 开头，先读取 `.agents/rules/task-short-id.md` 的「SKILL 入参解析」段执行解析；后续命令视 `{task-id}` 为解析后的全长 `TASK-YYYYMMDD-HHMMSS` 形式。
 
+## 执行步骤
 ### 1. 验证前置条件
 
 先检查：
@@ -66,18 +70,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. 确定模式与轮次
+
+执行 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` 为准并报告异常：
 
-### 4. 确定输入方案与实现轮次
+| `$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 +111,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 +142,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 +172,7 @@ node .agents/scripts/validate-artifact.js gate implement-task .agents/workspace/
 
 将校验输出保留在回复中作为当次验证输出。没有当次校验输出，不得声明完成。
 
-### 11. 告知用户
+### 12. 告知用户
 
 > 仅在校验通过后执行本步骤。
 
@@ -151,7 +181,7 @@ node .agents/scripts/validate-artifact.js gate implement-task .agents/workspace/
 ## 完成检查清单
 
 - [ ] 已完成批准范围内的代码实现
-- [ ] 已创建 `{implementation-artifact}`
+- [ ] 已创建 `{code-artifact}`
 - [ ] 所有必需测试通过
 - [ ] 已更新 task.md 并追加 Activity Log
 - [ ] 已向用户展示所有 TUI 格式的下一步命令（含自定义 TUI）
@@ -162,7 +192,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`

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

@@ -0,0 +1,69 @@
+# code-task 双模式判定
+
+本文件说明 `scripts/detect-mode.js` 的行为。脚本是单点真相；修改脚本时必须同步更新本文档。
+
+## 输入
+
+```bash
+node .agents/skills/code-task/scripts/detect-mode.js .agents/workspace/active/{task-id}
+```
+
+脚本扫描任务目录中的 `plan.md` / `plan-r{N}.md`、`review-plan.md` / `review-plan-r{N}.md`、`code.md` / `code-r{N}.md` 和 `review-code.md` / `review-code-r{N}.md`。
+
+## 8 个分支
+
+> 分支按表中自上而下的顺序评估，命中即返回；后续分支不再判定。
+
+| 条件 | mode | exit | 行为 |
+|---|---|---:|---|
+| 无 code 产物 | `init` | 0 | 初次实现，产物为 `code.md` |
+| 最新 review-plan 已批准（`通过` 或 `通过 + major/minor 建议`，即 `Approved` 或 `Approved-with-issues`），且其「审查输入」/「Review Input」字段引用的 plan 文件 == 任务目录中最新的 `plan(-r{N})?.md`，且最新 review-plan 的 mtime > 最新 code 的 mtime | `init` | 0 | plan 已在 code 之后被批准；进入新一轮实现，`next_round = code_max + 1`、`next_artifact = code-r{next_round}.md`。**不论 review-code 是否已审**，本分支均先命中。plan 与 review-plan 的轮次独立递增（如 `plan-r5` 可被 `review-plan-r4` 批准），通过 review-plan 的「审查输入」字段建立批准关系，不要求同号 |
+| `rev_max < code_max` | `error` | 2 | 最新代码未审查，先运行 `review-code` |
+| `rev_max > code_max` | `error` | 2 | 数据状态异常，需要人工检查 |
+| 最新 review-code 为 Approved 且 0/0/0 | `refused` | 1 | 已通过，无需再次运行 `code-task` |
+| 最新 review-code 为 Approved 但有 major/minor | `fix` | 0 | 可选修复模式 |
+| 最新 review-code 为 Changes Requested | `fix` | 0 | 必需修复模式 |
+| 最新 review-code 为 Rejected | `refused` | 1 | 需要重新设计，不进入局部修复 |
+
+## verdict 解析
+
+脚本支持中文和英文 review-code 报告：
+
+| 语义 | 中文 | 英文 |
+|---|---|---|
+| 摘要段落 | `## 审查摘要` | `## Review Summary` |
+| 总体结论字段 | `**总体结论**：` | `**Overall Verdict**:` |
+| 发现统计字段 | `**发现（AI 可处理）**：` | `**Findings (AI-actionable)**:` |
+
+结论映射：
+
+- `通过` / `Approved` -> `Approved`，再按 blocker/major/minor 计数拆成 `Approved` 或 `Approved-with-issues`
+- `需要修改` / `Changes Requested` -> `Changes Requested`
+- `拒绝` / `Rejected` -> `Rejected`
+
+env-blocked 计数不参与 mode 判定。
+
+## 输出契约
+
+脚本输出 JSON：
+
+```json
+{
+  "mode": "init",
+  "code_max": 0,
+  "rev_max": 0,
+  "verdict": null,
+  "next_round": 1,
+  "next_artifact": "code.md",
+  "review_artifact": null,
+  "message": "..."
+}
+```
+
+`review_artifact` 字段在第 2 分支（replan-driven init）下指向触发的 `review-plan-r{N}.md` 而非 review-code 产物，用于追溯触发原因。
+
+exit code：
+
+- `0`：可继续，`mode` 为 `init` 或 `fix`
+- `1`：拒绝继续，`mode` 为 `refused`
+- `2`：状态异常，`mode` 为 `error`

package/templates/.agents/skills/{refine-task/reference/fix-workflow.en.md → code-task/reference/fix-mode.en.md}

@@ -1,6 +1,6 @@
 # Fix Workflow
 
-Read this file before changing code during refinement.
+Read this file before changing code during fix mode.
 
 ## Plan the Fixes
 
@@ -24,7 +24,7 @@ Detailed priority rules:
 
 env-blocked findings are outside the repair scope. Handling rules:
 - do not write code changes for these findings
-- list them unchanged in the refinement report's "Environment-Blocked Handling" section and mark them "outside AI repair scope"
+- list them unchanged in the code report's "Environment-Blocked Handling" section and mark them "outside AI repair scope"
 - do not repeat them under unresolved issues, to avoid visually double-counting them
 - their destination is the PR description, where maintainers carry them as a "manual verification required" checklist
 
@@ -38,7 +38,7 @@ For each fix:
 
 ## Run Test Verification
 
-Before writing the refinement report, run the project's **core subset** as final verification and confirm that all required tests still pass. If the project does not have layered scripts, fall back to the full project test command.
+Before writing the code report, run the project's **core subset** as final verification and confirm that all required tests still pass. If the project does not have layered scripts, fall back to the full project test command.
 
 ## Choose the Next-Step Branch
 
@@ -53,22 +53,22 @@ Prohibition:
 Required output template:
 
 ```text
-Task {task-id} refinement completed.
+Task {task-id} fix completed.
 
-Refinement status:
+Fix status:
 - Blockers fixed: {fixed-blockers}/{total-blockers}
 - Major issues fixed: {fixed-majors}/{total-majors}
 - Minor issues fixed: {fixed-minors}/{total-minors}
 - [If env-blocked > 0] env-blocked skipped: {count}
 - All tests passing: {yes/no}
 - Review input: {review-artifact}
-- Refinement artifact: {refinement-artifact}
+- Code artifact: {code-artifact}
 
 Next step - re-review or commit:
 - Re-review (always recommended):
-  - Claude Code / OpenCode: /review-task {task-id}
-  - Gemini CLI: /agent-infra:review-task {task-id}
-  - Codex CLI: $review-task {task-id}
+  - Claude Code / OpenCode: /review-code {task-id}
+  - Gemini CLI: /agent-infra:review-code {task-id}
+  - Codex CLI: $review-code {task-id}
 - Commit directly (optional; only when all issues are resolved and changes are low risk):
   - Claude Code / OpenCode: /commit
   - Gemini CLI: /agent-infra:commit
@@ -77,9 +77,9 @@ Next step - re-review or commit:
 
 ## Notes
 
-1. **Prerequisite**: a review artifact must exist (`review.md` or `review-r{N}.md`)
+1. **Prerequisite**: a code review artifact must exist (`review-code.md` or `review-code-r{N}.md`)
 2. **No auto-commit**: do not run `git commit`
 3. **Scope discipline**: only fix reviewed issues
 4. **Disagreement handling**: record any disagreement in the report
-5. **Re-review**: always recommend `review-task` as the default next step after refinement
-6. **Consistency**: the latest review artifact, Activity Log entry, and refinement report must reference the same round
+5. **Re-review**: always recommend `review-code` as the default next step after fix mode
+6. **Consistency**: the latest review artifact, Activity Log entry, and code report must reference the same round