@fitlab-ai/agent-infra 0.4.0 → 0.4.1

package/templates/.agents/skills/create-release-note/SKILL.zh-CN.md

@@ -1,8 +1,6 @@
 ---
 name: create-release-note
-description: >
-  从 PR 和 commit 生成版本发布说明。
-  当用户要求生成发布说明时触发。参数：版本号，可选的上一版本号。
+description: "从 PR 和 commit 生成版本发布说明"
 ---
 
 # 创建发布说明
@@ -11,13 +9,13 @@ description: >
 
 ## 执行流程
 
-### 步骤 1：解析参数
+### 1. 解析参数
 
 从参数中提取：
 - `<version>`：当前发布版本（必需），格式 `X.Y.Z`
 - `<prev-version>`：上一版本（可选），如未提供则自动检测
 
-### 步骤 2：确定版本范围
+### 2. 确定版本范围
 
 **当前标签**：`v<version>`
 
@@ -33,7 +31,7 @@ git rev-parse v<version>
 git rev-parse v<prev-version>
 ```
 
-### 步骤 3：参考历史发布说明格式与分类
+### 3. 参考历史发布说明格式与分类
 
 获取最近多条已发布的 Release Note 作为格式参考，并参考预定义的完整分类清单：
 
@@ -58,7 +56,7 @@ done
 - 后续步骤 7 生成发布说明时，**必须**同时参考步骤 3 的历史格式风格和完整分类清单，保持版本间的一致性
 - 如果没有历史发布说明，则使用步骤 7 中定义的默认格式
 
-### 步骤 4：收集已合并的 PR
+### 4. 收集已合并的 PR
 
 获取标签之间的日期范围，然后查询已合并的 PR：
 
@@ -78,7 +76,7 @@ gh pr list --state merged --base <branch> \
 git log v<prev-version>..v<version> --format="%H %s" --no-merges
 ```
 
-### 步骤 5：收集关联 Issue
+### 5. 收集关联 Issue
 
 从每个 PR body 中提取关联的 Issue：
 - 匹配模式：`Closes #N`、`Fixes #N`、`Resolves #N`（不区分大小写）
@@ -87,7 +85,7 @@ git log v<prev-version>..v<version> --format="%H %s" --no-merges
 gh issue view <N> --json number,title,labels,url
 ```
 
-### 步骤 6：分类变更
+### 6. 分类变更
 
 **按类型**（从 PR 标题的 Conventional Commit 前缀）：
 - `feat`、`perf`、`refactor`、依赖升级 -> Enhancement
@@ -98,7 +96,7 @@ gh issue view <N> --json number,title,labels,url
 - 从 PR 标题中的方括号 `[module]` 或 Conventional scope `feat(module):` 推断模块
 - 兜底：分析变更的文件
 
-### 步骤 7：生成发布说明
+### 7. 生成发布说明
 
 **优先使用步骤 3 中获取的历史格式风格，并确保覆盖步骤 3 列出的所有分类。** 如果存在历史发布说明，严格沿用其章节结构、标题风格（含 emoji）、条目格式和双语布局。
 
@@ -127,7 +125,7 @@ gh issue view <N> --json number,title,labels,url
 4. 贡献者：去重，按贡献数量降序排列
 5. 空部分：省略没有条目的部分
 
-### 步骤 8：展示并确认
+### 8. 展示并确认
 
 向用户展示生成的发布说明。
 
@@ -135,7 +133,7 @@ gh issue view <N> --json number,title,labels,url
 1. 需要调整吗？
 2. 是否创建 GitHub Draft Release？
 
-### 步骤 9：创建 Draft Release（如确认）
+### 9. 创建 Draft Release（如确认）
 
 ```bash
 gh release create v<version> \

package/templates/.agents/skills/create-task/SKILL.md

@@ -1,9 +1,6 @@
 ---
 name: create-task
-description: >
-  Create a task skeleton from the user's natural-language description.
-  Triggered when the user describes a new feature, bug, or improvement request.
-  The only output is task.md; do not write any business code. Argument: task description text.
+description: "Create a task from a natural-language description"
 ---
 
 # Create Task

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

