/code

name: code
description: |
  Implement ONE pending Phase from subtask plan. Only write code, do not mark checkboxes or run tests.
  Called by autoworker:dispatch. Ends by calling autoworker:checkpoint.

autoworker:code — Implement One Phase

Called by autoworker:dispatch. Does one thing: implement the first incomplete Phase from the subtask plan.

Execution Flow

1. Read Subtask

Glob `subtask_*.md` (exclude subtask_template.md) →
  0 found → stop, prompt to create subtask
  1 found → use directly (backward compatible)
  multiple → grep `status:` to filter:
    - Files without status field treated as active (backward compatible)
    - Exactly 1 active → use it
    - 0 active → list all files + status, prompt user to choose
    - >1 active → report anomaly
→ Read → extract:
- Plan section Phase list (with checkboxes)
- Find the first incomplete Phase (`- [ ]` prefixed Steps)

If subtask doesn't exist or plan is empty → **stop, prompt to complete autoworker:subtask-plan first**. If all Phases are complete → **stop, prompt that autoworker:dispatch should route to autoworker:test**.

2. Implement Code

Read all Steps in the Phase, implement one by one:

1. Read Step description and target file 2. Read target file (if modifying) 3. Edit/Write to implement the code change 4. After completing the Step, continue to next Step

**Executing commands**: Steps may involve not just writing code but also executing commands (starting training, running scripts, etc.). Long-running commands use `run_in_background=true` — execute autonomously, do not ask the user to run manually. After starting background tasks like training, continue to the next step without waiting for completion.

**Forbidden**:

• Writing code from memory without reading subtask
• Skipping Steps (unless subtask explicitly marks as skippable)
• Checking off boxes yourself (autoworker:checkpoint's responsibility)
• Running tests yourself (autoworker:test's responsibility)
• Making changes beyond the current Phase's scope
• Asking user to manually execute commands that can be done autonomously

3. Output Summary

Phase X code implementation complete:
- Step X.1: <brief change description>
- Step X.2: <brief change description>
→ Invoking autoworker:checkpoint

4. Chain: Immediately Invoke autoworker:checkpoint

**After outputting the summary, immediately invoke `autoworker:checkpoint`. Do not wait for user instructions, do nothing else.**

Key Constraints

• **Only one Phase**: Complete it and hand off to checkpoint — don't determine how many Phases remain
• **Only write code**: Don't check boxes, don't run tests, don't make routing decisions
• **Self-debug when hitting issues**: 2 consecutive failures with same approach → enter diagnostic mode (make assumptions explicit → minimum observable unit → build diagnostic tool)
• **Don't return to user mid-way**: Unless hitting a genuine blocker requiring human decision

Important Notes

• **Phase granularity**: A Phase typically contains 2-5 Steps, each Step is a specific file change
• **Files in current Phase**: If a Step says "modify file X", must Read the file before Edit
• **Chaining is mandatory**: Must invoke autoworker:checkpoint after completion, cannot skip or manually substitute