/execute-ticket

name: execute-ticket
description: Execute a Jira ticket following its implementation plan
argument-hint: <ticket-key>

Ticket Execution Workflow

**Target Ticket:** $ARGUMENTS

---

Phase 0: Context Retrieval

1. **Fetch the Jira ticket** using `{Target_Ticket}`

2. **Verify ticket is self-contained** with:

• Implementation steps
• Files to modify
• Test code
• Acceptance criteria

3. **Extract document links** (for context/reference only):

• `{Overview_Document}` - Epic context
• `{Implementation_Plan}` - Coordination/tracking

4. **FAILURE CONDITION - Missing Implementation Details:**

If the ticket lacks implementation steps or test code:

**STOP and prompt the user:**

   Ticket {Target_Ticket} is missing implementation details.

   Found: [list what's present]
   Missing: [list what's missing]

   Options:
   1. I can analyze the codebase and generate the missing details
   2. Please update the ticket with implementation details first

5. **CHECKPOINT:** Confirm ticket details and approach with user before proceeding.

---

Phase 1: Preparation

1. **Mandatory: Review the ticket's implementation steps** (primary source of truth) 2. **Mandatory: Read the implementation plan** for wave/dependency context 3. **Mandatory: Explore the codebase** for relevant patterns and unforseen sideffects 4. **Mandatory: Check for parallel execution opportunities** (see below)

---

Parallel Execution Check

After reading the implementation plan, check for a **Parallel Execution Strategy** section:

1. **If parallel waves are defined:**

• Identify the current wave (first wave with incomplete tickets)
• All tickets in the same wave can be executed **simultaneously**
• Consider delegating wave tickets to specialized agents in parallel:
• Frontend work → frontend-developer agent
• Backend work → backend-developer agent
• Database work → database-optimizer agent
• Test coverage → test-automator agent
• Present the parallel execution opportunity to the user for approval

2. **Parallel execution prompt to user:**

   The implementation plan defines parallel execution waves.

   Current Wave: [N]
   Tickets ready for parallel execution:
   - TICKET-101: [title] → recommended: [agent-type]
   - TICKET-102: [title] → recommended: [agent-type]
   - TICKET-103: [title] → recommended: [agent-type]

   Options:
   A) Execute all wave tickets in parallel (spawn multiple agents)
   B) Execute tickets sequentially (one at a time)
   C) Select specific tickets to parallelize

   Which approach? [A/B/C]

3. **If user approves parallel execution:**

• Launch specialized agents concurrently for each ticket
• Each agent works independently on their assigned ticket
• Coordinate completion before advancing to next wave

---

Phase 2: Implementation

6. **CHECKPOINT:** Confirm ticket selection and approach with user 7. Update Jira status to "In Progress" 8. **Write a failing test for the ticket's acceptance criteria** (unit, integration, E2E as needed) before touching production code

• Tests live in the repo and run in CI. Ad hoc scripts and manual runs are extra evidence, never the test

9. **Record the RED result:** run the new tests and confirm each one fails for the reason the ticket describes

• A test that passes before the change, or fails for another reason (import error, typo, missing fixture), is rewritten until it fails correctly
• Keep the failure output for the completion summary

10. **Make the tests pass:** execute the implementation steps from the plan until the new tests and the existing suite are green 11. **Refactor** with the tests green 12. Verify all acceptance criteria are met

**Tickets with no code** (docs, prompts, configuration): name the check that stands in for the test (a validator, a grep, a fixture run) and record its RED result before making the change, the same way.

---

Phase 3: Completion

13. Present implementation summary and commit message for user review (see Output format below)

**Note:** The user will handle git commit and PR creation. When ready to finalize, the user runs `/complete-ticket` to transition Jira and update the implementation plan.

---

User Checkpoints

**STOP and check in with the user at these points:**

1. **Before starting:** Confirm ticket selection and planned approach 2. **On deviation:** Stop and get approval (see Deviation Handling) 3. **On blocker:** Report the issue and wait for guidance 4. **When complete:** Present commit message and summary for user review

---

Execution Checklist

Before Starting

• [ ] Read the ticket's section in the implementation plan
• [ ] Verify all blocking tickets are complete (check Jira status)
• [ ] **CHECKPOINT:** Confirm ticket and approach with user
• [ ] Move ticket to "In Progress" in Jira

During Implementation

• [ ] Reference existing codebase patterns
• [ ] Write failing tests for the acceptance criteria first:
• Unit tests for new functions/components
• Integration tests for API/service interactions
• E2E tests for user flows (if applicable)
• [ ] Record RED: each new test fails for the reason the ticket describes
• [ ] Create/modify files as specified, following the plan's implementation steps, until the tests pass
• [ ] Refactor with the tests green

Before Marking Complete

• [ ] Pre-commit hooks pass (linting, formatting, type checks)
• [ ] Pre-push hooks pass (tests, build)
• [ ] All new tests written and passing
• [ ] All existing tests continue to pass
• [ ] 90% branch coverage maintained
• [ ] All Jira ticket acceptance criteria met

Completion

• [ ] Present commit message and implementation summary for user review

---

Suggested Commit Message Format

When implementation is complete, present this for user review:

{Target_Ticket}: Brief summary of changes

- Change 1 description
- Change 2 description
- Change 3 description

---

Deviation Handli