@@ -1,8 +1,6 @@
 ---
 name: create-task
-description: >
-  根据用户的自然语言描述创建任务骨架。当用户描述一个新功能、Bug 或改进需求时触发。
-  唯一的产出是 task.md —— 不编写任何业务代码。参数：任务描述文本。
+description: "根据自然语言描述创建任务"
 ---
 
 # 创建任务

package/templates/.agents/skills/implement-task/SKILL.md

@@ -1,104 +1,63 @@
 ---
 name: implement-task
-description: >
-  Implement a task based on the technical plan, write code and tests, and
-  output an implementation report. Triggered when the user requests task
-  implementation or coding after the technical plan has been reviewed and
-  approved. Argument: task-id.
+description: "Implement a task from its technical plan and output a report"
 ---
 
 # Implement Task
 
+Implement the approved task and produce `implementation.md` or `implementation-r{N}.md`.
+
 ## Boundary / Critical Rules
 
-- Strictly follow the latest technical plan artifact (`plan.md` or `plan-r{N}.md`) -- do not deviate without documenting the reason
-- Do NOT auto-commit. Never execute `git commit` or `git add` automatically
-- This skill outputs an implementation report (`implementation.md` or `implementation-r{N}.md`) and must never overwrite an existing round artifact
-- After executing this skill, you **must** immediately update task status in task.md
+- Follow the latest approved plan artifact: `plan.md` or `plan-r{N}.md`
+- Never auto-run `git add` or `git commit`
+- Create a new implementation artifact for each round and never overwrite an older one
+- After executing this skill, you **must** immediately update task.md
 
 ## Steps
 
 ### 1. Verify Prerequisites
 
-Check required files:
-- `.agents/workspace/active/{task-id}/task.md` - Task file
+Check these files first:
+- `.agents/workspace/active/{task-id}/task.md`
 - At least one technical plan artifact: `plan.md` or `plan-r{N}.md`
 
-Note: `{task-id}` format is `TASK-{yyyyMMdd-HHmmss}`, e.g. `TASK-20260306-143022`
-
-If either file is missing, prompt the user to complete the prerequisite step first.
+If either file is missing, stop and ask the user to complete the prerequisite step.
 
 ### 2. Determine the Input Plan and Implementation Round
 
-Scan `.agents/workspace/active/{task-id}/` for technical plan files (`plan.md`, `plan-r{N}.md`):
-- Read the highest-round plan file and record it as `{plan-artifact}`
-
-Scan `.agents/workspace/active/{task-id}/` for implementation report files:
-- If neither `implementation.md` nor `implementation-r*.md` exists -> this is Round 1 and must create `implementation.md`
-- If `implementation.md` exists and no `implementation-r*.md` exists -> this is Round 2 and must create `implementation-r2.md`
-- If `implementation-r{N}.md` exists -> this is Round N+1 and must create `implementation-r{N+1}.md`
-
-Record:
-- `{plan-artifact}`: the technical plan file used for this implementation
-- `{implementation-round}`: the current implementation round
-- `{implementation-artifact}`: the implementation report filename for this round
-
-Note: multi-round implementation should only happen after a review verdict of Rejected. A normal first implementation always creates `implementation.md`.
+Scan `.agents/workspace/active/{task-id}/` and record:
+- the highest-round plan file as `{plan-artifact}`
+- the next implementation artifact as `implementation.md` or `implementation-r{N}.md`
+- `{implementation-round}` and `{implementation-artifact}`
 
-### 3. Read Technical Plan
+If any `plan-r{N}.md` exists, read the highest-round plan file. Otherwise read `plan.md`.
 
-Carefully read `{plan-artifact}` to understand:
-- Technical approach and solution strategy
-- Detailed implementation steps
-- Files to create/modify
-- Test strategy
-- Any constraints or risks
+### 3. Read the Technical Plan
 
-### 4. Execute Code Implementation
+Read `{plan-artifact}` carefully and extract:
+- implementation steps
+- files to create or modify
+- test strategy
+- constraints, risks, and any approved tradeoffs
 
