continue-feature

Continue Feature Implementation

Find and implement the next available task from a GitHub-published feature with full Project Roadmap integration.

Prerequisites

• GitHub CLI (gh) authenticated
• Feature published to GitHub (github.md exists in feature folder)

Execution Checklist

Execute ALL steps in order. DO NOT skip any step.

1. Find Feature

Look for feature folder in /specs/{feature-name}/ containing:

• requirements.md - feature requirements
• implementation-plan.md - task breakdown
• github.md - GitHub references (REQUIRED)

If no folder attached: Show incomplete features list

Scan /specs folder for features with github.md:

# Check open issues count for each feature
gh issue list --label "feature/{feature-name}" --state open --json number --limit 100

Use AskUserQuestion to let user select:

{
  "questions": [
    {
      "question": "Which feature to continue?",
      "header": "Select Feature",
      "multiSelect": false,
      "options": [
        {
          "label": "{feature-1}",
          "description": "Phase {X}/{Y}, {N} tasks remaining"
        }
      ]
    }
  ]
}

If github.md missing:

"This feature is not published to GitHub yet. Run /publish-to-github first."

2. Read GitHub References

Parse github.md to extract:

• feature_name from frontmatter
• epic_issue number from frontmatter
• repository from frontmatter
• project_number from frontmatter
• project_id from frontmatter
• fields.status field ID
• fields.start_date field ID
• fields.end_date field ID
• fields.phase field ID

3. Query Open Issues

gh issue list \
  --label "feature/{feature_name}" \
  --state open \
  --json number,title,body,labels \
  --limit 100

4. Identify Current Phase

From returned issues:

1. Skip Epic issue (has epic label)
2. Identify Phase issues by title format: Phase N: {Title}
3. Sort by phase number (Phase 1 → Phase 2 → ...)
4. Find first open Phase

5. Select Next Task

From the current Phase issue body:

1. Parse ## Tasks section
2. Find first unchecked item: - [ ] (not - [x])
3. If all tasks checked: close Phase issue and move to next

If no tasks remaining:

• All Phases closed: "All tasks for {feature_name} completed!"
• Current Phase done: Close Phase issue and continue to next

6. Display Task Info (REQUIRED)

Before implementation, display:

Current Task

Feature: {feature_name}
Phase: {phase_number} - {phase_title}
Task: {task_description}
Issue: #{issue_number}
Roadmap: https://github.com/users/{owner}/projects/{project-number}/views/1

7. Update Project Status to "In Progress" (REQUIRED - MUST EXECUTE)

# Get item ID for the Phase issue
ITEM_ID=$(gh project item-list {project-number} --owner {owner} --format json | jq -r '.items[] | select(.content.number == {phase-issue-number}) | .id')

# Update status to "In Progress"
gh project item-edit --project-id {project-id} --id $ITEM_ID --field-id {status-field-id} --single-select-option-id {in-progress-option-id}

8. Add Progress Comment to Issue (REQUIRED - MUST EXECUTE)

gh issue comment {phase-issue-number} --body "## Task Started

Starting: **{task_description}**

Time: $(date -u +"%Y-%m-%d %H:%M UTC")
Status: In Progress"

9. Read Full Context (REQUIRED)

Before implementing:

1. Read Epic issue for overall context
2. Read requirements.md for feature requirements
3. Use Task tool with Explore subagent to understand codebase patterns

Task tool call:
subagent_type: Explore
prompt: "Explore codebase to understand:
         - Project structure and conventions
         - Existing patterns related to {task}
         - Files that may need modification"

10. Implement Task (REQUIRED)

Implement all tasks following project conventions:

• Follow existing code patterns
• Run lint and typecheck after changes
• Fix errors before proceeding

11. Code Review (REQUIRED - MUST EXECUTE)

After implementation, use Task tool for code review:

Task tool call:
subagent_type: general-purpose
prompt: "Review the code changes for this task:
         - Check code quality and readability
         - Identify potential bugs or missing error handling
         - Verify consistency with existing patterns
         - Suggest improvements if needed"

If critical issues found, fix them before proceeding.

12. Write Unit Tests (REQUIRED - MUST EXECUTE)

After implementation, write and run unit tests:

1. Create test file if not exists
2. Write tests covering the implemented functionality
3. Run tests and ensure they pass

# Example for Node.js
npm test

# Example for Python
pytest

If tests fail, fix the issues before proceeding.

13. Commit Changes (REQUIRED - MUST EXECUTE)

After successful implementation and tests:

git add {changed-files}
git commit -m "{type}: {description}

Implements task from Phase {N}
Issue: #{phase-issue-number}"

14. Update Phase Issue Checklist (REQUIRED - MUST EXECUTE)

