@fitlab-ai/agent-infra 0.4.0 → 0.4.2

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
@@ -27,7 +24,7 @@ After executing this skill, you **must** immediately update task status in task.
 ### 1. Parse the User Description
 
 Extract from the natural-language description:
-- **Task title**: a concise title (maximum 50 characters)
+- **Task title**: a concise title (maximum 50 characters), in the same language as the user's description
 - **Task type**: `feature` | `bugfix` | `refactor` | `docs` | `chore` (infer from the description)
 - **Workflow**: `feature-development` | `bug-fix` | `refactoring` (infer from the type)
 - **Detailed description**: the cleaned-up original user request

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

@@ -1,8 +1,6 @@
 ---
 name: create-task
-description: >
-  根据用户的自然语言描述创建任务骨架。当用户描述一个新功能、Bug 或改进需求时触发。
-  唯一的产出是 task.md —— 不编写任何业务代码。参数：任务描述文本。
+description: "根据自然语言描述创建任务"
 ---
 
 # 创建任务
@@ -26,7 +24,7 @@ description: >
 ### 1. 解析用户描述
 
 从自然语言描述中提取：
-- **任务标题**：简洁标题（最多 50 个字符）
+- **任务标题**：简洁标题（最多 50 个字符），使用与用户描述相同的语言
 - **任务类型**：`feature` | `bugfix` | `refactor` | `docs` | `chore`（从描述推断）
 - **工作流**：`feature-development` | `bug-fix` | `refactoring`（从类型推断）
 - **详细描述**：整理后的用户原始描述

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,37 @@ 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}`
+- review the `## Requirements` section and only change items from `- [ ]` to `- [x]` when they are clearly satisfied by this round's implemented code and passing tests
+- 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