-Follow the `implementation` step in `.agents/workflows/feature-development.yaml`:
+### 4. Implement the Code
 
-**Required tasks**:
-- [ ] Implement functionality code following the plan
-- [ ] Write comprehensive unit tests
-- [ ] Run tests locally to verify functionality
-- [ ] Update related documentation and comments
-- [ ] Follow project coding standards (see project instructions)
+Follow `.agents/workflows/feature-development.yaml` and the plan in order.
 
-**Implementation principles**:
-1. **Strictly follow the plan**: Do not deviate from the technical plan
-2. **Step by step**: Execute plan steps in order
-3. **Test continuously**: Run tests after completing each step
-4. **Keep it simple**: Do not over-engineer or add unplanned features
+> Detailed implementation rules, testing discipline, and deviation handling live in `reference/implementation-rules.md`. Read `reference/implementation-rules.md` before executing this step.
 
 ### 5. Run Test Verification
 
-Execute the project's test command. Reference the `test` skill for the project-specific test command:
+Use the project test command from the `test` skill and keep iterating until all required tests pass.
 
-```bash
-# Check .agents/skills/test/SKILL.md for the project's test command
-# Common patterns:
-# npm test          (Node.js)
-# mvn test          (Maven)
-# pytest            (Python)
-# go test ./...     (Go)
-```
-
-If tests fail:
-- Analyze the failure first, and prioritize fixing problems introduced by the current implementation, plus any test or documentation updates required to match the approved plan
-- Re-run the tests after each fix until they pass, or until you confirm the remaining issue is an external blocker outside the current task scope
-- Only stop when the failure is blocked by external dependencies, missing environment, or unclear requirements that cannot be resolved within the task; in that case, report the blocker and do not create the implementation report, update task.md as implementation-complete, or output the Step 8 completion template
+If tests fail, Attempt to fix the issue and re-run tests first. Only stop when you confirm an external blocker, missing environment, or unclear requirement that is out of scope for the task.
 
-Proceed to Steps 6, 7, and 8 only after the full test suite passes.
-
-### 6. Output Implementation Report
+### 6. Write the Implementation Report
 
 Create `.agents/workspace/active/{task-id}/{implementation-artifact}`.
 
-Requirements:
-- Do not overwrite any existing implementation report
-- Record the actual round number and artifact filename in the report
-- If this is a re-implementation round, explain what triggered it
+> Report structure, required sections, and the full template live in `reference/report-template.md`. Read `reference/report-template.md` before writing the report.
 
 ### 7. Update Task Status
 
@@ -110,125 +69,36 @@ date "+%Y-%m-%d %H:%M:%S"
 
 Update `.agents/workspace/active/{task-id}/task.md`:
 - `current_step`: implementation
-- `assigned_to`: {current AI agent}
+- `assigned_to`: {current agent}
 - `updated_at`: {current time}