Update the Phase issue body to check off completed task:

# Get current body
BODY=$(gh issue view {phase-issue-number} --json body -q '.body')

# Update body with task checked (replace "- [ ] {task}" with "- [x] {task}")
gh issue edit {phase-issue-number} --body "{updated-body-with-checked-task}"

15. Add Implementation Comment (REQUIRED - MUST EXECUTE)

Add a detailed comment to the issue:

gh issue comment {phase-issue-number} --body "## Task Complete: {task_description}

### Changes
- \`{file1}\`: {description}
- \`{file2}\`: {description}

### Tests
- {test_description}: Passed

### Commit
\`{commit-hash}\`

### Progress
Tasks: {completed}/{total} ({percentage}%)
Time: $(date -u +"%Y-%m-%d %H:%M UTC")"

16. Update Project Board Status (REQUIRED - MUST EXECUTE)

If Phase has remaining tasks:

Keep status as "In Progress"

If Phase is complete:

# Update status to "Done"
gh project item-edit --project-id {project-id} --id $ITEM_ID --field-id {status-field-id} --single-select-option-id {done-option-id}

# Update actual end date
gh project item-edit --project-id {project-id} --id $ITEM_ID --field-id {end-date-field-id} --date "$(date +%Y-%m-%d)"

# Close the Phase issue
gh issue close {phase-issue-number} --comment "## Phase Complete

All tasks completed successfully.

### Summary
- Tasks: {total} completed
- Duration: {start_date} to {end_date}
- Commits: {commit_count}"

17. Update Milestone Progress

# Get milestone progress
gh api repos/{owner}/{repo}/milestones/{milestone-number} --jq '{open: .open_issues, closed: .closed_issues}'

18. Report Completion (REQUIRED)

Task Complete

Feature: {feature_name}
Phase: {phase_number} - {phase_title}
Task: {task_description}
Status: Completed

Changes:
- {file1}: {description}
- {file2}: {description}

Commit: {commit-hash}
Tests: Passed

Progress:
- Phase {N}: {completed}/{total} tasks
- Milestone: {closed}/{total} issues closed

Roadmap: https://github.com/users/{owner}/projects/{project-number}/views/1

Next: {next_task_or_phase_info}

19. Prompt for Next Action

Ask user:

{
  "questions": [
    {
      "question": "Continue to next task?",
      "header": "Next Action",
      "multiSelect": false,
      "options": [
        {
          "label": "Continue",
          "description": "Implement next task: {next_task}"
        },
        {
          "label": "Stop",
          "description": "Stop for now"
        }
      ]
    }
  ]
}

Feature Completion

When all phases are complete:

# Update Epic status to Done
EPIC_ITEM_ID=$(gh project item-list {project-number} --owner {owner} --format json | jq -r '.items[] | select(.content.number == {epic-number}) | .id')
gh project item-edit --project-id {project-id} --id $EPIC_ITEM_ID --field-id {status-field-id} --single-select-option-id {done-option-id}
gh project item-edit --project-id {project-id} --id $EPIC_ITEM_ID --field-id {end-date-field-id} --date "$(date +%Y-%m-%d)"

# Close Epic issue
gh issue close {epic-number} --comment "## Feature Complete!

All phases implemented successfully.

### Summary
- Phases: {total} completed
- Total Tasks: {total_tasks}
- Duration: {start_date} to $(date +%Y-%m-%d)

### Phase Details
- Phase 1: {title} - {task_count} tasks
- Phase 2: {title} - {task_count} tasks
...

View the completed roadmap: https://github.com/users/{owner}/projects/{project-number}/views/1"

# Close milestone
gh api repos/{owner}/{repo}/milestones/{milestone-number} --method PATCH -f state="closed"

Error Handling

github.md missing

Guide to run /publish-to-github or use offline mode with implementation-plan.md

All Phases complete

Close Epic issue, update Project, close Milestone, display completion message

lint/typecheck fails

Report errors and suggest fixes

Tests fail

Analyze failures and fix before proceeding

Offline Mode (without GitHub)

If user doesn't use GitHub or gh unavailable, fallback to implementation-plan.md:

1. Parse tasks from implementation-plan.md
2. Track completion locally (check off in file)
3. Skip GitHub-specific steps (7, 8, 14, 15, 16, 17)

IMPORTANT

• Steps 7, 8, 11, 12, 13, 14, 15, 16 MUST be executed
• Code review is MANDATORY before committing
• Unit tests are MANDATORY for all implementations
• Always commit after successful implementation
• Always update issue checklist after task completion
• Always add implementation comment to issue
• Always update Project board status
• Progress comments provide visibility in Roadmap view