-- Record the implementation artifact for this round: `{implementation-artifact}` (Round `{implementation-round}`)
-- Mark implementation as complete in workflow progress and include the actual round when the task template supports it
-- **Append** to `## Activity Log` (do NOT overwrite previous entries):
-  ```
-  - {yyyy-MM-dd HH:mm:ss} — **Implementation (Round {N})** by {agent} — Code implemented, {n} files modified, {n} tests passed → {artifact-filename}
-  ```
-
-### 8. Inform User
-
-> **IMPORTANT**: All TUI command formats listed below must be output in full. Do not show only the format for the current AI agent.
-
-Output format:
-```
-Implementation complete for task {task-id}.
-
-Summary:
-- Modified files: {count}
-- New files: {count}
-- Tests passed: {count}/{total}
-
-Output file:
-- Implementation report: .agents/workspace/active/{task-id}/{implementation-artifact} (Round {implementation-round})
-
-Next step - code review:
-  - Claude Code / OpenCode: /review-task {task-id}
-  - Gemini CLI: /{{project}}:review-task {task-id}
-  - Codex CLI: $review-task {task-id}
-```
-
-## Output Template
-
-```markdown
-# Implementation Report
-
-- **Implementation round**: Round {implementation-round}
-- **Artifact file**: `{implementation-artifact}`
+- record `{implementation-artifact}` for Round `{implementation-round}`
+- append:
+  `- {yyyy-MM-dd HH:mm:ss} — **Implementation (Round {N})** by {agent} — Code implemented, {n} files modified, {n} tests passed → {implementation-artifact}`
 
-## Modified Files
+### 8. Inform the User
 
-### New Files
-- `{file-path}` - {Description}
-
-### Modified Files
-- `{file-path}` - {Summary of changes}
-
-## Key Code Explanation
-
-### {Module/Feature Name}
-**File**: `{file-path}:{line-number}`
-
-**Implementation logic**:
-{Explanation of important logic}
-
-**Key code**:
-```{language}
-{Key code snippet}
-```
-
-## Test Results
-
-### Unit Tests
-- Test file: `{test-file-path}`
-- Test cases: {count}
-- Pass rate: {percentage}
-
-**Test output**:
-```
-{Test run results}
-```
-
-## Differences from Plan
-
-{If implementation differs from plan, explain why}
-
-## Items for Review
-
-**Points that need reviewer attention**:
-- {Attention point 1}
-- {Attention point 2}
-
-## Known Issues
-
-{Issues discovered during implementation or items to optimize later}
-
-## Next Steps
-
-{Suggestions for code review or follow-up work}
-```
+Output the implementation summary and include all TUI command variants for the next review step.
 
 ## Completion Checklist
 
-- [ ] Completed all code implementation
-- [ ] Created implementation report `.agents/workspace/active/{task-id}/{implementation-artifact}`
-- [ ] All tests pass
-- [ ] Updated `current_step` to implementation in task.md
-- [ ] Updated `updated_at` to current time in task.md
-- [ ] Updated `assigned_to` in task.md
-- [ ] Appended entry to Activity Log in task.md
-- [ ] Marked implementation as complete in workflow progress
-- [ ] Informed user of next step (must include all TUI command formats — do not filter)
+- [ ] Implemented the approved code changes
+- [ ] Created `{implementation-artifact}`
+- [ ] All required tests passed
+- [ ] Updated task.md and appended the Activity Log entry
+- [ ] Included every TUI command format in the user-facing next step
 
 ## STOP
 
-After completing the checklist, **stop**. Do not auto-commit. Wait for code review before submission.
+Stop after the checklist is complete. Do not auto-commit.
 
 ## Notes
 
-1. **Prerequisites**: Must have a reviewed technical plan (`plan.md` or `plan-r{N}.md` exists and is approved)
-2. **No auto-commit**: Do NOT execute `git commit` or `git add` automatically. Remind the user to commit manually
-3. **Test requirement**: All new code must have unit tests; test coverage must not decrease. When removing a feature, delete the test fixtures and assertions that existed solely for that feature — do not mechanically flip assertions; every assertion must verify meaningful business logic, not merely confirm that data passes through unchanged
-4. **Code quality**: Follow project coding standards
-5. **Plan deviation**: If you need to deviate from the plan, document the reason in the implementation report
-6. **Versioning rule**: First-round implementation uses `implementation.md`; later re-implementations use `implementation-r{N}.md`
+- Round 1 uses `implementation.md`; later rounds use `implementation-r{N}.md`
+- Record any deviation from `{plan-artifact}` in the report
+- New tests must validate meaningful business behavior, not just passthrough data
 
 ## Error Handling
 
-- Task not found: Prompt "Task {task-id} not found"
-- Missing plan: Prompt "Technical plan not found, please run the plan-task skill first"
-- Test failure: Attempt to fix the issue and re-run tests first; stop only when an external blocker, missing environment, or unclear requirement prevents completion, and report that blocker
-- Build failure: Output build errors, stop implementation
+- Task not found: `Task {task-id} not found`
+- Missing plan: `Technical plan not found, please run the plan-task skill first`
+- Test failure after local fixes: explain the external blocker and stop without creating the implementation artifact

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

@@ -1,102 +1,63 @@
 ---
 name: implement-task
-description: >
-  根据技术方案实施任务，编写代码和测试，输出实现报告。当用户在技术方案审查通过后要求实施任务或编码时触发。
-  参数：task-id。
+description: "根据技术方案实施任务并输出报告"
 ---
 
 # 实施任务
 
+根据已批准的技术方案实施任务，并产出 `implementation.md` 或 `implementation-r{N}.md`。
+
 ## 行为边界 / 关键规则
 
-- 严格遵循最新技术方案产物（`plan.md` 或 `plan-r{N}.md`）—— 不要偏离，除非记录了偏离原因
-- 不要自动提交。绝不自动执行 `git commit` 或 `git add`
-- 本技能产出实现报告（`implementation.md` 或 `implementation-r{N}.md`）—— 不覆盖已有轮次产物
-- 执行本技能后，你**必须**立即更新 task.md 中的任务状态
+- 严格遵循最新方案产物：`plan.md` 或 `plan-r{N}.md`
+- 绝不自动执行 `git add` 或 `git commit`
+- 每轮实现都创建新的实现产物，不覆盖旧文件
+- 执行本技能后，你**必须**立即更新 task.md
 
 ## 执行步骤
 
 ### 1. 验证前置条件
 
-检查必要文件：
-- `.agents/workspace/active/{task-id}/task.md` - 任务文件
+先检查：
+- `.agents/workspace/active/{task-id}/task.md`
 - 至少一个技术方案产物：`plan.md` 或 `plan-r{N}.md`
 
-注意：`{task-id}` 格式为 `TASK-{yyyyMMdd-HHmmss}`，例如 `TASK-20260306-143022`
-
-如果任一文件缺失，提示用户先完成前置步骤。
+如果缺少任一文件，立即停止并提示用户先完成前置步骤。
 
 ### 2. 确定输入方案与实现轮次
 
-扫描 `.agents/workspace/active/{task-id}/` 目录中的技术方案文件（`plan.md`、`plan-r{N}.md`）：
-- 读取最高轮次的方案文件，记为 `{plan-artifact}`
-
-扫描 `.agents/workspace/active/{task-id}/` 目录中的实现报告文件：
-- 如果不存在 `implementation.md` 且不存在 `implementation-r*.md` → 本轮为第 1 轮，产出 `implementation.md`
-- 如果存在 `implementation.md` 且不存在 `implementation-r*.md` → 本轮为第 2 轮，产出 `implementation-r2.md`
-- 如果存在 `implementation-r{N}.md` → 本轮为第 N+1 轮，产出 `implementation-r{N+1}.md`
+扫描 `.agents/workspace/active/{task-id}/` 并记录：
+- 最高轮次的方案文件为 `{plan-artifact}`
+- 本轮实现产物为 `implementation.md` 或 `implementation-r{N}.md`
+- `{implementation-round}` 与 `{implementation-artifact}`
 
-记录：
-- `{plan-artifact}`：本次实现遵循的技术方案文件
-- `{implementation-round}`：本轮实现轮次
-- `{implementation-artifact}`：本轮实现报告文件名
-
-注意：仅在审查结论为“拒绝”后重新执行时才会进入多轮。正常首次实现始终产出 `implementation.md`。
+如果存在 `plan-r{N}.md`，读取最高轮次的方案文件；否则读取 `plan.md`。
 
 ### 3. 阅读技术方案
 
-仔细阅读 `{plan-artifact}` 以理解：
-- 技术方法和解决策略
-- 详细实施步骤
-- 需要创建/修改的文件
+仔细阅读 `{plan-artifact}`，提取：
+- 实施步骤
+- 需要创建或修改的文件
 - 测试策略
-- 任何约束或风险
+- 约束、风险与已批准的取舍
 
 ### 4. 执行代码实现
 
-遵循 `.agents/workflows/feature-development.yaml` 中的 `implementation` 步骤：
-
-**必要任务**：
-- [ ] 按照计划实现功能代码
-- [ ] 编写全面的单元测试
-- [ ] 在本地运行测试以验证功能
-- [ ] 更新相关文档和注释
-- [ ] 遵循项目编码规范（参见项目指南）
+按照 `.agents/workflows/feature-development.yaml` 和方案顺序实施。
 
-**实现原则**：
-1. **严格遵循计划**：不偏离技术方案
-2. **逐步执行**：按顺序执行计划步骤
-3. **持续测试**：每完成一个步骤后运行测试
-4. **保持简单**：不过度设计，不添加计划外的功能
+> 详细实现规则、测试纪律和偏离处理见 `reference/implementation-rules.md`。执行此步骤前，先读取 `reference/implementation-rules.md`。
 
 ### 5. 运行测试验证
 
-执行项目的测试命令。参考 `test` 技能获取项目特定的测试命令：
+使用 `test` 技能中的项目测试命令，直到所有必需测试通过。
 
-```bash
-# 查看 .agents/skills/test/SKILL.md 获取项目测试命令
-# 常见模式：
-# npm test          (Node.js)
-# mvn test          (Maven)
-# pytest            (Python)
-# go test ./...     (Go)
-```
-
-如果测试失败：
-- 先分析失败原因，优先修复由本次实现引入的问题，以及为匹配已批准方案而需要同步调整的测试或文档
-- 修复后重新运行测试，直到测试通过，或明确确认存在超出当前任务范围的外部阻塞
-- 仅当问题属于外部阻塞、环境缺失或需求不明确且无法在当前任务内解决时，才向用户报告阻塞并停止；此时不要创建实现报告，不要更新 task.md 为实现完成，也不要输出步骤 8 的完成模板
+如果测试失败，先尝试修复并重新运行测试。只有在确认存在外部阻塞、环境缺失或需求不明确且超出任务范围时，才可以停止。
 
-只有全部测试通过后，才可以继续步骤 6、7 和 8。
-
-### 6. 输出实现报告
+### 6. 编写实现报告
 
 创建 `.agents/workspace/active/{task-id}/{implementation-artifact}`。
 
-要求：
-- 不要覆盖已有的实现报告
-- 在报告中明确记录本轮轮次编号和实际产物文件名
-- 如果本轮是重实现，说明其触发原因（例如上一轮审查结论为 Rejected）
+> 报告结构、必填章节和完整模板见 `reference/report-template.md`。写报告前先读取 `reference/report-template.md`。
 
 ### 7. 更新任务状态
 
@@ -108,125 +69,36 @@ date "+%Y-%m-%d %H:%M:%S"
 
 更新 `.agents/workspace/active/{task-id}/task.md`：
 - `current_step`：implementation
-- `assigned_to`：{当前 AI 代理}
+- `assigned_to`：{当前代理}
 - `updated_at`：{当前时间}
-- 记录本轮实现产物：`{implementation-artifact}`（Round `{implementation-round}`）
-- 在工作流进度中标记 implementation 为已完成，并注明实际轮次（如果任务模板支持）
-- **追加**到 `## Activity Log`（不要覆盖之前的记录）：
-  ```
-  - {yyyy-MM-dd HH:mm:ss} — **Implementation (Round {N})** by {agent} — Code implemented, {n} files modified, {n} tests passed → {artifact-filename}
-  ```
+- 记录 Round `{implementation-round}` 的 `{implementation-artifact}`
+- 追加：
+  `- {yyyy-MM-dd HH:mm:ss} — **Implementation (Round {N})** by {agent} — Code implemented, {n} files modified, {n} tests passed → {implementation-artifact}`
 
 ### 8. 告知用户
 
-> **重要**：以下「下一步」中列出的所有 TUI 命令格式必须完整输出，不要只展示当前 AI 代理对应的格式。
-
-输出格式：
-```
-任务 {task-id} 实现完成。
-
-摘要：
-- 修改文件：{数量}
-- 新建文件：{数量}
-- 测试通过：{数量}/{总数}
-
-产出文件：
-- 实现报告：.agents/workspace/active/{task-id}/{implementation-artifact}（Round {implementation-round}）
-
-下一步 - 代码审查：
-  - Claude Code / OpenCode：/review-task {task-id}
-  - Gemini CLI：/{{project}}:review-task {task-id}
-  - Codex CLI：$review-task {task-id}
-```
-
-## 输出模板
-
-```markdown
-# 实现报告
-
-- **实现轮次**：Round {implementation-round}
-- **产物文件**：`{implementation-artifact}`
-
-## 修改文件
-
-### 新建文件
-- `{file-path}` - {描述}
-
-### 修改文件
-- `{file-path}` - {变更摘要}
-
-## 关键代码说明
-
-### {模块/功能名称}
-**文件**：`{file-path}:{line-number}`
-
-**实现逻辑**：
-{重要逻辑的说明}
-
-**关键代码**：
-```{language}
-{关键代码片段}
-```
-
-## 测试结果
-
-### 单元测试
-- 测试文件：`{test-file-path}`
-- 测试用例数：{数量}
-- 通过率：{百分比}
-
-**测试输出**：
-```
-{测试运行结果}
-```
-
-## 与计划的差异
-
-{如果实现与计划有差异，说明原因}
-
-## 审查关注点
-
-**需要审查者注意的要点**：
-- {关注点 1}
-- {关注点 2}
-
-## 已知问题
-
-{实现过程中发现的问题或后续需要优化的事项}
-
-## 后续步骤
-
-{代码审查或后续工作的建议}
-```
+输出实现摘要，并完整展示下一步代码审查的所有 TUI 命令格式。
 
 ## 完成检查清单
 
-- [ ] 完成了所有代码实现
-- [ ] 创建了实现报告 `.agents/workspace/active/{task-id}/{implementation-artifact}`
-- [ ] 所有测试通过
-- [ ] 更新了 task.md 中的 `current_step` 为 implementation
-- [ ] 更新了 task.md 中的 `updated_at` 为当前时间
-- [ ] 更新了 task.md 中的 `assigned_to`
-- [ ] 追加了 Activity Log 条目到 task.md
-- [ ] 在工作流进度中标记了 implementation 为已完成
-- [ ] 告知了用户下一步（必须展示所有 TUI 的命令格式，不要筛选）
+- [ ] 已完成批准范围内的代码实现
+- [ ] 已创建 `{implementation-artifact}`
+- [ ] 所有必需测试通过
+- [ ] 已更新 task.md 并追加 Activity Log
+- [ ] 已向用户展示所有 TUI 格式的下一步命令
 
 ## 停止
 
-完成检查清单后，**停止**。不要自动提交。等待代码审查后再提交。
+完成检查清单后立即停止。不要自动提交。
 
 ## 注意事项
 
-1. **前置条件**：必须有已审查的技术方案（`plan.md` 或 `plan-r{N}.md` 存在且已获批准）
-2. **禁止自动提交**：不要自动执行 `git commit` 或 `git add`。提醒用户手动提交
-3. **测试要求**：所有新代码必须有单元测试；测试覆盖率不得下降。删除功能时，必须同时删除为该功能而存在的测试 fixture 和断言，不要机械地翻转断言方向；每条断言都应验证有意义的业务逻辑，仅确认数据原样通过的断言不构成有效测试
-4. **代码质量**：遵循项目编码规范
-5. **计划偏离**：如果需要偏离计划，在实现报告中记录原因
-6. **版本化规则**：首轮实现使用 `implementation.md`；后续重实现使用 `implementation-r{N}.md`
+- 首轮实现使用 `implementation.md`，后续轮次使用 `implementation-r{N}.md`
+- 如偏离 `{plan-artifact}`，必须在报告中记录原因
+- 新测试必须验证有意义的业务行为，而不是机械透传
 
 ## 错误处理
 
-- 任务未找到：提示 "Task {task-id} not found"
-- 缺少计划：提示 "Technical plan not found, please run the plan-task skill first"
-- 测试失败：先尝试修复并重新运行测试；只有在存在外部阻塞、环境缺失或需求不明确时才停止，并输出阻塞原因
-- 构建失败：输出构建错误，停止实现
+- 任务未找到：`Task {task-id} not found`
+- 缺少方案：`Technical plan not found, please run the plan-task skill first`
+- 本地修复后仍无法通过测试：说明外部阻塞并停止，且不要创建实现产物